Upload 25 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
+libfacesdk2.so filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,21 @@
+FROM openvino/ubuntu20_runtime:2022.3.0
+USER root
+
+RUN apt-get update -y
+RUN apt-get install -y libcurl4-openssl-dev libssl-dev libgomp1 libpugixml-dev
+
+RUN mkdir -p /root/kby-ai-face
+WORKDIR /root/kby-ai-face
+COPY ./libfacesdk2.so .
+COPY ./libimutils.so /usr/lib/libimutils.so
+COPY ./facesdk.py .
+COPY ./facebox.py .
+COPY ./app.py .
+COPY ./demo.py .
+COPY ./run.sh .
+COPY ./face_examples ./face_examples
+COPY ./requirements.txt .
+COPY ./data ./data
+RUN pip3 install -r requirements.txt
+CMD ["./run.sh"]
+EXPOSE 8080 9000

app.py

@@ -0,0 +1,223 @@
+import sys
+sys.path.append('.')
+
+import os
+import numpy as np
+import base64
+import io
+
+from PIL import Image
+from flask import Flask, request, jsonify
+from facesdk import getMachineCode
+from facesdk import setActivation
+from facesdk import initSDK
+from facesdk import faceDetection
+from facesdk import templateExtraction
+from facesdk import similarityCalculation
+from facebox import FaceBox
+
+verifyThreshold = 0.67
+
+maxFaceCount = 1
+
+licensePath = "license.txt"
+license = ""
+
+# Get a specific environment variable by name
+license = os.environ.get("LICENSE")
+
+# Check if the variable exists
+if license is not None:
+    print("Value of LICENSE:", license)
+else:
+    license = ""
+    try:
+        with open(licensePath, 'r') as file:
+            license = file.read().strip()
+    except IOError as exc:
+        print("failed to open license.txt: ", exc.errno)
+    print("license: ", license)
+
+machineCode = getMachineCode()
+print("machineCode: ", machineCode.decode('utf-8'))
+
+
+ret = setActivation(license.encode('utf-8'))
+print("activation: ", ret)
+
+ret = initSDK("data".encode('utf-8'))
+print("init: ", ret)
+
+app = Flask(__name__) 
+
+@app.route('/compare_face', methods=['POST'])
+def compare_face():
+    result = "None"
+    similarity = -1
+    face1 = None
+    face2 = None
+
+    file1 = request.files['file1']
+    file2 = request.files['file2']
+
+    try:
+        image1 = Image.open(file1).convert('RGB')
+    except:
+        result = "Failed to open file1"
+        response = jsonify({"compare_result": result, "compare_similarity": similarity, "face1": face1, "face2": face2})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+
+    try:
+        image2 = Image.open(file2).convert('RGB')
+    except:
+        result = "Failed to open file2"
+        response = jsonify({"compare_result": result, "compare_similarity": similarity, "face1": face1, "face2": face2})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+    image_np1 = np.asarray(image1)
+    image_np2 = np.asarray(image2)
+
+    faceBoxes1 = (FaceBox * maxFaceCount)()
+    faceCount1 = faceDetection(image_np1, image_np1.shape[1], image_np1.shape[0], faceBoxes1, maxFaceCount)
+
+    faceBoxes2 = (FaceBox * maxFaceCount)()
+    faceCount2 = faceDetection(image_np2, image_np2.shape[1], image_np2.shape[0], faceBoxes2, maxFaceCount)
+
+    if faceCount1 == 1 and faceCount2 == 1:
+        templateExtraction(image_np1, image_np1.shape[1], image_np1.shape[0], faceBoxes1[0])
+        templateExtraction(image_np2, image_np2.shape[1], image_np2.shape[0], faceBoxes2[0])
+        similarity = similarityCalculation(faceBoxes1[0].templates, faceBoxes2[0].templates)
+        if similarity > verifyThreshold:
+            result = "Same person"
+        else:
+            result = "Different person"
+    elif faceCount1 == 0:
+        result = "No face1"
+    elif faceCount2 == 0:
+        result = "No face2"
+
+    if faceCount1 == 1:
+        landmark_68 = []
+        for j in range(68):
+            landmark_68.append({"x": faceBoxes1[0].landmark_68[j * 2], "y": faceBoxes1[0].landmark_68[j * 2 + 1]})
+
+        face1 = {"x1": faceBoxes1[0].x1, "y1": faceBoxes1[0].y1, "x2": faceBoxes1[0].x2, "y2": faceBoxes1[0].y2, 
+                      "yaw": faceBoxes1[0].yaw, "roll": faceBoxes1[0].roll, "pitch": faceBoxes1[0].pitch,
+                      "face_quality": faceBoxes1[0].face_quality, "face_luminance": faceBoxes1[0].face_luminance, "eye_dist": faceBoxes1[0].eye_dist,
+                      "left_eye_closed": faceBoxes1[0].left_eye_closed, "right_eye_closed": faceBoxes1[0].right_eye_closed,
+                      "face_occlusion": faceBoxes1[0].face_occlusion, "mouth_opened": faceBoxes1[0].mouth_opened,
+                      "landmark_68": landmark_68}
+
+    if faceCount2 == 1:
+        landmark_68 = []
+        for j in range(68):
+            landmark_68.append({"x": faceBoxes2[0].landmark_68[j * 2], "y": faceBoxes2[0].landmark_68[j * 2 + 1]})
+
+        face2 = {"x1": faceBoxes2[0].x1, "y1": faceBoxes2[0].y1, "x2": faceBoxes2[0].x2, "y2": faceBoxes2[0].y2, 
+                      "yaw": faceBoxes2[0].yaw, "roll": faceBoxes2[0].roll, "pitch": faceBoxes2[0].pitch,
+                      "face_quality": faceBoxes2[0].face_quality, "face_luminance": faceBoxes2[0].face_luminance, "eye_dist": faceBoxes2[0].eye_dist,
+                      "left_eye_closed": faceBoxes2[0].left_eye_closed, "right_eye_closed": faceBoxes2[0].right_eye_closed,
+                      "face_occlusion": faceBoxes2[0].face_occlusion, "mouth_opened": faceBoxes2[0].mouth_opened,
+                      "landmark_68": landmark_68}
+
+    response = jsonify({"compare_result": result, "compare_similarity": similarity, "face1": face1, "face2": face2})
+
+    response.status_code = 200
+    response.headers["Content-Type"] = "application/json; charset=utf-8"
+    return response
+
+@app.route('/compare_face_base64', methods=['POST'])
+def compare_face_base64():
+    result = "None"
+    similarity = -1
+    face1 = None
+    face2 = None
+
+    content = request.get_json()
+
+    try:
+        imageBase64_1 = content['base64_1']
+        image_data1 = base64.b64decode(imageBase64_1)    
+        image1 = Image.open(io.BytesIO(image_data1)).convert('RGB')
+    except:
+        result = "Failed to open file1"
+        response = jsonify({"compare_result": result, "compare_similarity": similarity, "face1": face1, "face2": face2})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+    
+    try:
+        imageBase64_2 = content['base64_2']
+        image_data2 = base64.b64decode(imageBase64_2)
+        image2 = Image.open(io.BytesIO(image_data2)).convert('RGB')
+    except IOError as exc:
+        result = "Failed to open file2"
+        response = jsonify({"compare_result": result, "compare_similarity": similarity, "face1": face1, "face2": face2})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+    image_np1 = np.asarray(image1)
+    image_np2 = np.asarray(image2)
+
+    faceBoxes1 = (FaceBox * maxFaceCount)()
+    faceCount1 = faceDetection(image_np1, image_np1.shape[1], image_np1.shape[0], faceBoxes1, maxFaceCount)
+
+    faceBoxes2 = (FaceBox * maxFaceCount)()
+    faceCount2 = faceDetection(image_np2, image_np2.shape[1], image_np2.shape[0], faceBoxes2, maxFaceCount)
+
+    if faceCount1 == 1 and faceCount2 == 1:
+        templateExtraction(image_np1, image_np1.shape[1], image_np1.shape[0], faceBoxes1[0])
+        templateExtraction(image_np2, image_np2.shape[1], image_np2.shape[0], faceBoxes2[0])
+        similarity = similarityCalculation(faceBoxes1[0].templates, faceBoxes2[0].templates)
+        if similarity > verifyThreshold:
+            result = "Same person"
+        else:
+            result = "Different person"
+    elif faceCount1 == 0:
+        result = "No face1"
+    elif faceCount2 == 0:
+        result = "No face2"
+
+    if faceCount1 == 1:
+        landmark_68 = []
+        for j in range(68):
+            landmark_68.append({"x": faceBoxes1[0].landmark_68[j * 2], "y": faceBoxes1[0].landmark_68[j * 2 + 1]})
+
+        face1 = {"x1": faceBoxes1[0].x1, "y1": faceBoxes1[0].y1, "x2": faceBoxes1[0].x2, "y2": faceBoxes1[0].y2, 
+                      "yaw": faceBoxes1[0].yaw, "roll": faceBoxes1[0].roll, "pitch": faceBoxes1[0].pitch,
+                      "face_quality": faceBoxes1[0].face_quality, "face_luminance": faceBoxes1[0].face_luminance, "eye_dist": faceBoxes1[0].eye_dist,
+                      "left_eye_closed": faceBoxes1[0].left_eye_closed, "right_eye_closed": faceBoxes1[0].right_eye_closed,
+                      "face_occlusion": faceBoxes1[0].face_occlusion, "mouth_opened": faceBoxes1[0].mouth_opened,
+                      "landmark_68": landmark_68}
+
+    if faceCount2 == 1:
+        landmark_68 = []
+        for j in range(68):
+            landmark_68.append({"x": faceBoxes2[0].landmark_68[j * 2], "y": faceBoxes2[0].landmark_68[j * 2 + 1]})
+
+        face2 = {"x1": faceBoxes2[0].x1, "y1": faceBoxes2[0].y1, "x2": faceBoxes2[0].x2, "y2": faceBoxes2[0].y2, 
+                      "yaw": faceBoxes2[0].yaw, "roll": faceBoxes2[0].roll, "pitch": faceBoxes2[0].pitch,
+                      "face_quality": faceBoxes2[0].face_quality, "face_luminance": faceBoxes2[0].face_luminance, "eye_dist": faceBoxes2[0].eye_dist,
+                      "left_eye_closed": faceBoxes2[0].left_eye_closed, "right_eye_closed": faceBoxes2[0].right_eye_closed,
+                      "face_occlusion": faceBoxes2[0].face_occlusion, "mouth_opened": faceBoxes2[0].mouth_opened,
+                      "landmark_68": landmark_68}
+
+    response = jsonify({"compare_result": result, "compare_similarity": similarity, "face1": face1, "face2": face2})
+
+    response.status_code = 200
+    response.headers["Content-Type"] = "application/json; charset=utf-8"
+    return response
+
+if __name__ == '__main__':
+    port = int(os.environ.get("PORT", 8080))
+    app.run(host='0.0.0.0', port=port)

data/detect.bin

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

data/eye.bin

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

data/landmark.bin

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

data/templates.bin

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

demo.py

@@ -0,0 +1,141 @@
+import gradio as gr
+import requests
+import datadog_api_client
+from PIL import Image
+
+def compare_face(frame1, frame2):
+    url = "http://127.0.0.1:8080/compare_face"
+    files = {'file1': open(frame1, 'rb'), 'file2': open(frame2, 'rb')}
+
+    r = requests.post(url=url, files=files)
+
+    html = None
+    faces = None
+
+    compare_result = r.json().get('compare_result')
+    compare_similarity = r.json().get('compare_similarity')
+
+    html = ("<table>"
+                "<tr>"
+                    "<th>Compare Result</th>"
+                    "<th>Value</th>"
+                "</tr>"
+                "<tr>"
+                    "<td>Result</td>"
+                    "<td>{compare_result}</td>"
+                "</tr>"
+                "<tr>"
+                    "<td>Similarity</td>"
+                    "<td>{compare_similarity}</td>"
+                "</tr>"
+                "</table>".format(compare_result=compare_result, compare_similarity=compare_similarity))
+
+    try:
+        image1 = Image.open(frame1)
+        image2 = Image.open(frame2)
+
+        face1 = None
+        face2 = None
+
+        if r.json().get('face1') is not None:
+            face = r.json().get('face1')
+            x1 = face.get('x1')
+            y1 = face.get('y1')
+            x2 = face.get('x2')
+            y2 = face.get('y2')
+
+            if x1 < 0:
+                x1 = 0
+            if y1 < 0:
+                y1 = 0
+            if x2 >= image1.width:
+                x2 = image1.width - 1
+            if y2 >= image1.height:
+                y2 = image1.height - 1
+
+            face1 = image1.crop((x1, y1, x2, y2))
+            face_image_ratio = face1.width / float(face1.height)
+            resized_w = int(face_image_ratio * 150)
+            resized_h = 150
+
+            face1 = face1.resize((int(resized_w), int(resized_h)))
+
+        if r.json().get('face2') is not None:
+            face = r.json().get('face2')
+            x1 = face.get('x1')
+            y1 = face.get('y1')
+            x2 = face.get('x2')
+            y2 = face.get('y2')
+
+            if x1 < 0:
+                x1 = 0
+            if y1 < 0:
+                y1 = 0
+            if x2 >= image2.width:
+                x2 = image2.width - 1
+            if y2 >= image2.height:
+                y2 = image2.height - 1
+
+            face2 = image2.crop((x1, y1, x2, y2))
+            face_image_ratio = face2.width / float(face2.height)
+            resized_w = int(face_image_ratio * 150)
+            resized_h = 150
+
+            face2 = face2.resize((int(resized_w), int(resized_h)))
+
+        if face1 is not None and face2 is not None:
+            new_image = Image.new('RGB',(face1.width + face2.width + 10, 150), (80,80,80))
+
+            new_image.paste(face1,(0,0))
+            new_image.paste(face2,(face1.width + 10, 0))
+            faces = new_image.copy()
+        elif face1 is not None and face2 is None:
+            new_image = Image.new('RGB',(face1.width + face1.width + 10, 150), (80,80,80))
+
+            new_image.paste(face1,(0,0))
+            faces = new_image.copy()
+        elif face1 is None and face2 is not None:
+            new_image = Image.new('RGB',(face2.width + face2.width + 10, 150), (80,80,80))
+
+            new_image.paste(face2,(face2.width + 10, 0))
+            faces = new_image.copy()
+
+    except:
+        pass
+
+    return [faces, html]
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+    # KBY-AI
+    We offer SDKs for Face Recognition, Face Liveness Detection(Face Anti-Spoofing), and ID Card Recognition.<br/>
+    Besides that, we can provide several AI models and development services in machine learning.
+
+    ## Simple Installation & Simple API
+    ```
+    sudo docker pull kbyai/face-recognition:latest
+    sudo docker run -e LICENSE="xxxxx" -p 8081:8080 -p 9001:9000 kbyai/face-recognition:latest
+    ```      
+    ## KYC Verification Demo
+    https://github.com/kby-ai/KYC-Verification    
+    """
+    )
+    with gr.TabItem("Face Recognition"):
+        with gr.Row():
+            with gr.Column():
+                compare_face_input1 = gr.Image(type='filepath')
+                gr.Examples(['face_examples/1.jpg', 'face_examples/3.jpg', 'face_examples/5.jpg', 'face_examples/7.jpg', 'face_examples/9.jpg'], 
+                            inputs=compare_face_input1)
+                compare_face_button = gr.Button("Compare Face")
+            with gr.Column():
+                compare_face_input2 = gr.Image(type='filepath')
+                gr.Examples(['face_examples/2.jpg', 'face_examples/4.jpg', 'face_examples/6.jpg', 'face_examples/8.jpg', 'face_examples/10.jpg'], 
+                            inputs=compare_face_input2)
+            with gr.Column():
+                compare_face_output = gr.Image(type="pil").style(height=150)
+                compare_result_output = gr.HTML(label='Result')
+
+        compare_face_button.click(compare_face, inputs=[compare_face_input1, compare_face_input2], outputs=[compare_face_output, compare_result_output])
+
+demo.launch(server_name="0.0.0.0", server_port=9000)

facebox.py

@@ -0,0 +1,11 @@
+from ctypes import *
+
+class FaceBox(Structure):
+    _fields_ = [("x1", c_int32), ("y1", c_int32), ("x2", c_int32), ("y2", c_int32), 
+        ("yaw", c_float), ("roll", c_float), ("pitch", c_float), 
+        ("face_quality", c_float), ("face_luminance", c_float), ("eye_dist", c_float),
+        ("left_eye_closed", c_float), ("right_eye_closed", c_float), 
+        ("face_occlusion", c_float), ("mouth_opened", c_float), 
+        ("landmark_68", c_float * 136),
+        ("templates", c_ubyte * 2048)        
+        ]

facesdk.py

@@ -0,0 +1,32 @@
+import os
+
+from ctypes import *
+from numpy.ctypeslib import ndpointer
+from facebox import FaceBox
+
+libPath = os.path.abspath(os.path.dirname(__file__)) + '/libfacesdk2.so'
+facesdk = cdll.LoadLibrary(libPath)
+
+getMachineCode = facesdk.getMachineCode
+getMachineCode.argtypes = []
+getMachineCode.restype = c_char_p
+
+setActivation = facesdk.setActivation
+setActivation.argtypes = [c_char_p]
+setActivation.restype = c_int32
+
+initSDK = facesdk.initSDK
+initSDK.argtypes = [c_char_p]
+initSDK.restype = c_int32
+
+faceDetection = facesdk.faceDetection
+faceDetection.argtypes = [ndpointer(c_ubyte, flags='C_CONTIGUOUS'), c_int32, c_int32, POINTER(FaceBox), c_int32]
+faceDetection.restype = c_int32
+
+templateExtraction = facesdk.templateExtraction
+templateExtraction.argtypes = [ndpointer(c_ubyte, flags='C_CONTIGUOUS'), c_int32, c_int32, POINTER(FaceBox)]
+templateExtraction.restype = c_int32
+
+similarityCalculation = facesdk.similarityCalculation
+similarityCalculation.argtypes = [c_ubyte * 2048, c_ubyte * 2048]
+similarityCalculation.restype = c_float

libfacesdk2.so

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

license.txt

@@ -0,0 +1,5 @@
+X3tZBYEsEN2uHpfhqE1ey7bYJxW+pqBE+Niw3KOXnLkGkySze00sGuLI1SwbqsvYXfZ6V4tVa8gc
+tiLBXVxkagOO6KjLYPLjxZM59gi3RYB8FoNYulaITilxNPu/5QQrRmEGJ7Qef3ewdlIv20IqsZOx
+NB2vSBEO263OSogqT/lOpCAAUQhyxApY5iJsh6j+aWBSHkgx8XOscEw3x7m+DBHqKy0M6Vncnwla
+gkY9O53wwCqyTljvUmxIBRYUqdaxND82a0XgGk5armnaK2gRN1zKSW+cNd4s2nUKH07AlEeKCUqz
+OdzWhwdHQM/ULhAl1Oyyiw7NmUBLC7XmprB8EA==

requirements.txt

@@ -0,0 +1,6 @@
+flask
+flask-cors
+Pillow
+numpy
+gradio==3.50.2
+datadog_api_client

run.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+cd /root/kby-ai-face
+exec python3 demo.py &
+exec python3 app.py