added new models and added api docs page

app/__init__.py

@@ -1,4 +1,4 @@
-from flask import Flask,session
+from flask import Flask,session,render_template,url_for,json
 from datetime import timedelta
 
 from face_detection import inference as fd
@@ -11,14 +11,17 @@ from face_recognition import helper as fr_helper
 
 face_detector=fd.face_detection("face_detection/Models/v1")
 face_detector.square_preprocessing=fd.square_pad()
-face_recognizer=fr.face_recognition("face_recognition/Models/v1")
-aligner_obj=aligner(min_aligner_confidence=0.6)
+# face_recognizer=fr.face_recognition("face_recognition/Models/v1")
+# face_recognizer=fr.face_recognition("face_recognition/Models/mobilenet_basic_lfw")
+face_recognizer=fr.face_recognition("face_recognition/Models/keras_mobilenet_emore_adamw")
+aligner_obj=aligner()
 
-image_size=544
-p_thres=0.7
-nms_thres=0.3
-batch_size=1
-face_detector.set_mode(p_thres,nms_thres,mode="sized",image_size=image_size,batch_size=batch_size)
+# image_size=544
+# p_thres=0.7
+# nms_thres=0.3
+# batch_size=1
+# face_detector.set_mode(p_thres,nms_thres,mode="sized",image_size=image_size,batch_size=batch_size)
+face_detector.mode="sized"
 
 
 # def create_app(config_class=Config):
@@ -51,5 +54,13 @@ def create_app():
     @app.route("/test/")
     def test_page():
         return "<h1>This is a test page</h1>"
+    
+    @app.route("/api/docs/json/",methods=["GET"])
+    def get_docs_json():
+        return json.load(open("app/static/docs/data.json","r"))
+
+    @app.route("/api/docs/")
+    def api_docs():
+        return render_template("docs/index.html")
 
     return app

app/api/routes.py

@@ -6,9 +6,10 @@ import numpy as np
 
 from app import face_detector,face_recognizer,aligner_obj,fd_get_crops,fr_helper
 
+from config import demo_config
 
 
-#################################################################################################################################################
+##################################################################settings#######################################################################
 
 def set_image_size(settings,mode):
     if mode=='small':
@@ -20,11 +21,22 @@ def set_image_size(settings,mode):
     else:
         raise("Error")
     
-
-
-
-def load_settings(username):
+def get_default_settings():
+    settings_dict={}
+    #p_thres,nms_thres,small_size,large_size,d_thres,a_thres,db_mode,fr_mode
+        
+    #p_thres,nms_thres
+    settings_dict['p_thres']=face_detector.model_config.p_thres
+    settings_dict['nms_thres']=face_detector.model_config.nms_thres
+    # d_thres
+    settings_dict['d_thres']=face_recognizer.model_config.d_thres
+
+    #small_size,large_size,a_thres,db_mode,fr_mode
+    settings_dict.update(demo_config)
     
+    return settings_dict
+
+def get_settings(username):
     dataBase = access_database_as_admin()
     cursor=dataBase.cursor()
     cursor.execute("select * from user_settings where username=%s",[username])
@@ -43,6 +55,10 @@ def load_settings(username):
     # Disconnecting from the server
     dataBase.commit()
     dataBase.close()
+    return settings
+
+def load_settings(settings):
+    
 
     # set face detector settings
     face_detector.p_thres=settings['p_thres']
@@ -57,7 +73,7 @@ def load_settings(username):
 
     return settings
 
-#################################################################################################################################################
+############################################################settings_end#########################################################################
 
 def is_auth(func):
     def wrapper_func(*args,**kwargs):
@@ -78,37 +94,7 @@ def is_auth(func):
     return wrapper_func
 
 
-@bp.route("/get_crops/",methods=["POST"])
-@is_auth
-def get_crops(username):
-
-    settings=load_settings(username)
-    set_image_size(settings,settings["db_mode"])
-    if "image_size" in request.form: face_detector.image_size=list(map(lambda x:int(x),request.form["image_size"].split(",")))
-    if "thres" in request.form: face_recognizer.thres=request.form["thres"]
-    print(face_detector.image_size)
-
-    file = request.files['image']
-    
-    image=Image.open(file.stream).convert("RGB")
-    image = ImageOps.exif_transpose(image)
-    image=np.array(image)
-    print(image.shape)
-
-    image,objs_found=face_detector.predict(image)
-    print(objs_found)
-      
-    all_aligned_crops=fd_get_crops(image,objs_found,aligner_obj,resize=(face_recognizer.model_config.input_size,face_recognizer.model_config.input_size))
-    all_aligned_crops_base64=[]
-
-    for i,aligned_crop in enumerate(all_aligned_crops):
-        all_aligned_crops_base64.append(image_to_base64(aligned_crop))
-
-    return jsonify({"message":"success","crops":all_aligned_crops_base64})
-
-
-
-
+#################################################################change_db############################################################################
 @bp.route("/add_person/",methods=["POST"])
 @is_auth
 def add_person(username):
@@ -156,15 +142,60 @@ def remove_person(username):
     return jsonify({"message":"success"})
     # return jsonify({"message":"success",'image':pred_img})
 
+#################################################################change_db_end############################################################################
+
+@bp.route("/get_crops/",methods=["POST"])
+@is_auth
+def get_crops(username):
+
+    settings=get_settings(username)
+
+    for setting in settings.keys():
+        if setting in request.form:
+            settings[setting]=request.form[setting]
+
+    load_settings(settings)
+
+    set_image_size(settings,settings["db_mode"])
+    if "image_size" in request.form: face_detector.image_size=list(map(lambda x:int(x),request.form["image_size"].split(",")))
+    print(face_detector.image_size)
+
+    file = request.files['image']
+    
+    image=Image.open(file.stream).convert("RGB")
+    image = ImageOps.exif_transpose(image)
+    image=np.array(image)
+    print(image.shape)
+
+    image,objs_found=face_detector.predict(image)
+    print(objs_found)
+      
+    all_aligned_crops=fd_get_crops(image,objs_found,aligner_obj,resize=(face_recognizer.model_config.input_size,face_recognizer.model_config.input_size))
+    all_aligned_crops_base64=[]
+
+    for i,aligned_crop in enumerate(all_aligned_crops):
+        all_aligned_crops_base64.append(image_to_base64(aligned_crop))
+
+    return jsonify({"message":"success","crops":all_aligned_crops_base64})
+
+
+
+
+
 
 @bp.route("/face_recognize/",methods=["POST"])
 @is_auth
 def face_recognition(username):
 
-    settings=load_settings(username)
+    settings=get_settings(username)
+
+    for setting in settings.keys():
+        if setting in request.form:
+            settings[setting]=request.form[setting]
+
+    load_settings(settings)
     set_image_size(settings,settings["fr_mode"])
     if "image_size" in request.form: face_detector.image_size=list(map(lambda x:int(x),request.form["image_size"].split(",")))
-    if "d_thres" in request.form: face_recognizer.thres=request.form["d_thres"]
     print(face_detector.image_size)
 
     # print(request.form)
@@ -183,16 +214,24 @@ def face_recognition(username):
     for i in range(len(faces)):
         print(faces[i],":",db_faces_features[i].shape)
     
-    # face_recognizer.set_face_db_and_mode(faces=faces,db_faces_features=db_faces_features,distance_mode="avg",recognition_mode="repeat")
-    face_recognizer.set_face_db_and_mode(faces=faces,db_faces_features=db_faces_features,distance_mode="best",recognition_mode="repeat")
+    
     img,objs_found=face_detector.predict(image)
     h,w=img.shape[:2]
     tree=fr_helper.objs_found_to_xml("test.jpg",w,h,objs_found)
-    tree=face_recognizer.predict(img,tree)
+
+    # face_recognizer.set_face_db_and_mode(faces=faces,db_faces_features=db_faces_features,distance_mode="avg",recognition_mode="repeat")
+    face_recognizer.set_face_db_and_mode(faces=faces,db_faces_features=db_faces_features,distance_mode="best",recognition_mode="repeat")
+
+    if len(faces)>0:
+        tree=face_recognizer.predict(img,tree)
+        
+        
+    # print(objs_found[0])
+    
+
     pred_img=fr_helper.show_pred_image(tree,img)
     pred_img=image_to_base64(pred_img)
     objs_found=fr_helper.xml_to_objs_found(tree) # everything is okay till here
-    # print(objs_found[0])
     
     objs_found=face_detector.square_preprocessing.rescale(objs_found)   #rescale coordinates to original image's resolution
     # print(objs_found[0])

app/demo/routes.py

@@ -11,9 +11,10 @@ import uuid
 from flask import render_template,request,send_from_directory,session,jsonify,json
 from app import helper
 from PIL import ImageOps
-from app.helper import generate_random_id,access_database_as_admin,image_to_base64,base64_to_image,add_row_user_table,read_row_user_table,read_user_table,remove_person_from_user_table
+from app.helper import generate_random_id,image_to_base64,base64_to_image
 from app.demo import bp
 import copy
+from config import demo_config
 
 
 
@@ -166,27 +167,43 @@ def face_recognition():
     return jsonify({"message":"success",'image':pred_img})  
 
 
+def get_default_settings():
+    settings_dict={}
+    #p_thres,nms_thres,small_size,large_size,d_thres,a_thres,db_mode,fr_mode
+        
+    #p_thres,nms_thres
+    settings_dict['p_thres']=face_detector.model_config.p_thres
+    settings_dict['nms_thres']=face_detector.model_config.nms_thres
+    # d_thres
+    settings_dict['d_thres']=face_recognizer.model_config.d_thres
+
+    #small_size,large_size,a_thres,db_mode,fr_mode
+    settings_dict.update(demo_config)
+    
+    return settings_dict
+
 @bp.route("/get_settings/",methods=['GET'])
 def get_settings():
     session.permanent=True
     if "demo" not in session:
-        dataBase = access_database_as_admin()
-        cursor=dataBase.cursor()
-        cursor.execute("select * from default_settings where page='demo'")
-
+        
         session["demo"]={'settings':dict()}
-        session["demo"]['settings']= dict(zip(cursor.column_names, cursor.fetchone()))
-        # Disconnecting from the server
-        dataBase.commit()
-        dataBase.close()
+        session["demo"]['settings']=get_default_settings()
+        
+
+        
+        
+        
 
     return session["demo"]['settings']
 
 @bp.route("/reset_settings/",methods=['GET'])
 def reset_settings():
     del session["demo"]
+    session["demo"]={'settings':dict()}
+    session["demo"]['settings']=get_default_settings()
 
-    return {"message":"success"}
+    return {"message":"success",**session["demo"]['settings']}
 
 @bp.route("/update_settings/",methods=['POST'])
 def update_settings():

app/static/demo/index/script.js

@@ -432,6 +432,22 @@ function hide_settings(){
 }
 
 
+function update_settings_html(res){
+    p_thres.value=p_thresValue.innerText=res['p_thres'];
+    nms_thres.value=nms_thresValue.innerText=res['nms_thres'];
+    
+    small_size.value=small_sizeValue.innerText=res['small_size'];
+    large_size.value=large_sizeValue.innerText=res['large_size'];
+
+    d_thres.value=d_thresValue.innerText=res['d_thres'];
+    a_thres.value=a_thresValue.innerText=res['a_thres'];
+
+    db_mode.value=res['db_mode'];
+    fr_mode.value=res['fr_mode'];
+    // console.log(res['db_mode'],res['fr_mode']);
+}
+
+
 
 function get_settings(){
     fetch("get_settings/",{
@@ -440,19 +456,7 @@ function get_settings(){
         return response.json();
     }).then(function(res){
         console.log(res);
-
-        p_thres.value=p_thresValue.innerText=res['p_thres'];
-        nms_thres.value=nms_thresValue.innerText=res['nms_thres'];
-        
-        small_size.value=small_sizeValue.innerText=res['small_size'];
-        large_size.value=large_sizeValue.innerText=res['large_size'];
-
-        d_thres.value=d_thresValue.innerText=res['d_thres'];
-        a_thres.value=a_thresValue.innerText=res['a_thres'];
-
-        db_mode.value=res['db_mode'];
-        fr_mode.value=res['fr_mode'];
-        console.log(res['db_mode'],res['fr_mode']);
+        update_settings_html(res);
     })
 }
 get_settings();
@@ -492,7 +496,7 @@ function reset_settings(){
     }).then(function(res){
         console.log(res);
         if(res['message']=='success')
-            get_settings();
+            update_settings_html(res);
     }
     );
 }

app/static/docs/data.json

@@ -0,0 +1,38 @@
+[
+    {
+        "color":"#df7fff",
+        "route_name":"get_crops",
+        "route":"/api/get_crops",
+        "method":"POST",
+        "summary":"This route is used to get face crops from any image",
+        "request_params":[
+            {"name":"image","summary":"Image to get face crops from.","type":"File","required":"*"},
+            {"name":"access_key","summary":"access key related with your account.","type":"json","required":"*"},
+            {"name":"settings-parameter","summary":"pass any settings for example \"d_thres\":0.3 .","type":"json","required":""}
+        ],
+        "response_params":[
+            {"name":"message","summary":"\"success\" if everything is fine.","type":"Text"},
+            {"name":"crops","summary":"return list of crop images.","type":"list of base64 values"}
+        ]
+    },
+    
+    {
+        "color":"#acff7f",
+        "route_name":"face_recognize",
+        "route":"/api/face_recognize",
+        "method":"POST",
+        "summary":"This route is used to do face recognition based on the images in the db.",
+        "request_params":[
+            {"name":"image","summary":"Image to get face crops from.","type":"File","required":"*"},
+            {"name":"access_key","summary":"access key related with your account.","type":"json","required":"*"},
+            {"name":"settings-parameter","summary":"pass any settings for example \"d_thres\":0.3 .","type":"json","required":""}
+        ],
+        "response_params":[
+            {"name":"message","summary":"\"success\" if everything is fine.","type":"Text"},
+            {"name":"pred_image","summary":"image with prediction boxes","type":"base64"},
+            {"name":"person_ids","summary":"list of person_id(\"face\" if face is not found)","type":"list of string"},
+            {"name":"crops","summary":"return list of crop images.","type":"list of base64 values"},
+            {"name":"objs_found","summary":"dictionary of faces found with coordinates and names .","type":"dictionary"}
+        ]
+    }
+]

app/static/docs/index.css

@@ -0,0 +1,20 @@
+*{
+    /* font-weight: bold; */
+    font-family: 'Poppins';
+}
+.container{
+    display:flex;
+    flex-direction: column;
+    align-items: center;
+}
+.endpoint{
+    /* height: 200px; */
+    /* background-color: aquamarine; */
+    background-color: aquamarine;
+    margin-top:50px;
+    width:80%;
+    padding:0px 10px;
+    border-radius: 20px;
+    
+    box-shadow: black 1px 2px 21px -10px;
+}

app/static/docs/index.js

@@ -0,0 +1,123 @@
+var base_url=window.location.href.split("/").slice(0,3).join("/");
+// console.log(base_url);
+
+
+var data={
+    "route_name":"get_crops",
+    "route":"/api/get_crops",
+    "method":"POST",
+    "summary":"This route is used to get face crops from any image",
+    "request_params":[
+        {"name":"image","summary":"Image to get face crops from.","type":"File","required":"*"},
+        {"name":"access_key","summary":"access key related with your account.","type":"json","required":"*"},
+        {"name":"settings-parameter","summary":"pass any settings for example \"d_thres\":0.3 .","type":"json","required":""},
+    ],
+    "response_params":[
+        {"name":"message","summary":"\"success\" if everything is fine.","type":"Text"},
+        {"name":"crops","summary":"return list of crop images.","type":"list of base64 values"},
+    ],
+}
+
+
+
+function add_endpoint(data){
+    // <div class="endpoint">
+    //             <h3 class="route_name">get_crops</h3> 
+    //             <h4>Method:<span class="method_type">POST</span></h4>
+    //             <p class="summary">This route is used to get face crops from any image</p>
+    //             <p><b>route:&#9;</b><span class="api_route">/api/get_crops</span></p>
+                
+                
+    //             <b>Request Parameters:</b>
+    //             <ul>
+    //                 <li>
+    //                     <span><span class="param_name">image<span>:&#9;</span>
+    //                     <span class="param_summary">Image to get face crops from.</span>
+    //                     <span>(Type:&#9;<span class="param_type">File</span>)</span>
+    //                 </li>
+    //                 <li>
+    //                     <span><span class="param_name">settings-parameter<span>:&#9;</span>
+    //                     <span class="param_summary">pass any settings for example "d_thres":0.3 .</span>
+    //                     <span>(Type:&#9;<span class="param_type">json</span>)</span>
+    //                 </li>
+    //                 <li>
+    //                     <span><span class="param_name">access_key<span>:&#9;</span>
+    //                     <span class="param_summary">access key related with your account.</span>
+    //                     <span>(Type:&#9;<span class="param_type">json</span>)</span>
+    //                 </li>
+                    
+    //             </ul>
+    //             <b>Response Body:</b>
+    //             <ul>
+    //                 <li>
+                        
+    //                     <span><span class="param_name">message<span>:&#9;</span>
+    //                     <span class="param_summary">"success" if everything is fine.</span>
+    //                     <span>(Type:&#9;<span class="param_type">Text</span>)</span>
+    //                 </li>
+    //                 <li>
+                        
+    //                     <span><span class="param_name">crops<span>:&#9;</span>
+    //                     <span class="param_summary">return list of crop images.</span>
+    //                     <span>(Type:&#9;<span class="param_type">list of base64 values</span>)</span>
+    //                 </li>
+                    
+    //             </ul>
+                
+                
+    //         </div>
+    var parent_div=document.querySelector(".container");
+    var endpoint=document.createElement("div");
+    endpoint.className="endpoint";
+    // console.log(("color" in data));
+    if ("color" in data) {
+        endpoint.style.backgroundColor=data["color"];
+    }
+    parent_div.appendChild(endpoint);
+    
+    endpoint.innerHTML+=`<h3 class="route_name">${data['route_name']}</h3> `;
+    endpoint.innerHTML+=`<h4>Method:&#9;<span class="method_type">${data['method']}</span></h4>`;
+    endpoint.innerHTML+=`<p class="summary">${data['summary']}</p>`;
+    endpoint.innerHTML+=`<p><b>route:&#9;</b><span class="api_route">${base_url+data["route"]}</span></p>`;
+    endpoint.innerHTML+=`<b>Request Parameters:</b>`;
+    
+    var params=document.createElement("ul");
+    endpoint.appendChild(params);
+
+    data['request_params'].map(param=>{
+        // request parameters
+
+        var list=document.createElement("li");
+        list.innerHTML+=`<span><span class="param_name">${param["name"]}<span>:&#9;</span>`;
+        list.innerHTML+=`<span class="param_summary">${param['summary']}</span>`;
+        list.innerHTML+=`<span>(Type:&#9;<span class="param_type">${param['type']}</span>)${param['required']}</span>`;
+        params.appendChild(list);
+
+    })
+    endpoint.innerHTML+=`<b>Response Body:</b>`;
+    var params=document.createElement("ul");
+    endpoint.appendChild(params);
+    data['response_params'].map(param=>{
+        // response parameters
+        
+        var list=document.createElement("li");
+        list.innerHTML+=`<span><span class="param_name">${param['name']}<span>:&#9;</span>`;
+        list.innerHTML+=`<span class="param_summary">${param["summary"]}</span>`;
+        list.innerHTML+=`<span>(Type:&#9;<span class="param_type">${param["type"]}</span>)</span>`;
+        params.appendChild(list);
+
+    })
+    
+}
+
+
+
+
+fetch("json/").then(res=>{return res.json();}).then(res=>{
+res.map(data=>{
+    add_endpoint(data);
+})
+})
+
+
+

app/static/user/dashboard.js

@@ -416,6 +416,20 @@ function hide_settings(){
     document.querySelector('#container').classList.remove("blur");
 }
 
+function update_settings_html(res){
+    p_thres.value=p_thresValue.innerText=res['p_thres'];
+    nms_thres.value=nms_thresValue.innerText=res['nms_thres'];
+    
+    small_size.value=small_sizeValue.innerText=res['small_size'];
+    large_size.value=large_sizeValue.innerText=res['large_size'];
+
+    d_thres.value=d_thresValue.innerText=res['d_thres'];
+    a_thres.value=a_thresValue.innerText=res['a_thres'];
+
+    db_mode.value=res['db_mode'];
+    fr_mode.value=res['fr_mode'];
+    // console.log(res['db_mode'],res['fr_mode']);
+}
 
 
 function get_settings(){
@@ -425,19 +439,8 @@ function get_settings(){
         return response.json();
     }).then(function(res){
         console.log(res);
-
-        p_thres.value=p_thresValue.innerText=res['p_thres'];
-        nms_thres.value=nms_thresValue.innerText=res['nms_thres'];
+        update_settings_html(res);
         
-        small_size.value=small_sizeValue.innerText=res['small_size'];
-        large_size.value=large_sizeValue.innerText=res['large_size'];
-
-        d_thres.value=d_thresValue.innerText=res['d_thres'];
-        a_thres.value=a_thresValue.innerText=res['a_thres'];
-
-        db_mode.value=res['db_mode'];
-        fr_mode.value=res['fr_mode'];
-        console.log(res['db_mode'],res['fr_mode']);
     })
 }
 get_settings();
@@ -477,7 +480,7 @@ function reset_settings(){
     }).then(function(res){
         console.log(res);
         if(res['message']=='success')
-            get_settings();
+            update_settings_html(res);
     }
     );
 }

app/templates/docs/index.html

@@ -0,0 +1,17 @@
+{% extends 'base.html' %}
+{% block title %}api documentations{% endblock %}
+{% block css %}
+    <link type="text/css" rel="stylesheet" href="{{ url_for('static',filename='docs/index.css') }}">
+    <!-- <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.3.0/css/all.min.css"> -->
+    <link href="https://fonts.googleapis.com/css2?family=Poppins&display=swap" rel="stylesheet">
+{% endblock %}
+{% block body %}        
+        <h1>API documentations</h1>
+        
+        <div class="container">
+            
+            
+        </div>
+        <script src="{{ url_for('static',filename='docs/index.js') }}"></script>
+        
+{% endblock %}

app/user/routes.py

@@ -10,6 +10,7 @@ from PIL import Image
 import os
 import numpy as np
 from app import face_detector,face_recognizer,aligner_obj,fd_get_crops,fr_helper,fd,fr
+from config import user_config
 
 
 
@@ -213,6 +214,22 @@ def get_image_size(mode):
     
 
 
+def get_default_settings():
+    settings_dict={}
+    #p_thres,nms_thres,small_size,large_size,d_thres,a_thres,db_mode,fr_mode
+        
+    #p_thres,nms_thres
+    settings_dict['p_thres']=face_detector.model_config.p_thres
+    settings_dict['nms_thres']=face_detector.model_config.nms_thres
+    # d_thres
+    settings_dict['d_thres']=face_recognizer.model_config.d_thres
+
+    #small_size,large_size,a_thres,db_mode,fr_mode
+    settings_dict.update(user_config)
+    
+    return settings_dict
+
+
 @bp.route("/get_settings/",methods=['GET'])
 def get_settings():
     global settings
@@ -225,13 +242,15 @@ def get_settings():
 
     if settings is None:
         # get default settings and insert a row in user_settings
-        cursor.execute("select p_thres,nms_thres,small_size,large_size,d_thres,a_thres,db_mode,fr_mode from default_settings where page='user'")
-        settings=cursor.fetchone()
-        columns=cursor.column_names
-        cursor.execute(f"insert into user_settings(username,{','.join(columns)}) values(%s,{','.join(map(lambda x:'%s',columns))})",(session['user']['username'],)+settings)
+        
+        settings=get_default_settings()
+        columns=["p_thres","nms_thres","small_size","large_size","d_thres","a_thres","db_mode","fr_mode"]
+        
+        cursor.execute(f"insert into user_settings(username,{','.join(columns)}) values(%s,{','.join(map(lambda x:'%s',columns))})",[session['user']['username']]+[settings[col] for col in columns])
     
+    else:
+        settings= dict(zip(columns, settings))
     
-    settings= dict(zip(columns, settings))
     # Disconnecting from the server
     dataBase.commit()
     dataBase.close()
@@ -240,24 +259,29 @@ def get_settings():
 
     return settings
 
+
 @bp.route("/reset_settings/",methods=['GET'])
 def reset_settings():
+    global settings
+
     dataBase = access_database_as_admin()
     cursor=dataBase.cursor()
     
-    cursor.execute("select p_thres,nms_thres,small_size,large_size,d_thres,a_thres,db_mode,fr_mode from default_settings where page='user'")
-    settings=cursor.fetchone()
-    columns=cursor.column_names
+    
+    settings=get_default_settings()
+    columns=["p_thres","nms_thres","small_size","large_size","d_thres","a_thres","db_mode","fr_mode"]
+    
+
     print(settings)
-    cursor.execute(f"update user_settings set {','.join(list(map(lambda x:x+'=%s',columns)))} where username=%s;",settings+(session['user']['username'],))
+    cursor.execute(f"update user_settings set {','.join(list(map(lambda x:x+'=%s',columns)))} where username=%s;",[settings[col] for col in columns]+[session['user']['username']])
     
     # Disconnecting from the server
     dataBase.commit()
     dataBase.close()
     
-    settings=dict()
+    
 
-    return {"message":"success"}
+    return {"message":"success",**settings}
 
 @bp.route("/update_settings/",methods=['POST'])
 def update_settings():

config.py

@@ -1,17 +1,20 @@
-import os
 
+demo_config={
 
-# face detector
-p_thres=0.7
-nms_thres=0.3
-small_size=544
-large_size=2080
+    "small_size":256,
+    "large_size":1024,
+    
+    "db_mode":'small',  # 'small','large','both'
+    "fr_mode":'large',   # 'small','large','both'
 
-# face aligner
-thres=0.6
+    "a_thres":0.6
+}
+user_config={
+    "small_size":544,
+    "large_size":2080,
+    
+    "db_mode":'small',  # 'small','large','both'
+    "fr_mode":'both',   # 'small','large','both'
 
-# face recognizer
-thres=0.5   # distance is almost 0 to 1
-
-# class Config:
-#     SECRET_KEY=os.environ.get("SECRET_KEY")
+    "a_thres":0.6
+}

face_detection/Models/v1/config.py

@@ -0,0 +1,2 @@
+p_thres=0.5
+nms_thres=0.3

face_detection/inference.py

@@ -3,6 +3,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 import math
 import copy
+import importlib
 
 
 
@@ -96,7 +97,11 @@ class face_detection:
         self.modes_available=["tiled","sized"]
         self.square_preprocessing=square_crop
 
-    def invoke_model(self,img,p=0.2,iou_threshold=0.3,batch_size=4):
+        config_file_path='.'.join(model_path.split("/"))+".config"
+        # print(config_file_path)
+        self.model_config= importlib.import_module(config_file_path)
+
+    def invoke_model(self,img,p,iou_threshold,batch_size):
         all_objs_found=[]
         
         for i in range(math.ceil(img.shape[0]/batch_size)):
@@ -151,7 +156,7 @@ class face_detection:
         return all_objs_found_joined
 
 
-    def set_mode(self,p_thres,nms_thres,batch_size=4,mode="tiled",**kwargs):
+    def set_mode(self,p_thres,nms_thres,batch_size=1,mode="sized",**kwargs):
         # mode : tiled or sized
         
         self.p_thres=p_thres

face_recognition/Models/keras_mobilenet_emore_adamw/config.py

@@ -0,0 +1,3 @@
+input_size=112
+d_thres=0.2830035090446472
+large_distance=-1

face_recognition/Models/keras_mobilenet_emore_adamw/keras_mobilenet_emore_adamw.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c5cec8f368a176dab4ccf48be1cd25aa7a4bb2ced049a38c86922f8bb5c70ac
+size 14285304

face_recognition/Models/keras_mobilenet_emore_adamw/model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d1d7a8631e59c14f774391e52187d07e20643b53058377276c89908c982516f
+size 14191896

face_recognition/Models/mobilenet_basic_lfw/config.py

@@ -0,0 +1,3 @@
+input_size=112
+d_thres=0.2830035090446472
+large_distance=-1

face_recognition/Models/mobilenet_basic_lfw/mobilenet_basic_lfw_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:886d91bf3bb317399f07222ff014bca71495fbd9ea35cd9722dfdb9987b4b851
+size 14290152

face_recognition/Models/mobilenet_basic_lfw/model.h5

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

face_recognition/aligner.py

@@ -10,7 +10,7 @@ import shutil
 
 
 class aligner:
-    def __init__(self,min_aligner_confidence):        
+    def __init__(self,min_aligner_confidence=0.5):        
         mp_face_mesh = mp.solutions.face_mesh
 
         self.face_mesh_images = mp_face_mesh.FaceMesh(static_image_mode=True, max_num_faces=1,

face_recognition/inference.py

@@ -24,15 +24,22 @@ class face_recognition:
     # print(config_file_path)
     self.model_config= importlib.import_module(config_file_path)
     # print(self.model_config)
-    self.thres=thres if thres is not None else self.model_config.thres
+    self.thres=thres if thres is not None else self.model_config.d_thres
     self.aligner=aligner(min_aligner_confidence)  if min_aligner_confidence is not None else aligner(config.min_aligner_confidence)
     self.feature_extractor=tf.keras.models.load_model(model_path+"/model.h5",compile=False)
     
     
 
-  def euclidean_distance(self,vectors):
-    squared_sum=np.sum(np.square(vectors[0]-vectors[1]),axis=-1,keepdims=True)
-    return np.sqrt(np.maximum(squared_sum,1e-7))
+  # def euclidean_distance(self,vectors):
+  #   squared_sum=np.sum(np.square(vectors[0]-vectors[1]),axis=-1,keepdims=True)
+  #   return np.sqrt(np.maximum(squared_sum,1e-7))
+
+  def new_distance(self,vectors):
+    ''' this distance metric is -1 to 1 
+        and it gives values close to 1 when matching 
+        and values close to -1 when not matching
+    '''
+    return (vectors[0]*vectors[1]).sum(-1)
 
 
 
@@ -55,12 +62,12 @@ class face_recognition:
       except:
         raise AssertionError(f"db_face_features shape{db_face_features.shape} does not match crop_img_features shape{new_crop_img_features.shape}")
       
-      distance=np.min(self.euclidean_distance([db_face_features,new_crop_img_features]),axis=0)[0]
+      distance=np.max(self.new_distance([db_face_features,new_crop_img_features]),axis=0)
       
-      if distance<=self.thres:
+      if distance>self.thres:
         all_distances.append(distance) # obj distance wrt to all faces in database
       else:
-        all_distances.append(self.model_config.large_distance) # not the person garruntied
+        all_distances.append(self.model_config.large_distance) # not the person guaranteed
     return all_distances
 
 
@@ -69,8 +76,8 @@ class face_recognition:
     faceidx_to_obj_dict=dict()
     for obj in distance_dict.keys():
       distances=np.array(distance_dict[obj])
-      min_distance,min_distance_idx = distances.min(),distances.argmin()
-      if min_distance<=self.thres:
+      min_distance,min_distance_idx = distances.max(),distances.argmax()
+      if min_distance>self.thres:
         obj.find('name').text = self.faces[min_distance_idx]
         distance_tag=ET.Element("distance")
         distance_tag.text="{:.2f}".format(min_distance)
@@ -78,42 +85,43 @@ class face_recognition:
     return faceidx_to_obj_dict
 
 
-  def assign_face_label(self,obj):
-      
-      # find min and argmin
-      min_distance,min_distance_idx = self.distance_dict[obj].min(),self.distance_dict[obj].argmin()
-      # base condition
-      if min_distance>=self.thres:
-        # print("end");
-        return;
-      if min_distance_idx not in self.faceidx_to_obj_dict:
-        self.faceidx_to_obj_dict[min_distance_idx]=(obj,min_distance)  # stores obj and distance
-      else:
-
-        if(min_distance>self.faceidx_to_obj_dict[min_distance_idx][1]):
-          self.distance_dict[obj][min_distance_idx]=self.model_config.large_distance
-          self.assign_face_label(obj)
-        else:
-          temp_obj,temp_min_distance=self.faceidx_to_obj_dict[min_distance_idx]
-          self.faceidx_to_obj_dict[min_distance_idx]=(obj,min_distance)  # stores obj and distance
-          self.distance_dict[temp_obj][min_distance_idx]=self.model_config.large_distance
-          self.assign_face_label(temp_obj)
 
 
   def no_repeat_allowed_face_recognition(self,distance_dict):
     
-    self.faceidx_to_obj_dict=dict()
+    def assign_face_label(obj):
+        
+        # find min and argmin
+        min_distance,min_distance_idx = distance_dict[obj].max(),distance_dict[obj].argmax()
+        # base condition
+        if min_distance<self.thres:
+          # print("end");
+          return;
+        elif min_distance_idx not in faceidx_to_obj_dict:
+          faceidx_to_obj_dict[min_distance_idx]=(obj,min_distance)  # stores obj and distance
+        else:
+
+          if(min_distance<faceidx_to_obj_dict[min_distance_idx][1]): # current is less matching
+            distance_dict[obj][min_distance_idx]=self.model_config.large_distance
+            assign_face_label(obj)
+          else: # current is more matching
+            temp_obj,temp_min_distance=faceidx_to_obj_dict[min_distance_idx]
+            faceidx_to_obj_dict[min_distance_idx]=(obj,min_distance)  # stores obj and distance
+            distance_dict[temp_obj][min_distance_idx]=self.model_config.large_distance
+            assign_face_label(temp_obj)
+    
+    faceidx_to_obj_dict=dict()
     for obj in distance_dict.keys():
-      self.assign_face_label(obj)
+      assign_face_label(obj)
       
-    for idx,(obj,distance) in self.faceidx_to_obj_dict.items():
+    for idx,(obj,distance) in faceidx_to_obj_dict.items():
       obj.find('name').text = self.faces[idx]
       distance_tag=ET.Element("distance")
       distance_tag.text="{:.2f}".format(distance)
       obj.append(distance_tag)
       # print(obj.find("distance").text)
     
-    return self.faceidx_to_obj_dict
+    return faceidx_to_obj_dict
     
 
   def forward_pass(self,img,tree,mode="repeat"):

setup_db.py

@@ -44,25 +44,25 @@ cursorObject.execute("""create table if not exists session_table(
     );
 """)
 
-cursorObject.execute("""drop table if exists default_settings""")
-cursorObject.execute("""create table if not exists default_settings(
-    page varchar(30) not null unique,
-    p_thres float not null,
-    nms_thres float not null,
-    small_size integer not null default 544,
-    large_size integer not null default 2080,
-    d_thres float not null,
-    a_thres float not null,
-    db_mode enum('small','large','both') not null,
-    fr_mode enum('small','large','both') not null
-    );
-""")
+# cursorObject.execute("""drop table if exists default_settings""")
+# cursorObject.execute("""create table if not exists default_settings(
+#     page varchar(30) not null unique,
+#     p_thres float not null,
+#     nms_thres float not null,
+#     small_size integer not null default 544,
+#     large_size integer not null default 2080,
+#     d_thres float not null,
+#     a_thres float not null,
+#     db_mode enum('small','large','both') not null,
+#     fr_mode enum('small','large','both') not null
+#     );
+# """)
 
-cursorObject.execute("""insert into default_settings(page,p_thres,nms_thres,small_size,large_size,d_thres,a_thres,db_mode,fr_mode) values(
-                'demo',0.5,0.3,256,1024,0.5,0.6,'small','large');""")
+# cursorObject.execute("""insert into default_settings(page,p_thres,nms_thres,small_size,large_size,d_thres,a_thres,db_mode,fr_mode) values(
+#                 'demo',0.5,0.3,256,1024,0.5,0.6,'small','large');""")
 
-cursorObject.execute("""insert into default_settings(page,p_thres,nms_thres,small_size,large_size,d_thres,a_thres,db_mode,fr_mode) values(
-                'user',0.7,0.3,544,2080,0.5,0.6,'small','both');""")
+# cursorObject.execute("""insert into default_settings(page,p_thres,nms_thres,small_size,large_size,d_thres,a_thres,db_mode,fr_mode) values(
+#                 'user',0.7,0.3,544,2080,0.5,0.6,'small','both');""")
 
 
 # cursorObject.execute("""drop table if exists user_settings""")

test.py

@@ -0,0 +1,46 @@
+import tensorflow as tf
+import numpy as np
+import cv2
+
+def euclidean_distance(vectors):
+    squared_sum=np.sum(np.square(vectors[0]-vectors[1]),axis=-1,keepdims=True)
+    return np.sqrt(np.maximum(squared_sum,1e-7))
+
+def new_distance(vectors):
+    return (vectors[0]*vectors[1]).sum(-1)
+
+path="face_recognition/Models/mobilenet_basic_lfw/mobilenet_basic_lfw_model.h5"
+# path="face_recognition/Models/keras_mobilenet_emore_adamw/keras_mobilenet_emore_adamw.h5"
+
+model2=tf.keras.models.load_model(path,compile=False)
+
+x_input=tf.keras.layers.Input(shape=(112,112,3))
+x_preprocess=tf.keras.layers.Lambda(lambda x:(x - 127.5) * 0.0078125)(x_input)
+x=model2(x_preprocess,training=False)
+x=tf.keras.layers.Lambda(lambda x:tf.math.l2_normalize(x, axis=-1))(x)
+model2=tf.keras.Model(x_input,x)
+# model2.summary()
+
+
+# cv2.imread("")
+# for layer in model2.layers:
+#     if isinstance(layer,tf.keras.layers.Activation):
+#         print(layer.activation)
+
+img1=cv2.resize(cv2.imread("C:/Users/Home/Desktop/college stuff/vasu_dataset/all/priyanshi/7.jpg")[:,:,::-1],[112,112])[None]
+img2=cv2.resize(cv2.imread("C:/Users/Home/Desktop/college stuff/vasu_dataset/all/shivansh/12.jpg")[:,:,::-1],[112,112])[None]
+v1=(model2.predict(img1,verbose=0))
+v2=(model2.predict(img2,verbose=0))
+
+
+print("euclidean_distance:",euclidean_distance([v1,v2]))
+print("new_distance:",new_distance([v1,v2]))
+if(new_distance([v1,v2])[0]>0.2830035090446472):
+    print("matching")
+else:
+    print("not matching")
+
+
+
+model2.save(path.rsplit("/",1)[0]+"/model.h5")
+print("model save to :\t",path.rsplit("/",1)[0]+"/model.h5")