Upload 27 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Models/face_landmarker.task filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirments.txt
+RUN apt-get update && apt-get  install ffmpeg libsm6 libxext6 -y
+RUN pip install --no-cache-dir --upgrade -r /code/requirments.txt
+
+COPY . .
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

FaceRecognition/ModelTrainer.py

@@ -0,0 +1,385 @@
+import tensorflow as tf
+
+import numpy as np
+from tensorflow_hub import KerasLayer
+import os
+
+from keras.layers import Dense,Dropout,Input,BatchNormalization,Lambda
+from keras.models import Model
+from keras.optimizers import Adam
+from keras import Sequential
+from keras.callbacks import EarlyStopping,ModelCheckpoint
+from keras.layers.experimental.preprocessing import RandomRotation,RandomFlip,RandomCrop,PreprocessingLayer
+from tensorflow.math import l2_normalize
+from sys import argv
+
+User=argv[1]
+
+NegativeDatasetPath="./FaceRecognition/ExtactedFaces/Negative/"
+TrainUsersDatasetPath="./FaceRecognition/ExtactedFaces/Train/"
+TestUsersDatasetPath="./FaceRecognition/ExtactedFaces/Test/"
+DatasetPath="./FaceRecognition/ExtactedFaces/Dataset/"
+def DatasetPaths(UserDatapath,state,NegativeDatasetPath=None,DatasetPath=None):
+    User=os.listdir(UserDatapath)
+    UserFiles=[]
+    UserLabels=[]
+    for folder in User:
+        for file in os.listdir(UserDatapath+folder):
+            UserFiles.append(UserDatapath+folder+'/'+file)
+            UserLabels.append(folder)
+    
+    if state==True:
+        
+        Negativefiles=[]
+        NegativeLabels=[]
+        DatasetPathfiles=[]
+        for file in os.listdir(NegativeDatasetPath):
+            Negativefiles.append(NegativeDatasetPath+file)
+            NegativeLabels.append(file.split(",")[0])
+            
+            
+        for file in os.listdir(DatasetPath):
+            DatasetPathfiles.append(DatasetPath+file)
+            
+            
+        return np.array(Negativefiles),np.array(NegativeLabels),np.array(UserFiles),np.array(UserLabels),np.array(DatasetPathfiles)
+    return np.array(UserFiles),np.array(UserLabels)
+
+
+Negativefiles,NegativeLabels,UserFiles,UserLabels,DatasetPathfiles=DatasetPaths(TrainUsersDatasetPath,True,NegativeDatasetPath,DatasetPath)
+Negativefiles,NegativeLabels,UserFiles,UserLabels,DatasetPathfiles
+TrainClasses=np.unique(UserLabels)
+TrainClassesCount=len(TrainClasses)
+
+TestUserFiles,TestUserLabels=DatasetPaths(UserDatapath=TestUsersDatasetPath,state=False)
+TestClasses=np.unique(TestUserLabels)
+TestClassesCount=len(TestClasses)
+
+mask=np.zeros(shape=(224,224,3))
+mask[:,:,0]=200
+mask[:,:,1]=100
+mask[:,:,2]=200
+mask=tf.cast(mask/255,tf.float32)
+FliPer=RandomFlip(mode="horizontal",)
+Rotater=RandomRotation([-0.135,0.135])
+def PreProcessInput(Image,num):
+    if num ==0:
+        Image=FliPer(Image)
+    elif num==1:
+        Image= 0.75*Image+0.25*mask
+    if num<=2:
+        return Rotater(Image)
+    
+    else:
+        return Image
+    
+@tf.function
+def load_image(Anchor,Positive,Nagative,State):
+
+    Anchor=tf.io.read_file(Anchor)
+    Anchor=tf.image.decode_jpeg(Anchor)
+    Anchor = tf.cast(Anchor, tf.float32)
+    Anchor = tf.image.resize(Anchor, [224,224], method = tf.image.ResizeMethod.NEAREST_NEIGHBOR)
+    ranA=tf.random.uniform(shape=[1],minval=0,maxval=6,dtype=tf.int32)
+    
+    Positive=tf.io.read_file(Positive)
+    Positive=tf.image.decode_jpeg(Positive)
+    Positive = tf.cast(Positive, tf.float32)
+    Positive = tf.image.resize(Positive, [224,224], method = tf.image.ResizeMethod.NEAREST_NEIGHBOR)
+    ranB=tf.random.uniform(shape=[1],minval=0,maxval=6,dtype=tf.int32)
+    
+    Negative=tf.io.read_file(Nagative)
+    Negative=tf.image.decode_jpeg(Negative)
+    Negative = tf.cast(Negative, tf.float32)
+    Negative = tf.image.resize(Negative, [224,224], method = tf.image.ResizeMethod.NEAREST_NEIGHBOR)
+    ranN=tf.random.uniform(shape=[1],minval=0,maxval=6,dtype=tf.int32)
+    if State:
+        Anchor=PreProcessInput(Anchor/255,ranA)
+        Positive=PreProcessInput(Positive/255,ranB)
+        Negative=PreProcessInput(Negative/255,ranN)
+    else:
+        Anchor=Anchor/255
+        Positive=Positive/255
+        Negative=Negative/255
+    
+    return (Anchor,Positive,Negative)
+
+
+def DatasetTripletsGenerator(State):
+    #     Negativefiles=Negativefiles
+#     NegativeLabels=NegativeLabels
+#     DatasetPathfiles=DatasetPathfiles
+    if State:
+        UsersImagesPath=UserFiles
+        UsersImagesLabel=UserLabels
+        ClassesCount=TrainClassesCount
+        Classes=TrainClasses
+        
+    else:
+        ImagesName=TestUserFiles
+        ImagesLabel=TestUserLabels
+        ClassesCount=TestClassesCount
+        Classes=TestClasses
+        
+        
+   
+    for i in range(ClassesCount):
+        class_=Classes[i]
+        files=UsersImagesPath[UsersImagesLabel==class_]
+        
+        files_num=len(files)
+        for index in range(files_num-1):
+            for j in range(index+1,files_num):
+                ancore=files[index]
+                positive=files[j]
+                random=np.random.randint(0,high=10)
+                negative=None
+                if random<=3:
+                    negative=Negativefiles[NegativeLabels==class_]
+                    if type(negative)==list:
+                        negative=np.random.choice(negative)
+                elif random<=7:
+                    negative=UsersImagesPath[UsersImagesLabel != class_]
+                    if type(negative)==list:
+                        negative=np.random.choice(negative)
+                   
+                elif random<=10:
+                    negative=DatasetPathfiles
+                    if type(negative)==list:
+                        negative=np.random.choice(negative)
+                
+                if type(negative)!=str:
+                    negative=np.random.choice(DatasetPathfiles)
+                
+                    
+                
+                
+                yield ancore,positive,negative,State
+
+
+@tf.function
+def EmbeddingImageLoader(Anchor,Label):
+
+    Anchor=tf.io.read_file(Anchor)
+    Anchor=tf.image.decode_jpeg(Anchor)
+    Anchor = tf.cast(Anchor, tf.float32)
+    Anchor = tf.image.resize(Anchor, [224,224], method = tf.image.ResizeMethod.NEAREST_NEIGHBOR)
+    
+    Anchor=Anchor/255
+       
+    
+    return (Anchor,Label)
+
+
+TrainData=tf.data.Dataset.from_generator(DatasetTripletsGenerator,args=[True],output_types=(tf.string,tf.string,tf.string,tf.bool),output_shapes=((),(),(),()),name="DataLoaderPipeline")
+TrainData=TrainData.map(load_image)
+TrainData=TrainData.batch(2).shuffle(buffer_size=10)
+
+TestData=tf.data.Dataset.from_generator(DatasetTripletsGenerator,args=[False],output_types=(tf.string,tf.string,tf.string,tf.bool),output_shapes=((),(),(),()),name="DataLoaderPipeline")
+TestData=TestData.map(load_image).batch(2)
+
+EmbeddingData=tf.data.Dataset.from_tensor_slices((list(UserFiles),list(UserLabels))).map(EmbeddingImageLoader).batch(1)
+
+
+class DistanceLayer(tf.keras.layers.Layer):
+    def __init__(self):
+        super().__init__()
+    def call(self,anchor,positive,negative):
+        dis_ap=tf.reduce_sum(tf.square(anchor - positive), 1)  ## distance between anchor and positive 
+        dis_an=tf.reduce_sum(tf.square(anchor - negative), 1)   ## distance between anchor and negative
+        return  dis_ap , dis_an
+ 
+def GetEncoder():
+#     /drive/MyDrive/Model/
+    if os.path.isdir("./FaceRecognition/FaceModel/keras/"):
+        return tf.keras.models.load_model("./FaceRecognition/FaceModel/")
+    else:
+        pretrained_model = KerasLayer("./prtrained/archive/",trainable=False) ##pretraind Model
+
+        encode_model = Sequential([
+            pretrained_model,
+            Dropout(0.2),
+            Dense(512, activation='relu'),
+            BatchNormalization(),
+            Dense(128, activation="relu"),
+            Lambda(lambda x:l2_normalize(x))
+        ], name="Encoder")
+        return encode_model
+def SiameseNetwork(inputshape=(224,224,3)):
+    An_input=Input(shape=inputshape)
+    
+    Po_input=Input(shape=inputshape)
+    
+    Ne_input=Input(shape=inputshape)
+    
+    encoder=GetEncoder()
+    
+    An_embeding=encoder(An_input)
+    Po_embeding=encoder(Po_input)
+    Ne_embeding=encoder(Ne_input)
+    
+    
+    distanc=DistanceLayer()(An_embeding,Po_embeding,Ne_embeding) #return distance between (A and B) and (A and N)
+    
+    return Model(inputs=[An_input,Po_input,Ne_input],outputs=distanc)
+
+
+
+
+siames_net=SiameseNetwork()
+class SiamesModel(Model):
+    def __init__(self,siames_net,DesiredDistance):
+        super(SiamesModel, self).__init__()
+        
+        self.Model=siames_net
+        self.DesiredDistance=DesiredDistance
+        self.LossTracker=tf.keras.metrics.Mean(name="Loss")
+        
+        self.VALTracker=tf.keras.metrics.Mean(name="VAL")
+        
+        self.PmeanTracker=tf.keras.metrics.Mean(name="P_mean")
+        
+        self.PmaxTracker=tf.keras.metrics.Mean(name="P_max")
+        
+        self.PstdTracker=tf.keras.metrics.Mean(name="P_std")
+        
+        self.FARTracker=tf.keras.metrics.Mean(name="FAR")
+        
+        self.N_meanTracker=tf.keras.metrics.Mean(name="N_mean")
+        
+        self.NstdTracker=tf.keras.metrics.Mean(name="N_std")
+        self.NminTracker=tf.keras.metrics.Mean(name="N_min")
+        
+    def call(self,data):
+        return self.Model(data)
+    
+    def train_step(self,data):
+        with tf.GradientTape() as Tape:
+            AP_distanc,AN_distance=self.Model(data)
+            loss=self.TripLoss(AP_distanc,AN_distance)
+            gradients=Tape.gradient(loss,self.Model.trainable_weights)
+            self.optimizer.apply_gradients(zip(gradients, self.Model.trainable_weights))
+        self.DistanceEval(AP_distanc,AN_distance)
+        self.LossTracker.update_state(loss)
+        return {"VAL":self.VALTracker.result(),
+                "P_mean":self.PmeanTracker.result(),
+                "P_max":self.PmaxTracker.result(),
+                "P_std":self.PstdTracker.result(),
+                "FAR":self.FARTracker.result(),
+                "N_mean":self.N_meanTracker.result(),
+                "N_min":self.NminTracker.result(),
+                "N_std":self.NstdTracker.result(),
+                "Loss":self.LossTracker.result()}
+    
+    
+    def test_step(self, data):
+        AP_distanc,AN_distance=self.Model(data)
+        loss=self.TripLoss(AP_distanc,AN_distance)
+        self.LossTracker.update_state(loss)
+        self.DistanceEval(AP_distanc,AN_distance)
+        return {"VAL":self.VALTracker.result(),
+                "P_mean":self.PmeanTracker.result(),
+                "P_max":self.PmaxTracker.result(),
+                "P_std":self.PstdTracker.result(),
+                "FAR":self.FARTracker.result(),
+                "N_mean":self.N_meanTracker.result(),
+                "N_min":self.NminTracker.result(),
+                "N_std":self.NstdTracker.result(),
+                "Loss":self.LossTracker.result()}
+    
+    
+    
+    def TripLoss(self,ap_distance,an_distance):
+        return tf.reduce_mean(tf.maximum(ap_distance-0.2*self.DesiredDistance,0)+tf.maximum(self.DesiredDistance-an_distance, 0.0))
+    
+    
+    @property
+    def metrics(self):
+        return [self.LossTracker,self.VALTracker,self.PmaxTracker,self.PmeanTracker,self.PstdTracker,self.FARTracker,self.N_meanTracker,self.NminTracker,self.NstdTracker]
+    
+    def DistanceEval(self,P_distance,N_distance):
+
+        P_pred,N_pred=self.TDEvaluation(P_distance,N_distance)
+        PCDCount=tf.size(tf.where(P_pred))
+
+        VAL=PCDCount/tf.size(P_pred)
+        self.VALTracker.update_state(VAL)
+        
+        NCDcount=tf.size(tf.where(N_pred))
+        FAR=1-(NCDcount/tf.size(P_pred))
+        self.FARTracker.update_state(FAR)
+        P_mean=tf.reduce_mean(P_distance)
+        self.PmeanTracker.update_state(P_mean)
+        N_mean=tf.reduce_mean(N_distance)
+        self.N_meanTracker.update_state(N_mean)
+        P_std=tf.math.reduce_std(P_distance)
+        self.PstdTracker.update_state(P_std)
+        N_std=tf.math.reduce_std(N_distance)
+        self.NstdTracker.update_state(N_std)
+        P_max=tf.reduce_max(P_distance)
+        self.PmaxTracker.update_state(P_max)
+        N_min=tf.reduce_min(N_distance)
+        self.NminTracker.update_state(N_min)
+    
+    def TDEvaluation(self,P_distance,N_distance):
+        return tf.cast(P_distance<=self.DesiredDistance,dtype=tf.int8),tf.cast(N_distance>self.DesiredDistance,dtype=tf.int8)
+    
+    
+DesiredDistance=1
+Optimizer= Adam(learning_rate=1e-4)
+Siamesmodel=SiamesModel(siames_net,DesiredDistance)
+Siamesmodel.compile(optimizer=Adam(1e-4),weighted_metrics=[])
+Siamesmodel.fit(TrainData,validation_data=TestData,epochs=1,callbacks=[EarlyStopping(patience=3),ModelCheckpoint(f"./FaceRecognition/FaceModel/{User}/kerasModel")])
+
+
+
+def EmbeddingMaker(DataPipline,Model):
+    Embedding={}
+    NamesTimer={}
+    for  Image,Name in DataPipline:
+        Name=str(Name[0].numpy())[2:-1]
+        
+        if Name[0] not in Embedding.keys():
+            NamesTimer[Name]=1
+            Embedding[Name]=tf.squeeze(Model(Image)).numpy()
+            
+        else:
+            Embedding[Name]=Embedding[Name]+tf.squeeze(Model(Image)).numpy()
+            NamesTimer[Name]=NamesTimer[Name]+1
+    for Name in Embedding:
+        Embedding[Name]=Embedding[Name]/NamesTimer[Name]
+    return Embedding
+
+
+Embedding=EmbeddingMaker(EmbeddingData,siames_net.layers[3])
+EmbeddingLabel,EmbeddingNames=[[Embedding[Name] for Name in Embedding] , {Name:Index+1 for Index,Name in enumerate(Embedding) } ]
+
+
+
+class LiteModel(tf.Module):
+    def __init__(self,FaceModel,FacesEmbedding,name="FaceLiteModel"):
+        self.FaceModel=FaceModel
+        self.FacesEmdedding=FacesEmbedding
+       
+    @tf.function(input_signature=[tf.TensorSpec(shape=[None,224,224,3],dtype=tf.float32),tf.TensorSpec(shape=[],dtype=tf.float32)])
+    def __call__(self,Image,Threshold):
+        Embedding=self.FaceModel(Image)
+        Distance=tf.cast(Threshold,tf.float32)
+        Name=0
+        for Index,StoredEmbedding in enumerate(self.FacesEmdedding):
+            distance=tf.reduce_sum(tf.math.pow(Embedding-StoredEmbedding,2))
+            if distance<Distance:
+                Name=Index+1
+                Distance=distance
+        return Name,Distance
+    
+litemodel=LiteModel(siames_net.layers[3],FacesEmbedding=EmbeddingLabel)
+
+
+converter=tf.lite.TFLiteConverter.from_concrete_functions([litemodel.__call__.get_concrete_function()],litemodel)
+converter.optimizations=[tf.lite.Optimize.DEFAULT]
+converter.target_spec.supported_types=[tf.float16]
+tflitemodel=converter.convert()
+
+with open(f"./FaceRecognition/FaceModel/{User}/FaceXModel.tflite","wb") as file:
+    file.write(tflitemodel)

IndoorLocalization/IndoorlocalizationTrainer.py

@@ -0,0 +1,143 @@
+import numpy as np
+import pandas as pd
+from tensorflow.data import Dataset
+from tensorflow import lite,float16,random,where,cast,float32,constant,reshape
+from sklearn.model_selection import train_test_split
+from os.path import isdir
+import os
+from keras.callbacks import EarlyStopping,ModelCheckpoint
+from keras.models import Model,load_model
+from keras.layers import Layer,Dense,Dropout,Input,Embedding,Concatenate
+from  keras.optimizers import Adam
+from keras.losses import mean_absolute_error
+from keras.metrics import R2Score
+import sys
+User=sys.argv[1]
+print(sys.argv[0])
+Data=pd.read_csv(f"./IndoorLocalization/Data/{User}/Data.csv")
+print(Data)
+PhonsId=np.sort(Data["PHONEID"].unique())
+phoneidMap={phoneid:i for i,phoneid in enumerate(PhonsId)}
+def ReplaceId(id):
+    if (np.random.randint(low=0,high=20,size=1)==3):
+        return len(phoneidMap)
+    return phoneidMap[id]
+
+Data["PHONEID"]=Data["PHONEID"].apply(ReplaceId)
+Data=Data.dropna()
+
+def CleanTrainData(df):
+    target=df[["SPACEID","LONGITUDE","LATITUDE"]]
+    df=df.drop(['LONGITUDE', 'LATITUDE',"SPACEID"], axis=1)
+    return df, target
+
+DataX,TargetY=CleanTrainData(Data)
+
+LONGITUDEMax=TargetY["LONGITUDE"].max()
+LATITUDEMax=TargetY["LATITUDE"].max()
+LONGITUDEMin=TargetY["LONGITUDE"].min()
+LATITUDEMin=TargetY["LATITUDE"].min()
+BuildingWidth=20
+BuildingLength=20
+
+
+def LONGITUDE_min_max_newrange(item):
+    return ((item-LONGITUDEMin)/(LONGITUDEMax-LONGITUDEMin))*BuildingWidth
+
+def LATITUDE_min_max_newrange(item):
+    return ((item-LATITUDEMin)/(LATITUDEMax-LATITUDEMin))*BuildingLength
+
+TargetY["LONGITUDE"]=TargetY["LONGITUDE"].apply(LONGITUDE_min_max_newrange)
+TargetY["LATITUDE"]=TargetY["LATITUDE"].apply(LATITUDE_min_max_newrange)
+
+X_train, X_test, y_train, y_test = train_test_split(DataX.values,TargetY.values[:,1:], test_size=0.2, random_state=42,shuffle=True,stratify=TargetY.values[:,0])
+SPACESGroups=TargetY.groupby("SPACEID")
+SPACESGroupsmean=SPACESGroups.mean()
+SPACEIDPosition={f"{SPACEID}":(SPACESGroupsmean.query(f"SPACEID=={SPACEID}")["LONGITUDE"].values[0],SPACESGroupsmean.query(f"SPACEID=={SPACEID}")["LATITUDE"].values[0]) for SPACEID in list(SPACESGroups.groups.keys()) }
+
+SPACEIDPositionArray=np.array([list(SPACEIDPosition[f"{i}"]) for i in SPACESGroups.groups.keys()])
+PlacesNumber=len(np.unique(TargetY.iloc[:,0]))
+PhonesNumber=np.unique(DataX["PHONEID"]).size
+
+
+def ApplyNormalizationthenNois(X,Phoneid,Y):
+    X=cast(X,dtype=float32)
+    Y=cast(Y,dtype=float32)
+    additem=np.random.choice([0,1,2])
+    Nuknow=np.random.randint(0,high=5,size=1)
+    X=(X+100)/200
+    if additem ==1:
+        if Nuknow==0:
+            return (X,0),Y
+        return (X,Phoneid),Y
+
+    else:
+        noise=random.normal(shape=X.shape,mean=0,stddev=0.1,dtype=float32)
+        NoisedX=X+noise
+        NoisedX=where(NoisedX<0,x=0.0,y=NoisedX)
+        NoisedX=where(NoisedX>1,x=1.0,y=NoisedX)
+        if Nuknow==0:
+            return (NoisedX,0),Y
+        return (NoisedX,Phoneid),Y
+
+def ApplyNormalizationOnly(X,Phoneid,Y):
+    X=cast(X,dtype=float32)
+    Y=cast(Y,dtype=float32)
+    X=(X+100)/200
+    if Phoneid ==1:
+        return (X,1),Y
+    elif Phoneid ==2:
+        return (X,2),Y
+    else:
+        return (X,0),Y
+    
+TrainDataPipeline=Dataset.from_tensor_slices((X_train[:,:-1],X_train[:,-1],y_train)).map(ApplyNormalizationthenNois).batch(100)
+
+TestDataPipeline=Dataset.from_tensor_slices((X_test[:,:-1],X_test[:,-1],y_test)).map(ApplyNormalizationOnly).batch(10)
+
+class PositionAproxmator(Layer):
+    def __init__(self,PlacesPosition,name="PositionAproxmator"):
+        super(PositionAproxmator,self).__init__()
+        self.PlacesPosition=constant(PlacesPosition,dtype=float32,name="PlacesPositions")
+    def build(self,inputs_shape):
+        self.W=self.add_weight(shape=(inputs_shape[1],2),trainable=True,dtype=float32,name="PlacesWeight")
+
+    def call(self,Probilites):
+        return Probilites@(self.PlacesPosition+self.W)
+
+
+
+def MakeModel(SPACEIDPosition,PhonesNumber):
+    if isdir(f"./IndoorLocalization/IndoorModels/{User}/kerasModel"):
+        return load_model(f"./IndoorLocalization/IndoorModels/{User}/kerasModel")
+    WiFiReadings=Input(168)
+    Phoneid=Input(1)
+    Embeding=Embedding(PhonesNumber,64, embeddings_regularizer="l2")(Phoneid)
+    X=Dense(128,activation="relu")(WiFiReadings)
+    X=Dropout(0.2)(X)
+    z=Dense(64,activation="relu")(X)
+    X=z+reshape(Embeding,shape=(-1,64))
+    X=Concatenate()([z,X,reshape(Embeding,shape=(-1,64))])
+    X=Dropout(0.2)(X)
+    X=Dense(100,activation="relu", kernel_regularizer="l2")(X)
+    X=Dropout(0.1)(X)
+    X=Dense(64,activation="relu")(X)
+    X=X+z
+    X=Dense(64,activation="relu")(X)
+    X=Dropout(0.2)(X)
+    X=Dense(PlacesNumber,activation="softmax")(X)
+    X=PositionAproxmator(SPACEIDPosition)(X)
+
+    return Model(inputs=[WiFiReadings,Phoneid],outputs=[X])
+
+model=MakeModel(SPACEIDPositionArray,PhonesNumber)
+model.compile(optimizer=Adam(learning_rate=1e-4),loss=mean_absolute_error,metrics=[R2Score()])
+hsitory=model.fit(TrainDataPipeline,validation_data=TestDataPipeline,epochs=5,callbacks=[EarlyStopping(patience=3),ModelCheckpoint(f"./IndoorLocalization/IndoorModels/{User}/kerasModel")])
+# hsitory=model.fit(TrainDataPipeline,validation_data=TestDataPipeline,epochs=5,callbacks=[EarlyStopping(patience=3),ModelCheckpoint(r"C:\Users\mf\Desktop\AIProjects")])
+
+converter=lite.TFLiteConverter.from_keras_model(model)
+converter.optimizations=[lite.Optimize.DEFAULT]
+converter.target_spec.supported_types=[float16]
+tflitemodel=converter.convert()
+with open(f"./IndoorLocalization/IndoorModels/{User}/FinalHistoryModel.tflite","wb") as file:
+    file.write(tflitemodel)

Logic/FUsers/AddUser.py

@@ -0,0 +1,68 @@
+from fastapi import APIRouter,File,Form,UploadFile
+import sqlite3
+from passlib.context import CryptContext
+from os import makedirs
+from os.path import exists
+from pydantic import BaseModel
+from PIL import Image
+from io import BytesIO
+UserAddRouter=APIRouter(prefix="/Users")
+
+
+
+@UserAddRouter.post("/AddUser")
+def adduser(AdminEmail:str=Form(...),AdminPassword:str =Form(...),Email:str=Form(...),Name:str=Form(...),Job:str=Form(...),Phonenumber:str=Form(...),Place:str=Form(...),BDay:str=Form(...),Password:str=Form(...),Images:UploadFile=File(...)):
+    try:
+        pwd_context=CryptContext(schemes=["bcrypt"],deprecated="auto")
+        AdminPassword="$2b$12$33H14GFBvtomzLrEaM6Tqu7Jr621eHlXL9TVtdPU6YCljxc4eug2a"
+        if  AdminEmail !="[email protected]":
+            if not pwd_context.verify(  AdminPassword,AdminPassword):
+                return {"Status":False,"Message":" Admin Email or Password is not correct "}
+        pwd_context=CryptContext(schemes=["bcrypt"],deprecated="auto")
+        UserId=0
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT UserId FROM Users where Email='{ Email}'
+                        ''')
+        Data=cursor.fetchall()
+        if len(Data)==1:
+            if (Data[0]!=None):
+                return  {"Status":False,"Message":"Email Is Alread Exists"}
+        cursor=connect.execute('''
+                        SELECT MAX(UserId) FROM Users
+                        ''')
+        Data=cursor.fetchall()
+        
+        if len(Data)!=0:
+            if Data[0][0]==None:
+                UserId=0
+            else:
+                UserId=Data[0][0]+1
+        
+        HashedPassword=pwd_context.hash( Password)
+                
+        connect.execute(f'''
+                        INSERT INTO Users (UserId ,Email ,UserName ,Job, Phonenumber ,Place,BDay ,Password ) VALUES ({UserId},'{ Email}','{ Name}','{ Job}', '{ Phonenumber}' ,'{ Place}','{ BDay}','{HashedPassword}')
+                        ''')
+        connect.commit()
+        connect.close() 
+        if (not exists(f"./FaceRecognition/ExtactedFaces/{UserId}/Train")):
+            makedirs(f"./FaceRecognition/ExtactedFaces/{UserId}/Train")
+        if (not exists(f"./FaceRecognition/ExtactedFaces/{UserId}/Train/Negative")):
+            makedirs(f"./FaceRecognition/ExtactedFaces/{UserId}/Train/Negative")
+        if (not exists(f"./FaceRecognition/ExtactedFaces/{UserId}/Test")):
+            makedirs(f"./FaceRecognition/ExtactedFaces/{UserId}/Test")
+        if (not exists(f"./FaceRecognition/FaceModel/{UserId}")):
+            makedirs(f"./FaceRecognition/FaceModel/{UserId}")
+        if (not exists(f"./static/{UserId}")):
+            makedirs(f"./static/{UserId}")
+            Image.open(BytesIO(Images.file.read())).save(f"./static/{UserId}/user.png","PNG")
+        if (not exists(f"./IndoorLocalization/Data/{UserId}")):
+            makedirs(f"./IndoorLocalization/Data/{UserId}")
+        if (not exists(f"./IndoorLocalization/IndoorModels/{UserId}")):
+            makedirs(f"./IndoorLocalization/IndoorModels/{UserId}")
+            
+        return {"Status":True,"Message":"User Is Added Correctly"}
+
+    except Exception as e :
+        return {"Status":False,"Message":e}

Logic/FUsers/AddUserItem.py

@@ -0,0 +1,52 @@
+from fastapi import APIRouter,File,Form,UploadFile
+import sqlite3
+
+from os.path import exists
+from os import makedirs
+
+from PIL import Image
+from io import BytesIO
+
+UserItemAddRouter=APIRouter(prefix="/Users")
+@UserItemAddRouter.post("/AddUserItem")
+def adduser(Email:str=Form(...),Name:str=Form(...),Password:str=Form(...),Images:UploadFile=File(...)):
+    try:
+        
+        State=False
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT UserId,Password FROM Users where Email='{ Email}'
+                        ''')
+
+        FData=cursor.fetchall()
+        
+        
+        
+        if len(FData) !=0 :
+            if FData[0][0]==None:
+                return  {"Status":False,"Message":"Email or Password Is Incorrect "}
+            HasedPassword=FData[0][1]
+            UserId=FData[0][0]
+            State= Password==HasedPassword
+        
+        Name= Name
+        if not State:
+            return {"Status":False,"Message":"Email or Password is not correct"}
+        
+        if not exists(f"./FaceRecognition/ExtactedFaces/{UserId}/Train/{Name}"):
+            connect.execute(f'''
+                            INSERT INTO UserItems (UserId ,UserItemName  ) VALUES ({UserId},'{Name}')
+                            ''')
+            connect.commit()
+            if not exists(f"./FaceRecognition/ExtactedFaces/{UserId}/Train/{Name}"):
+                makedirs(f"./FaceRecognition/ExtactedFaces/{UserId}/Train/{Name}")
+            if not exists(f"./FaceRecognition/ExtactedFaces/{UserId}/Test/{Name}"):
+                makedirs(f"./FaceRecognition/ExtactedFaces/{UserId}/Test/{Name}")
+            if not exists(f"./static/{UserId}/{Name}"):
+                makedirs(f"./static/{UserId}/{Name}")
+                Image.open(BytesIO(Images.file.read())).save(f"./static/{UserId}/{Name}/user.png","PNG")
+            return {"Status":True,"Message":"User Is Added Correctly"}
+        else:
+            return {"Status":False,"Message":"Name Is Already Exist"}
+    except Exception as e:
+        return {"Status":False,"Message":e}

Logic/FUsers/DeleteUser.py

@@ -0,0 +1,46 @@
+from fastapi import APIRouter
+import sqlite3
+from passlib.context import CryptContext
+from shutil import rmtree
+from os.path import exists
+DeleteUserRouter=APIRouter(prefix="/Users")
+@DeleteUserRouter.post("/DeleteUser")
+def SpeachToTextEndPoint(Email:str,Password:str,AdminEmail:str,AdminPassword:str):
+    try:
+        if AdminEmail !="[email protected]" and AdminPassword !="#mohammed*123#":
+            return {"Status":False,"Message":" Admin Email or Password is not correct "}
+        State=False
+        
+        pwd_context=CryptContext(schemes=["bcrypt"],deprecated="auto")
+        
+        
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT UserId,Password FROM Users where Email='{Email}' 
+                        ''')
+        Data=cursor.fetchall()
+        if len(Data) !=0 :
+            if Data[0][0]==None:
+                return {"Status":True,"Message":"User Is Not Defined Before"}
+            HasedPassword=Data[0][1]
+            UserId=Data[0][0]
+            State=pwd_context.verify(Password,HasedPassword)
+
+        if State:
+            connect.execute(f'''
+                        DELETE FROM Users where Email='{Email}'
+                        ''')
+            connect.execute(f'''
+                        DELETE FROM UserItems WHERE UserId={UserId}
+                        ''')
+            connect.commit()
+            if exists(f"./FaceRecognition/ExtactedFaces/{UserId}"):
+                rmtree(f"./FaceRecognition/ExtactedFaces/{UserId}")
+            return {"Status":True,"Message":"User Is Deleted Correctly"}
+        else:
+            return {"Status":False,"Message":"Email or Password is not correct"}
+        
+    
+        
+    except sqlite3.Error as e:
+        return {"Status":False,"Message":e}

Logic/FUsers/DeleteUserItem.py

@@ -0,0 +1,46 @@
+from fastapi import APIRouter
+import sqlite3
+from passlib.context import CryptContext
+from shutil import rmtree
+from os.path import exists
+from pydantic import BaseModel
+class DataType(BaseModel):
+    Email:str
+    Name:str
+    Password:str
+UserItemDeleteRouter=APIRouter(prefix="/Users")
+@UserItemDeleteRouter.post("/DeleteUserItem")
+def adduser(Dat:DataType):
+    try:
+        
+        State=False
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT UserId,Password FROM Users where Email='{Dat.Email}'
+                        ''')
+        
+        Data=cursor.fetchall()
+        if len(Data) !=0 :
+            if Data[0][0]==None:
+                return {"Status":False,"Message":"Email or Password Is Incorrect"}
+            HasedPassword=Data[0][1]
+            UserId=Data[0][0]
+            State=Dat.Password==HasedPassword
+            
+        if not State:
+            return {"Status":False,"Message":"Email or Password is not correct"}
+        Name=Dat.Name
+        connect.execute(f'''
+                            DELETE FROM UserItems WHERE UserId={UserId} AND UserItemName='{Name}'
+                        ''')
+        
+        connect.commit()
+        if exists(f"./FaceRecognition/ExtactedFaces/{UserId}/Test/{Name}"):
+            rmtree(f"./FaceRecognition/ExtactedFaces/{UserId}/Test/{Name}")
+        if exists(f"./FaceRecognition/ExtactedFaces/{UserId}/Train/{Name}"):
+            rmtree(f"./FaceRecognition/ExtactedFaces/{UserId}/Train/{Name}")
+        else:
+            return {"Status":False,"Message":"User Is Not Founded"}    
+        return {"Status":True,"Message":"User Is Deleted Correctly"}
+    except sqlite3.Error as e:
+        return {"Status":False,"Message":e}

Logic/FUsers/GetAllUsers.py

@@ -0,0 +1,31 @@
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+import sqlite3
+from pydantic import BaseModel
+class DataType(BaseModel):
+    AdminEmail:str
+    AdminPassword:str
+GetUserRouter=APIRouter(prefix="/Users")
+@GetUserRouter.post("/GetAllUsers")
+def adduser(Data:DataType):
+    try:
+        AdminPassword="$2b$12$33H14GFBvtomzLrEaM6Tqu7Jr621eHlXL9TVtdPU6YCljxc4eug2a"
+        if Data.AdminEmail =="[email protected]":
+            if not (Data.AdminPassword==AdminPassword):
+                response=JSONResponse({"Status":False},status_code=200)
+                
+                return response
+            connect=sqlite3.connect("DataBase/DataBase.bd")
+            cursor=connect.execute(f'''
+                            SELECT * FROM Users 
+                            ''')
+
+            Data=cursor.fetchall()
+            return {"Status":True,"Data":Data}
+        else:
+            response=JSONResponse({"Status":False,"Message":"Email Or password is in corredct try to login again"},status_code=200)
+                
+            return response
+        
+    except Exception as e:
+        return {"Status":False,"Message":e}

Logic/FUsers/GetUserData.py

@@ -0,0 +1,43 @@
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+import sqlite3
+from pydantic import BaseModel
+class DataType(BaseModel):
+    Email:str
+    Password:str
+GetUserDataRouter=APIRouter(prefix="/Users")
+@GetUserDataRouter.post("/GetUserData")
+def adduser(Dat:DataType):
+    try:
+        State=False
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT UserId,Password FROM Users where Email='{Dat.Email}'
+                        ''')
+
+        Data=cursor.fetchall()
+        if len(Data)!=0:
+            if Data[0][0]==None:
+                return  {"Status":False,"Message":"Email or Password Is Incorrect "}
+        
+        HasedPassword=Data[0][1]
+        UserId=Data[0][0]
+        State=Dat.Password==HasedPassword
+        if not State:
+            return {"Status":False,"Message":"Email or Password is not correct"}
+        
+        cursor=connect.execute(f'''
+                            
+                        SELECT UserName,Job,Phonenumber,Place,BDay FROM Users where UserId={UserId}
+                        ''')
+        Data=cursor.fetchone()
+        if len(Data)!=0:
+            
+            if Data[0][0]==None:
+                return  {"Status":True,"Message":"Error  Not Found"}
+            else:
+                return  {"Status":True,"Data":Data}
+        
+        return {"Status":False,"Message":"Error Not Found"}
+    except Exception as e:
+        return {"Status":False,"Message":e}

Logic/FUsers/GetUsersItems.py

@@ -0,0 +1,52 @@
+from fastapi import APIRouter
+import sqlite3
+from os import listdir
+from os.path import exists
+from pydantic import BaseModel
+class DataType(BaseModel):
+    Email:str
+    Password:str
+# from jose import jwt,JWTError
+UserItemGetRouter=APIRouter(prefix="/Users")
+@UserItemGetRouter.post("/GetUserItem")
+def adduser(Dat:DataType):
+    try:
+    
+        State=False
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT UserId,Password FROM Users where Email='{Dat.Email}'
+                        ''')
+
+        Data=cursor.fetchall()
+        if len(Data)!=0:
+            if Data[0][0]==None:
+                return  {"Status":False,"Message":"Email or Password Is Incorrect "}
+        
+        HasedPassword=Data[0][1]
+        UserId=Data[0][0]
+        State=Dat.Password==HasedPassword
+        if not State:
+            return {"Status":False,"Message":"Email or Password is not correct"}
+        
+        cursor=connect.execute(f'''
+                        SELECT UserItemName FROM UserItems where UserId={UserId}
+                        ''')
+        Data=cursor.fetchall()
+        if len(Data)!=0:
+            
+            if Data[0][0]==None:
+                return  {"Status":True,"Data":[]}
+            else:
+                UsersItems=[]
+                for i in Data:
+                    num=0
+                    if exists(f"./FaceRecognition/ExtactedFaces/{UserId}/Train/{i[0]}"):
+                        num=len(listdir(f"./FaceRecognition/ExtactedFaces/{UserId}/Train/{i[0]}"))
+                    
+                    UsersItems.append({"Name":i[0],"NumImages":num})
+                return  {"Status":True,"Data":UsersItems}
+        
+        return {"Status":False,"Message":[]}
+    except Exception as e:
+        return {"Status":False,"Message":e}

Logic/FaceRecognition/StoreImage.py

@@ -0,0 +1,102 @@
+from fastapi import APIRouter,UploadFile,Form,File
+from PIL import Image
+import mediapipe as mp
+from  numpy import sqrt, array,abs
+from io import BytesIO
+from os.path import exists
+from passlib.context import CryptContext
+from sqlite3 import connect
+from datetime import datetime 
+MediapipeModelPath="./Models/face_landmarker.task"
+
+BaseOptions=mp.tasks.BaseOptions
+FaceLandMarker=mp.tasks.vision.FaceLandmarker
+FaceLandMarkerOptions=mp.tasks.vision.FaceLandmarkerOptions
+VisionRunningMode=mp.tasks.vision.RunningMode
+FaceLandMarkerResult=mp.tasks.vision.FaceLandmarkerResult
+options=FaceLandMarkerOptions(base_options=BaseOptions(model_asset_path=MediapipeModelPath),running_mode=VisionRunningMode.IMAGE)
+landmarker= FaceLandMarker.create_from_options(options)
+# class DataType(BaseModel):
+#     Images:UploadFile
+#     Email:EmailStr
+#     Password:str
+#     Name:str
+#     Type:str
+
+# def asform(Images:UploadFile=File(...),Email:str=Form(...),Password:str=Form(...),Name:str=Form(...),Type:str=Form(...))->DataType:
+#     return DataType(Images=Images,Email=Email,Password=Password,Name=Name,Type=Type)
+UploaderRouter=APIRouter(prefix="/Uploader")
+
+@UploaderRouter.post("/ImageUpload")
+async def SpeachToTextEndPoint(Images:UploadFile=File(...),Email:str=Form(...),Password:str=Form(...),Name:str=Form(...),Type:str=Form(...)):
+    try:
+        State=False
+        pwd_context=CryptContext(schemes=["bcrypt"],deprecated="auto")
+        con=connect("./DataBase/DataBase.bd")
+        cursor=con.execute(f'''
+                        SELECT UserId,Password FROM Users where Email='{Email}' 
+                        ''')
+        
+        Data=cursor.fetchall()
+        if len(Data) !=0 :
+            if Data[0][0]==None:
+                return {"Status":True,"Message":"Email or Password Is Incorrect"}
+            HasedPassword=Data[0][1]
+            UserId=Data[0][0]
+            State=pwd_context.verify(Password,HasedPassword)
+        
+        
+        
+        con.close()
+        if not State:
+            return {"Status":False,"Message":"Email or Password is not correct"}
+        
+            
+        image_array=array(Image.open(BytesIO(Images.file.read())))
+        
+        mp_img=mp.Image(image_format=mp.ImageFormat.SRGB,data=image_array)
+        result=landmarker.detect(mp_img)
+        State,ExtractedImage=render(results=result,FaceImage=image_array)
+        if exists(f"./FaceRecognition/ExtactedFaces/{UserId}/{Type}/{Name}") and State:
+            Image.fromarray(ExtractedImage.astype("uint8")).save(f"./FaceRecognition/ExtactedFaces/{UserId}/{Type}/{Name}/{str(datetime.now()).split('.')[-1]}-{Images.filename}","PNG")
+        else:
+            return {"Status":False,"Message":"Cant Find That Person"}
+                
+        return {"Satus":True}
+
+    except Exception as e:
+        print(e)
+        return {"Satus":False}
+    
+
+def render(results,FaceImage):
+    res = results.face_landmarks[0]
+    x_=int(res[145].x*FaceImage.shape[1])
+    y_=int(res[145].y*FaceImage.shape[0])
+    x2_=int(res[374].x*FaceImage.shape[1])
+    y2_=int(res[374].y*FaceImage.shape[0])
+    w=sqrt((x_-x2_)**2+(y_-y2_)**2)
+    W=6.3
+    f = 840
+    d = (W * f) / w
+    if d >=100:
+        return False,None
+    
+    x=int(res[356].x*FaceImage.shape[1])
+    y=int(res[152].y*FaceImage.shape[0])
+    x2=int(res[162].x*FaceImage.shape[1])
+    y2=int(res[338].y*FaceImage.shape[0])
+    if x<FaceImage.shape[1]-10:
+        x+=10
+    if y>FaceImage.shape[0]-10:
+        y+=10
+    if x2>10:
+        x2-=10
+    if y2>10:
+        y2-=10
+    
+    
+    ExtractedFace=FaceImage[abs(y2):abs(y),abs(x2):abs(x)]
+    return True,ExtractedFace
+    
+    

Logic/FaceRecognition/Trainer.py

@@ -0,0 +1,73 @@
+from fastapi import APIRouter,BackgroundTasks,HTTPException
+from os.path import exists
+from os import listdir
+import subprocess
+from passlib.context import CryptContext
+import sqlite3
+ModelTrainer=APIRouter(prefix="/Trainer")
+TrainingProcess={}
+
+def TrainModel(UserId):
+    global TrainingProcess
+    if TrainingProcess.get(UserId,False) and TrainingProcess[UserId].poll() is None:
+        raise HTTPException(status_code=400,detail="Model is already training.")
+    TrainingProcess=subprocess.Popen(["python","./FaceRecognition/ModelTrainer.py",f"{UserId}"])
+
+
+
+@ModelTrainer.post("/TrainFaceModel")
+async def SpeachToTextEndPoint(Tasks:BackgroundTasks,Email:str,Password:str):
+    global TrainingProcess
+
+    try:
+        State=False
+        pwd_context=CryptContext(schemes=["bcrypt"],deprecated="auto")
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT UserId,Password FROM Users where Email='{Email}' 
+                        ''')
+        
+        Data=cursor.fetchall()
+        if len(Data) !=0 :
+            if Data[0][0]==None:
+                return {"Status":True,"Message":"Email or Password Is Incorrect"}
+            HasedPassword=Data[0][1]
+            UserId=Data[0][0]
+            
+            State=pwd_context.verify(Password,HasedPassword)
+            
+        if exists(f"./FaceRecognition/ExtactedFaces/{UserId}/Train"):
+            for UserName in listdir(f"./FaceRecognition/ExtactedFaces/{UserId}/Train"):
+                if len(listdir(f"./FaceRecognition/ExtactedFaces/{UserId}/Train/"+UserName))<2:
+                    return  {"Status":False,"Message":f"{UserName} has only {len(listdir(f'./FaceRecognition/ExtactedFaces/{UserId}/Train/'+UserName))} image and it must be 2 or more"}
+        if not State:
+            return {"Status":False,"Message":"Email or Password is not correct"}
+        if TrainingProcess.get(UserId,False) and TrainingProcess[UserId].poll() is None:
+            raise HTTPException(status_code=400,detail="Model is already training.")
+        Tasks.add_task(TrainModel ,args=[UserId])
+        return{"message":"Training Started"}
+    except Exception as e:
+        return{"Stats":False,"message":f"{e}"}
+    
+@ModelTrainer.post("/TrainFaceModelStatus")
+async def SpeachToTextEndPoint(Email:str,Password:str):
+    global TrainingProcess
+    try:
+        State=False
+        pwd_context=CryptContext(schemes=["bcrypt"],deprecated="auto")
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT UserId,Password FROM Users where Email='{Email}' 
+                        ''')
+        if len(cursor.fetchall())==1:
+            HasedPassword=cursor.fetchall()[0][1]
+            UserId=cursor.fetchall()[0][0]
+        State=pwd_context.verify(Password,HasedPassword)
+        if not State:
+            return {"Status":False,"Message":"Email or Password is not correct"}
+        if TrainingProcess.get(UserId,False) and TrainingProcess[UserId].poll() is None:
+            return{"message":"Model still Training "}
+        else:
+            return{"message":"Model Training ended"}
+    except Exception as e:
+        return{"Stats":True,"message":f"{e}"}

Logic/GetModels/FaceModel.py

@@ -0,0 +1,33 @@
+from fastapi import APIRouter
+from fastapi.responses import FileResponse
+from passlib.context import CryptContext
+
+import sqlite3
+FaceModelRouter=APIRouter(prefix="/GetModel")
+@FaceModelRouter.post("/GetFaceModel")
+def FaceModelEndPoint(Email:str,Password:str):
+    try:
+        State=False
+        pwd_context=CryptContext(schemes=["bcrypt"],deprecated="auto")
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT Password FROM Users where Email='{Email}' 
+                        ''')
+        if len(cursor.fetchall())==1:
+            HasedPassword=cursor.fetchall()[0][0]
+        State=pwd_context.verify(Password,HasedPassword)
+        if not State:
+            return {"Status":False,"Message":"Email or Password is not correct"}
+        pwd_context=CryptContext(schemes=["bcrypt"],deprecated="auto")
+        Password=pwd_context.hash(Password)
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT UserId FROM Users where Email='{Email}'
+                        ''')
+        if len(cursor.fetchall())==0:
+            return {"Status":False,"Message":"somthing went wrong"}
+        UserId=cursor.fetchone()["UserId"]
+        return FileResponse(f"./ExtactedFaces/FaceModel/{UserId}/FinalFaceModel.tflite")
+        
+    except Exception as e:
+        return {"Status":False,"Message":e}

Logic/GetModels/IndoorModel.py

@@ -0,0 +1,34 @@
+from fastapi import APIRouter
+from fastapi.responses import FileResponse
+from passlib.context import CryptContext
+import sqlite3
+IndoorModelRouter=APIRouter(prefix="/GetModel")
+@IndoorModelRouter.post("/GetIndoorModel")
+def FaceModelEndPoint(Email:str,Password:str):
+    try:
+        
+        State=False
+        pwd_context=CryptContext(schemes=["bcrypt"],deprecated="auto")
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT Password FROM Users where Email='{Email}' 
+                        ''')
+        if len(cursor.fetchall())==1:
+            HasedPassword=cursor.fetchall()[0][0]
+        State=pwd_context.verify(Password,HasedPassword)
+        if not State:
+            return {"Status":False,"Message":"Email or Password is not correct"}
+        
+        pwd_context=CryptContext(schemes=["bcrypt"],deprecated="auto")
+        Password=pwd_context.hash(Password)
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT UserId FROM Users where Email='{Email}'
+                        ''')
+        if len(cursor.fetchall())==0:
+            return {"Status":False,"Message":"somthing went wrong"}
+        UserId=cursor.fetchone()["UserId"]
+        return FileResponse(f"./IndoorLocalization/IndoorModels/{UserId}/FinalHistoryModel.tflite")
+        
+    except Exception as e:
+        return {"Status":False,"Message":e}

Logic/IndoorLocalization/StoreNewLabel.py

@@ -0,0 +1,44 @@
+from fastapi import APIRouter
+import pandas as read_csv
+from sqlite3 import connect
+from os.path import isfile
+from pydantic import BaseModel
+class DataType(BaseModel):
+    label:str
+    Email:str
+    Password:str
+IndoorLabel=APIRouter(prefix="/Uploader")
+@IndoorLabel.post("/AddWiFiLAbel")
+async def FunctionName(Data:DataType):
+    
+    try:
+        
+        
+        con=connect("DataBase/DataBase.bd")
+        cursor=con.execute(f'''
+                        SELECT UserId,Password FROM Users where Email='{Data.Email}' 
+                        ''')
+        if len(cursor.fetchall())==1:
+            
+            HasedPassword=cursor.fetchall()[0][1]
+            UserId=cursor.fetchall()[0][0]
+        State=Data.Password==HasedPassword
+        con.close()
+        if State:
+            if not isfile(f"./IndoorLocalization/Data/{UserId}/Data.csv"):
+                return {"Status":False,"message":"Cant Find DataSet"}
+            Labels=map(lambda x:int(x),Data.label.split(sep=","))
+            DATA=read_csv(f"./IndoorLocalization/Data/{UserId}/Data.csv")
+            DATA.loc[DATA.shape[0]]=Labels
+            DATA.to_csv(f"./IndoorLocalization/Data/{UserId}/Data.csv",index=False)
+            return {"Status":True,"message":"Store Done "}
+    
+        else:
+            return {"Status":False,"Message":"Email or Password is not correct"}
+        
+    
+        
+    except Exception as e:
+        
+        return {"Status":False,"message":e}
+    

Logic/IndoorLocalization/Trainer.py

@@ -0,0 +1,73 @@
+from fastapi import APIRouter,BackgroundTasks,HTTPException
+import sqlite3
+from passlib.context import CryptContext
+import subprocess
+from pydantic import BaseModel
+ModelIndoorTrainer=APIRouter(prefix="/Trainer")
+TrainingProcess2={}
+
+def TrainModel(UserId):
+    global TrainingProcess2
+    if TrainingProcess2.get(UserId,False) and TrainingProcess2.get(UserId).poll():
+        raise HTTPException(status_code=400,detail="Model is already training.")
+    TrainingProcess2[UserId]=subprocess.Popen(["python","./IndoorLocalization/IndoorlocalizationTrainer.py",f"{UserId}"])
+    TrainingProcess2[UserId]=None
+
+
+class DataType(BaseModel):
+    Email:str
+    Password:str
+@ModelIndoorTrainer.post("/TrainIndoorModel")
+async def SpeachToTextEndPoint(Tasks:BackgroundTasks,Data:DataType):
+    global TrainingProcess2
+    try:    
+        
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT UserId,Password FROM Users where Email='{Data.Email}' 
+                        ''')
+        if len(cursor.fetchall())==1:
+            HasedPassword=cursor.fetchall()[0][1]
+            UserId=cursor.fetchall()[0][0]
+        State=Data.Password==HasedPassword
+        if State:
+            if TrainingProcess2.get(UserId,False) and TrainingProcess2.get(UserId).poll() is None:
+                raise HTTPException(status_code=400,detail="Model is already training.")
+            Tasks.add_task(TrainModel,args=[UserId])
+            return{"message":"Training Started"}
+            
+
+        else:
+            return {"Status":False,"Message":"Email or Password is not correct"}
+    except Exception as e:
+        return {"Status":False,"Message":f"{e}"}
+    
+    
+
+    
+@ModelIndoorTrainer.post("/TrainIndoorModelStatus")
+async def SpeachToTextEndPoint(Data:DataType):
+    global TrainingProcess2
+    try:    
+        
+        
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT UserId, Password FROM Users where Email='{Data.Email}' 
+                        ''')
+        if len(cursor.fetchall())==1:
+            HasedPassword=cursor.fetchall()[0][1]
+            UserId=cursor.fetchall()[0][0]
+        State=Data.Password==HasedPassword
+        if State:
+            if TrainingProcess2.get(UserId,False) and TrainingProcess2.get(UserId).poll() is None:
+                return{"message":"Model still Training "}
+            else:
+                return{"message":"Model Training ended"}
+            
+
+        else:
+            return {"Status":False,"Message":"Email or Password is not correct"}
+    except Exception as e:
+        return {"Status":False,"Message":f"{e}"}
+    

Logic/IndoorLocalization/UserDataSetUploader.py

@@ -0,0 +1,36 @@
+from fastapi import APIRouter,UploadFile,Form,File
+from sqlite3 import connect
+
+IndoorDataUploader=APIRouter(prefix="/Uploader")
+@IndoorDataUploader.post("/UploadeWiFiData")
+async def FunctionName(Dataset:UploadFile=File(...),Email:str=Form(...),Password:str=Form(...)):
+    
+    try:
+        con=connect("DataBase/DataBase.bd")
+        cursor=con.execute(f'''
+                        SELECT UserId,Password FROM Users where Email='{Email}' 
+                        ''')
+        Data=cursor.fetchall()
+        if len(Data) !=0 :
+            if Data[0][0]==None:
+                return  {"Status":False,"Message":"Email or Password Is Incorrect "}
+            HasedPassword=Data[0][1]
+            UserId=Data[0][0]
+            State=Password==HasedPassword
+        
+        con.close()
+        if State:
+            with open(f"./IndoorLocalization/Data/{UserId}/Data.csv","wb") as File:
+                File.write(Dataset.file.read())
+            
+            return {"Status":True,"Message":"File Added Correctly"}
+
+        else:
+            return {"Status":False,"Message":"Email or Password is not correct"}
+            
+        
+        
+    except Exception as e:
+        
+        return {"Status":False,"message":e}
+    

Logic/Locations/GetDays.py

@@ -0,0 +1,51 @@
+from fastapi import APIRouter
+from fastapi.responses import  JSONResponse
+import sqlite3
+from passlib.context import CryptContext
+from pydantic import BaseModel
+UserGetTrackingDateRouter=APIRouter(prefix="/Location")
+class Data(BaseModel):
+    Email:str 
+    Password:str 
+    
+@UserGetTrackingDateRouter.post("/GetTrackingDate")
+def adduser(Dat:Data):
+    try:
+        Email= Dat.Email
+        Password=Dat.Password
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        State=False
+        
+        
+        
+        cursor=connect.execute(f'''
+                        SELECT UserId,Password FROM Users where Email='{Email}' 
+                        ''')
+        Data=cursor.fetchall()
+        if len(Data) !=0 :
+            if Data[0][0]==None:
+                return {"Status":True,"Message":"User Is Not Defined Before"}
+            HasedPassword=Data[0][1]
+            UserId=Data[0][0]
+            State=Password==HasedPassword
+        if State:
+            cursor=connect.execute(f'''
+                            SELECT DISTINCT Day FROM TrackeringPoints WHERE UserId={UserId}
+                            ''')
+            
+            DataCollected=cursor.fetchall()
+            if len(DataCollected)==0:
+                DataCollected=[["Nodays Found"]]
+            connect.close()
+            
+            return {
+                "Status":True,
+                "Data":DataCollected,
+                }
+                    
+        else:
+            return {"State":False}
+    
+    except Exception as e :
+        return {"Status":False,"Message":e}
+    

Logic/Locations/GetMapOfuser.py

@@ -0,0 +1,74 @@
+from fastapi import APIRouter
+import sqlite3
+from numpy import array,mean
+from pydantic import BaseModel
+UserGetLocationRouter=APIRouter(prefix="/Location")
+class DataType(BaseModel):
+    Email:str
+    Password:str
+    Day:str
+
+@UserGetLocationRouter.post("/GetMapLocations")
+def adduser(Data:DataType):
+    try:
+        Email=Data.Email
+        Password=Data.Password
+        Day=Data.Day
+        State=False
+        
+        # pwd_context=CryptContext(schemes=["bcrypt"],deprecated="auto")
+        
+        
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT UserId,Password FROM Users where Email='{Email}' 
+                        ''')
+        Data=cursor.fetchall()
+        if len(Data) !=0 :
+            if Data[0][0]==None:
+                return {"Status":False,"Message":"User Is Not Defined Before"}
+            HasedPassword=Data[0][1]
+            UserId=Data[0][0]
+            State=Password==HasedPassword
+        if State:
+            cursor=connect.execute(f'''
+                            SELECT Longtude , Lattitude,Houre FROM TrackeringPoints WHERE  Day='{Day}' and UserId={UserId}
+                            ''')
+            DataCollected=cursor.fetchall()
+            # cursor2=connect.execute(f'''
+            #                 SELECT AVG(Longtude) , AVG(Lattitude) TrackeringPoints WHERE  Day='{Day}' and UserId={UserId}
+            #                 ''')
+            
+            
+            # PositionsMean=cursor2.fetchall()
+            connect.close()
+            if len(DataCollected)==0:
+                return {
+                "Status":True,
+                "Data":{
+
+                    "PositionData":[],
+                    "Time":[],
+                    "Mean":[12.3,50]
+                    
+                }
+                    }
+            PositionData=[ [ item[0],item[1]]for item in DataCollected]
+            PositionsMean=mean(array(PositionData),axis=0)
+            Houre=[ item[2] for item in DataCollected]
+            
+            return {
+                "Status":True,
+                "Data":{
+
+                    "PositionData":PositionData,
+                    "Time":Houre,
+                    "Mean":PositionsMean
+                    
+                }
+                    }
+        else:
+            return {"State":False}
+    except Exception as e :
+        return {"Status":False,"Message":e}
+    

Logic/Locations/SetLocationForUser.py

@@ -0,0 +1,44 @@
+from fastapi import APIRouter
+import sqlite3
+from passlib.context import CryptContext
+from pydantic import BaseModel
+class DataType(BaseModel):
+    Email:str
+    Password:str
+    Longtude:str
+    Lattitude:str
+    Day:str
+    Houre:str
+UserAddLocationRouter=APIRouter(prefix="/Location")
+@UserAddLocationRouter.post("/AddLocation")
+def adduser(Data:DataType):
+    try:
+        
+        State=False
+        
+        pwd_context=CryptContext(schemes=["bcrypt"],deprecated="auto")
+        
+        
+        connect=sqlite3.connect("DataBase/DataBase.bd")
+        cursor=connect.execute(f'''
+                        SELECT UserId,Password FROM Users where Email='{Data.Email}' 
+                        ''')
+        Data=cursor.fetchall()
+        if len(Data) !=0 :
+            if Data[0][0]==None:
+                return {"Status":True,"Message":"User Is Not Defined Before"}
+            HasedPassword=Data[0][1]
+            UserId=Data[0][0]
+            State=Data.Password==HasedPassword
+        if State:
+            connect.execute(f'''
+                            INSERT INTO TrackeringPoints (UserId,Longtude ,Lattitude,Day,Houre) VALUES ({UserId},{float(Data.Longtude)},{float(Data.Lattitude)},'{Data.Day}','{Data.Houre}')
+                            ''')
+            connect.commit() 
+            connect.close()
+            return {"State":True}
+        else:
+            return {"State":False}
+    except Exception as e :
+        return {"Status":False,"Message":e}
+    

Logic/Login.py

@@ -0,0 +1,48 @@
+from fastapi import APIRouter,Form
+from passlib.context import CryptContext
+from pydantic import BaseModel
+import sqlite3
+class DataType(BaseModel):
+    AdminEmail:str=Form(...)
+    AdminPassword:str=Form(...)
+LogInRouter=APIRouter()
+@LogInRouter.post("/Login")
+def adduser(AdminEmail:str=Form(...),AdminPassword:str=Form(...),Type:str=Form(...)):
+    try:
+        # #mohammed*123#
+        pwd_context=CryptContext(schemes=["bcrypt"],deprecated="auto")
+        if Type=="Admin":
+            
+            AdminPasswordq="$2b$12$33H14GFBvtomzLrEaM6Tqu7Jr621eHlXL9TVtdPU6YCljxc4eug2a"
+            if AdminEmail =="[email protected]":
+                if pwd_context.verify( AdminPassword,AdminPasswordq):
+                    return {"Status":True,
+                    "Data":{"AdminEmail":"[email protected]",
+                        "AdminPassword":AdminPasswordq
+                    }}
+                else:
+                    return {"Status":False,"Message":" Admin Email or Password is not correct "}
+            else:
+                return {"Status":False,"Message":" Admin Email or Password is not correct "}
+        else:
+            connect=sqlite3.connect("DataBase/DataBase.bd")
+            State=False
+            
+            cursor=connect.execute(f'''
+                            SELECT UserId,Password FROM Users where Email='{AdminEmail}' 
+                            ''')
+            Data=cursor.fetchall()
+            if len(Data) !=0 :
+                if Data[0][0]==None:
+                    return {"Status":False,"Message":"User Is Not Defined Before"}
+                HasedPassword=Data[0][1]
+                UserId=Data[0][0]
+                State=pwd_context.verify( AdminPassword,HasedPassword)
+            if State:
+                return {"Status":True,
+                    "Data":{"Email":AdminEmail,
+                        "Password":HasedPassword,
+                        "UserId":UserId
+                    }}
+    except Exception as e :
+        return {"Status":False,"Message":e}

Logic/SpeachToText.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter,UploadFile
+from io import BytesIO
+import speech_recognition as sr
+from scipy.io import wavfile
+from os import environ
+Recognizer=sr.Recognizer()
+SpeachRouter=APIRouter()
+@SpeachRouter.post("/SpeachTotext")
+def SpeachToTextEndPoint(Audio:UploadFile):
+    try:
+        with sr.AudioFile(BytesIO(Audio.file.read())) as File:
+            
+            audio=Recognizer.listen(File)
+        environ["GOOGLE_APPLICATION_CREDENTIALS"]="smms"
+        Text:str=Recognizer.recognize_google(audio,language="en-US") 
+    
+        if ("on" in Text and "light" in Text) or ("off" not in Text and "light" in Text):
+            return {"Status":True,"Message":"l"} # l ::LightOn
+        elif "light" in Text:
+            return {"Status":True,"Message":"o"} # o ::LightOff
+        
+        
+    except LookupError as e:
+        return {"Status":False,"Message":e}

Models/face_landmarker.task

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64184e229b263107bc2b804c6625db1341ff2bb731874b0bcc2fe6544e0bc9ff
+size 3758596

Router/AppRouter.py

@@ -0,0 +1,73 @@
+from fastapi import  APIRouter
+from fastapi.responses import HTMLResponse
+
+from Logic.SpeachToText import SpeachRouter
+from Logic.FaceRecognition.StoreImage import UploaderRouter
+from Logic.FaceRecognition.Trainer import ModelTrainer
+from Logic.IndoorLocalization.StoreNewLabel import IndoorLabel
+from Logic.FUsers.AddUser import UserAddRouter
+from Logic.FUsers.DeleteUser import DeleteUserRouter
+from Logic.GetModels.FaceModel import FaceModelRouter
+from Logic.GetModels.IndoorModel import IndoorModelRouter
+from Logic.IndoorLocalization.Trainer import ModelIndoorTrainer
+from Logic.FUsers.AddUserItem import UserItemAddRouter
+from Logic.FUsers.GetUsersItems import UserItemGetRouter
+from Logic.FUsers.DeleteUserItem import UserItemDeleteRouter
+from Logic.IndoorLocalization.UserDataSetUploader import IndoorDataUploader
+from Logic.Locations.GetMapOfuser import UserGetLocationRouter
+from Logic.Locations.SetLocationForUser import UserAddLocationRouter
+from Logic.Locations.GetDays import UserGetTrackingDateRouter
+from Logic.Login import LogInRouter
+from Logic.FUsers.GetAllUsers import GetUserRouter
+from Logic.FUsers.GetUserData import GetUserDataRouter
+MainRouter=APIRouter()
+MainRouter.include_router(LogInRouter)
+MainRouter.include_router(SpeachRouter)
+MainRouter.include_router(UploaderRouter)
+MainRouter.include_router(ModelTrainer)
+MainRouter.include_router(IndoorLabel)
+MainRouter.include_router(UserAddRouter)
+MainRouter.include_router(GetUserRouter)
+MainRouter.include_router(DeleteUserRouter)
+MainRouter.include_router(FaceModelRouter)
+MainRouter.include_router(IndoorModelRouter)
+MainRouter.include_router(ModelIndoorTrainer)
+MainRouter.include_router(UserItemAddRouter)
+MainRouter.include_router(UserItemDeleteRouter)
+MainRouter.include_router(UserItemGetRouter)
+MainRouter.include_router(IndoorDataUploader)
+MainRouter.include_router(UserAddLocationRouter)
+MainRouter.include_router(UserGetLocationRouter)
+MainRouter.include_router(UserGetTrackingDateRouter)
+MainRouter.include_router(GetUserDataRouter)
+@MainRouter.get("/",response_class=HTMLResponse)
+def home():
+    return '''
+<html>
+<head>
+<title>
+Face Recognition
+</title>
+<style>
+*{
+    padding:0px;
+    margin:0px;
+}
+h1:hover{
+    background:#00f;
+    color:#fff;
+    cursor:pointer;
+}
+</style>
+</head>
+<body>
+<div style="display:flex;align-items:center; justify-content: center;height: 100vh;color: #b3a1a1;">
+<h1 style="border: 1px solid #00f;padding: 30px;border-radius: 20px;">Face Recognition App By Aboellil</h1>
+</div>
+<body>
+</html>
+
+
+
+'''
+    

main.py

@@ -0,0 +1,68 @@
+from fastapi import FastAPI,Request
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import JSONResponse
+from Router.AppRouter import MainRouter
+from sqlite3 import connect
+from os.path import exists
+from  fastapi.middleware.cors import CORSMiddleware
+from passlib.context import CryptContext
+app=FastAPI()
+try:
+    
+    conn=connect("DataBase/DataBase.bd")
+    
+    conn.execute("PRAGMA foreign_keys=ON")
+    
+    conn.execute('''
+                    create table if not exists Users (UserId int primary key
+                    ,Email text not null ,
+                    UserName  text not null,
+                    Job  text not null,
+                    Phonenumber  text not null,
+                    Place  text not null,
+                    BDay  text not null,
+                    Password Text Not Null);
+                    ''')
+    
+
+    conn.execute('''
+                    create table if not exists TrackeringPoints 
+                    (UserId int  
+                    ,Longtude  REAL not null
+                    ,Lattitude REAL Not Null
+                    ,Day text not null
+                    ,Houre text not null
+                    , foreign key (UserId) references Users(UserId))
+                    ''')
+    conn.execute('''
+                    create table if not exists UserModelVersion (UserId int  
+                    ,FaceModel  INT not null
+                    ,IndoorModel INT Not Null,
+                    foreign key (UserId) references Users(UserId))
+                    ''')
+    conn.execute('''
+                    create table if not exists UserItems (
+                        UserId int  ,
+                    UserItemName  TEXT not null,
+                    foreign key (UserId) references Users(UserId))
+                    ''')
+
+    conn.close()
+    
+
+except Exception as e:
+    print(e)
+
+app.mount("/static",StaticFiles(directory="./static"),name="static")
+
+app.add_middleware(CORSMiddleware,
+                   allow_origins=["*"],
+                   allow_credentials=True,
+                   allow_methods=["*"],
+                   allow_headers=["admin-email","admin-password","content-type"],
+                   )
+
+
+
+
+app.include_router(MainRouter)

requirements.txt

@@ -0,0 +1,13 @@
+fastapi
+numpy
+uvicorn
+python-multipart
+tensorflow
+passlib
+sqlite3
+os
+sklearn
+keras
+pandas
+scipy
+speech_recognition