Upload 40 files

.gitattributes

@@ -33,3 +33,7 @@ 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
+dependency/lib/libonnxruntime.so filter=lfs diff=lfs merge=lfs -text
+dependency/lib/libopyfaceenv.so filter=lfs diff=lfs merge=lfs -text
+engine/libopyfacerecog.so filter=lfs diff=lfs merge=lfs -text
+examples/5.webp filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -1 +1,26 @@
-aaa
+FROM python:3.8-slim
+
+ENV CONTAINER_TIMEZONE=UTC
+RUN ln -snf /usr/share/zoneinfo/$CONTAINER_TIMEZONE /etc/localtime && echo $CONTAINER_TIMEZONE > /etc/timezone
+
+# Create directory for the application
+RUN mkdir -p /home/recognito_fr
+
+# Set the working directory
+WORKDIR /home/recognito_fr
+
+# Copy the application files into the container
+COPY . .
+
+# Make the scripts executable
+RUN chmod +x install.sh run_demo.sh
+
+# Run the install.sh script to perform any installation tasks
+RUN apt-get update && apt-get install -y sudo
+RUN ./install.sh
+
+# Expose port 8000(flask), 7860(gradio)
+EXPOSE 8000 7860
+
+# Set the default command to run the application
+ENTRYPOINT ["./run_demo.sh"]

app.py

@@ -0,0 +1,258 @@
+import sys
+sys.path.append('.')
+
+import os
+import numpy as np
+import base64
+import json
+import io
+from PIL import Image, ExifTags
+from flask import Flask, request, jsonify
+from engine.header import *
+
+maxFaceCount1 = 5
+maxFaceCount2 = 10
+
+file_path = os.path.abspath(__file__)
+root_path = os.path.dirname(file_path)
+
+app = Flask(__name__) 
+app.config['SITE'] = "http://0.0.0.0:8000/"
+app.config['DEBUG'] = False
+
+device_id = getHWID().decode('utf-8')
+print_info('\t <Hardware ID> \t\t {}'.format(device_id))
+
+license = os.environ.get("FR_LICENSE_KEY")
+dict_path = os.path.join(root_path, "engine")
+
+ret = -1
+if license is None:
+    try:
+        licenseKeyPath = os.path.join(root_path, "license.txt")
+        with open(licenseKeyPath, 'r') as file:
+            license = file.read().strip()
+    except IOError as exc:
+        print_error(f"failed to open license.txt: {exc.errno}")
+
+print_log(f"License Key: \n{license}")
+ret = setLicenseKey(license.encode('utf-8'))
+print_log(f"Set License: {ret}")
+
+ret = initSDK(dict_path.encode('utf-8'))
+if ret == 0:
+    print_log("Successfully init SDK!")
+else:
+    print_error(f"Failed to init SDK, Error code {ret}")
+    exit(-1)
+
+def apply_exif_rotation(image):
+    try:
+        exif = image._getexif()
+        if exif is not None:
+            for orientation in ExifTags.TAGS.keys():
+                if ExifTags.TAGS[orientation] == 'Orientation':
+                    break
+
+            # Get the orientation value
+            orientation = exif.get(orientation, None)
+
+            # Apply the appropriate rotation based on the orientation
+            if orientation == 3:
+                image = image.rotate(180, expand=True)
+            elif orientation == 6:
+                image = image.rotate(270, expand=True)
+            elif orientation == 8:
+                image = image.rotate(90, expand=True)
+
+    except AttributeError:
+        print_error("No EXIF data found")
+
+    return image
+
+@app.route('/compare_face', methods=['POST'])
+def compare_face():
+    file1 = request.files['image1']
+    file2 = request.files['image2']
+
+    try:
+        image1 = apply_exif_rotation(Image.open(file1)).convert('RGB')        
+    except:
+        result = "Failed to open file1"
+        response = jsonify({"resultCode": result})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+    try:
+        image2 = apply_exif_rotation(Image.open(file2)).convert('RGB')        
+    except:
+        result = "Failed to open file2"
+        response = jsonify({"resultCode": result})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+    image_np1 = np.asarray(image1)
+    faces1 = (Face * maxFaceCount1)()
+    faceNum1 = processImage(image_np1, image_np1.shape[1], image_np1.shape[0], faces1, maxFaceCount1)
+
+    faces1_result = []
+    for i in range(faceNum1):
+        face = {"x": faces1[i].x, "y": faces1[i].y, "width": faces1[i].width, "height": faces1[i].height}
+        faces1_result.append(face)
+
+    image_np2 = np.asarray(image2)
+    faces2 = (Face * maxFaceCount1)()
+    faceNum2 = processImage(image_np2, image_np2.shape[1], image_np2.shape[0], faces2, maxFaceCount1)
+
+    faces2_result = []
+    for i in range(faceNum2):
+        face = {"x": faces2[i].x, "y": faces2[i].y, "width": faces2[i].width, "height": faces2[i].height}
+        faces2_result.append(face)
+
+    if faceNum1 > 0 and faceNum2 > 0:
+        results = []
+        for i in range(faceNum1):
+            for j in range(faceNum2):                
+                score = verifyFeat(faces1[i].featSize, faces1[i].featData, faces2[j].featSize, faces2[j].featData)
+                match_result = {"face1": i, "face2": j, "score": score}
+                results.append(match_result)
+
+        response = jsonify({"resultCode": "Ok", "faces1": faces1_result, "faces2": faces2_result, "results": results})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+    elif faceNum1 == 0:
+        response = jsonify({"resultCode": "No face1", "faces1": faces1, "faces2": faces2})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+    elif faceNum2 == 0:
+        response = jsonify({"resultCode": "No face2", "faces1": faces1, "faces2": faces2})
+
+        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():
+    base64_image1 = ""
+    base64_image2 = ""
+
+    try:
+        content = request.get_json()
+        base64_image1 = content['image1_base64']
+
+        image_data1 = base64.b64decode(base64_image1)
+        image1 = apply_exif_rotation(Image.open(io.BytesIO(image_data1))).convert("RGB")
+    except:
+        result = "Failed to parse image1 base64"
+        response = jsonify({"resultCode": result})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+    try:
+        content = request.get_json()
+        base64_image2 = content['image2_base64']
+
+        image_data2 = base64.b64decode(base64_image2)
+        image2 = apply_exif_rotation(Image.open(io.BytesIO(image_data2))).convert("RGB")
+    except:
+        result = "Failed to parse image2 base64"
+        response = jsonify({"resultCode": result})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+    image_np1 = np.asarray(image1)
+    faces1 = (Face * maxFaceCount1)()
+    faceNum1 = processImage(image_np1, image_np1.shape[1], image_np1.shape[0], faces1, maxFaceCount1)
+
+    faces1_result = []
+    for i in range(faceNum1):
+        face = {"x": faces1[i].x, "y": faces1[i].y, "width": faces1[i].width, "height": faces1[i].height}
+        faces1_result.append(face)
+
+    image_np2 = np.asarray(image2)
+    faces2 = (Face * maxFaceCount1)()
+    faceNum2 = processImage(image_np2, image_np2.shape[1], image_np2.shape[0], faces2, maxFaceCount1)
+
+    faces2_result = []
+    for i in range(faceNum2):
+        face = {"x": faces2[i].x, "y": faces2[i].y, "width": faces2[i].width, "height": faces2[i].height}
+        faces2_result.append(face)
+
+    if faceNum1 > 0 and faceNum2 > 0:
+        results = []
+        for i in range(faceNum1):
+            for j in range(faceNum2):                
+                score = verifyFeat(faces1[i].featSize, faces1[i].featData, faces2[j].featSize, faces2[j].featData)
+                match_result = {"face1": i, "face2": j, "score": score}
+                results.append(match_result)
+
+        response = jsonify({"resultCode": "Ok", "faces1": faces1_result, "faces2": faces2_result, "results": results})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+    elif faceNum1 == 0:
+        response = jsonify({"resultCode": "No face1", "faces1": faces1, "faces2": faces2})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+    elif faceNum2 == 0:
+        response = jsonify({"resultCode": "No face2", "faces1": faces1, "faces2": faces2})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+@app.route('/detect_face', methods=['POST'])
+def detect_face():
+    file = request.files['image']
+
+    try:
+        image = apply_exif_rotation(Image.open(file)).convert('RGB')
+    except:
+        result = "Failed to open file"
+        response = jsonify({"resultCode": result})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+    image_np = np.asarray(image)
+    faces = (Face * maxFaceCount2)()
+    faceNum = processImage(image_np, image_np.shape[1], image_np.shape[0], faces, maxFaceCount2)
+
+    if faceNum > 0:
+        faces_result = []
+        for i in range(faceNum):
+            face = {"rect": {"x": faces[i].x, "y": faces[i].y, "width": faces[i].width, "height": faces[i].height},
+            "angles": {"yaw": faces[i].yaw, "roll": faces[i].roll, "pitch": faces[i].pitch},
+            "age_gender": {"age": faces[i].age, "gender": faces[i].gender},
+            "emotion": {"neutral": faces[i].neutral, "happy": faces[i].happy, "angry": faces[i].angry,
+            "surprised": faces[i].surprised, "disgusted": faces[i].disgusted, "sad": faces[i].sad, "scared": faces[i].scared},
+            "attribute": {"masked": faces[i].masked, "left_eye_opened": faces[i].left_eye_opened, "right_eye_opened": faces[i].right_eye_opened}}
+            faces_result.append(face)
+
+        response = jsonify({"resultCode": "Ok", "result": faces_result})
+    else:
+        response = jsonify({"resultCode": "No face"})
+
+    response.status_code = 200
+    response.headers["Content-Type"] = "application/json; charset=utf-8"
+    return response
+
+if __name__ == '__main__':
+    port = int(os.environ.get("PORT", 8000))
+    app.run(host='0.0.0.0', port=port)

demo.py

@@ -0,0 +1,264 @@
+import os
+import gradio as gr
+import requests
+import json
+import io
+from gradio.components import Image
+from PIL import Image as PILImage, ImageDraw, ImageFont  # This import may be needed if you're processing images
+
+from PIL import Image
+
+from PIL import Image
+import io
+import base64
+
+def face_crop(image, face_rect):
+    x = face_rect.get('x')
+    y = face_rect.get('y')
+    width = face_rect.get('width')
+    height = face_rect.get('height')
+
+
+    if x < 0:
+        x = 0
+    if y < 0:
+        y = 0
+    if x + width >= image.width:
+        width = image.width - x
+    if y + height >= image.height:
+        height = image.height - y
+
+    face_image = image.crop((x, y, x + width - 1, y + height - 1))
+    face_image_ratio = face_image.width / float(face_image.height)
+    resized_w = int(face_image_ratio * 150)
+    resized_h = 150
+
+    face_image = face_image.resize((int(resized_w), int(resized_h)))
+    return face_image
+
+def pil_image_to_base64(image, format="PNG"):
+    """
+    Converts a PIL.Image object to a Base64-encoded string.
+
+    :param image: PIL.Image object
+    :param format: Format to save the image, e.g., "PNG", "JPEG"
+    :return: Base64-encoded string
+    """
+    # Save the image to a BytesIO buffer
+    buffer = io.BytesIO()
+    image.save(buffer, format=format)
+    buffer.seek(0)  # Rewind the buffer
+
+    # Convert the buffer's contents to a Base64 string
+    base64_string = base64.b64encode(buffer.getvalue()).decode('utf-8')
+    return base64_string
+
+def compare_face(image1, image2, verifyThreshold):
+    try:
+        img_bytes1 = io.BytesIO()
+        image1.save(img_bytes1, format="JPEG")
+        img_bytes1.seek(0)
+    except:
+        return ["Failed to open image1", {"resultCode": "Failed to open image1"}]
+
+    try:
+        img_bytes2 = io.BytesIO()
+        image2.save(img_bytes2, format="JPEG")
+        img_bytes2.seek(0)
+    except:
+        return ["Failed to open image2", {"resultCode": "Failed to open image2"}]
+    
+    url = "http://127.0.0.1:8000/compare_face"
+    files = {'image1': img_bytes1, 'image2': img_bytes2}
+    result = requests.post(url=url, files=files)
+    if result.ok:
+        json_result = result.json()
+        if json_result.get("resultCode") != "Ok":
+            return [json_result.get("resultCode"), json_result]
+
+        html = ""
+        faces1 = json_result.get("faces1", {})
+        faces2 = json_result.get("faces2", {})
+        results = json_result.get("results", {})
+
+        for result in results:
+            score = result.get('score')
+            face1_idx = result.get('face1')
+            face2_idx = result.get('face2')
+
+            face_image1 = face_crop(image1, faces1[face1_idx])
+            face_value1 = ('<img src="data:image/png;base64,{base64_image}" style="width: 100px; height: auto; object-fit: contain;"/>').format(base64_image=pil_image_to_base64(face_image1, format="PNG"))
+
+            face_image2 = face_crop(image2, faces2[face2_idx])
+            face_value2 = ('<img src="data:image/png;base64,{base64_image}" style="width: 100px; height: auto; object-fit: contain;"/>').format(base64_image=pil_image_to_base64(face_image2, format="PNG"))
+
+            match_icon = '<svg fill="red" width="19" height="32" viewBox="0 0 19 32"><path d="M0 13.92V10.2H19V13.92H0ZM0 21.64V17.92H19V21.64H0Z"></path><path d="M14.08 0H18.08L5.08 32H1.08L14.08 0Z"></path></svg>'
+            if score > verifyThreshold:
+                match_icon = '<svg fill="green" width="19" height="32" viewBox="0 0 19 32"><path d="M0 13.9202V10.2002H19V13.9202H0ZM0 21.6402V17.9202H19V21.6402H0Z"></path></svg>'
+
+            item_value = ('<div style="align-items: center; gap: 10px; display: flex; flex-direction: column;">'
+                            '<div style="display: flex; align-items: center; gap: 20px;">'
+                            '{face_value1}'
+                            '{match_icon}'
+                            '{face_value2}'
+                            '</div>'
+                            '<div style="text-align: center; margin-top: 10px;">'
+                            'Score: {score}'
+                            '</div>'
+                            '</div>'
+            ).format(face_value1=face_value1, face_value2=face_value2, match_icon=match_icon, score=f"{score:.2f}")
+            html += item_value
+            html += '<hr style="border: 1px solid #C0C0C0; margin: 10px 0;"/>'
+
+        return [html, json_result]
+    else:
+        return [result.text, {"resultCode": result.text}]
+
+
+def detect_face(image):
+    try:
+        img_bytes = io.BytesIO()
+        image.save(img_bytes, format="JPEG")
+        img_bytes.seek(0)
+    except:
+        return ["Failed to open image", {"resultCode": "Failed to open image"}]
+    
+    url = "http://127.0.0.1:8000/detect_face"
+    files = {'image': img_bytes}
+    result = requests.post(url=url, files=files)
+    if result.ok:
+        json_result = result.json()
+
+        html = ""
+        resultCode = json_result.get("resultCode")
+        if resultCode == "Ok":
+            faces = json_result.get("result", {})
+
+            for face in faces:
+                face_rect = face.get("rect", {})
+                angles = face.get("angles", {})
+                age_gender = face.get("age_gender", {})
+                emotion = face.get("emotion", {})
+                attribute = face.get("attribute", {})
+
+                face_image = face_crop(image, face_rect)
+                face_value = ('<img src="data:image/png;base64,{base64_image}" style="width: 100px; height: auto; object-fit: contain;"/>').format(base64_image=pil_image_to_base64(face_image, format="PNG"))
+
+                item_value = ('<div style="display: flex; justify-content: center; align-items: flex-start; margin: 10px;">'
+                                '<div style="display: flex; align-items: flex-start; gap: 40px; ">'
+                                '{face_value}'
+                                    '<div style="display: flex; gap: 20px; border-left: 1px solid #C0C0C0; padding-left: 20px;">'
+                                        '<div>'
+                                            '<p><b>Age</b></p>'
+                                            '<p><b>Gender</b></p>'
+                                            '<p><b>Mask</b></p>'
+                                            '<p><b>Left Eye</b></p>'
+                                            '<p><b>Right Eye</b></p>'
+                                            '<p><b>Yaw</b></p>'
+                                            '<p><b>Roll</b></p>'
+                                            '<p><b>Pitch</b></p>'
+                                        '</div>'
+                                        '<div>'
+                                            '<p>{age}</p>'
+                                            '<p>{gender}</p>'
+                                            '<p>{masked}</p>'
+                                            '<p>{left_eye}</p>'
+                                            '<p>{right_eye}</p>'
+                                            '<p>{yaw}</p>'
+                                            '<p>{roll}</p>'
+                                            '<p>{pitch}</p>'
+                                        '</div>'
+                                    '</div>'
+                                    '<div style="display: flex; gap: 20px; border-left: 1px solid #C0C0C0; padding-left: 20px;">'
+                                        '<div>'
+                                            '<p><b>Neutral</b></p>'
+                                            '<p><b>Happy</b></p>'
+                                            '<p><b>Angry</b></p>'
+                                            '<p><b>Surprised</b></p>'
+                                            '<p><b>Disgusted</b></p>'
+                                            '<p><b>Sad</b></p>'
+                                            '<p><b>Scared</b></p>'
+                                        '</div>'
+                                        '<div>'
+                                            '<p>{neutral}</p>'
+                                            '<p>{happy}</p>'
+                                            '<p>{angry}</p>'
+                                            '<p>{surprised}</p>'
+                                            '<p>{disgusted}</p>'
+                                            '<p>{sad}</p>'
+                                            '<p>{scared}</p>'
+                                        '</div>'
+                                    '</div>'
+                                '</div></div>').format(face_value=face_value, 
+                                    age=age_gender.get('age'), 
+                                    gender="Female" if age_gender.get('gender') == 0 else "Male", 
+                                    neutral=f"{emotion.get('neutral'):.2f}", 
+                                    happy=f"{emotion.get('happy'):.2f}", 
+                                    angry=f"{emotion.get('angry'):.2f}", 
+                                    surprised=f"{emotion.get('surprised'):.2f}", 
+                                    disgusted=f"{emotion.get('disgusted'):.2f}", 
+                                    sad=f"{emotion.get('sad'):.2f}", 
+                                    scared=f"{emotion.get('scared'):.2f}", 
+                                    masked="Yes" if attribute.get('masked') == 1 else "No", 
+                                    left_eye="Open" if attribute.get('left_eye_opened') == 1 else "Close", 
+                                    right_eye="Open" if attribute.get('right_eye_opened') == 1 else "Close", 
+                                    yaw=f"{angles.get('yaw'):.2f}", 
+                                    roll=f"{angles.get('roll'):.2f}", 
+                                    pitch=f"{angles.get('pitch'):.2f}", 
+                                    )
+
+                html += item_value
+                html += '<hr style="border: 1px solid #C0C0C0; margin: 10px 0;"/>'
+        else:
+            html = "No face!"
+
+        return [html, json_result]
+    else:
+        return [result.text, {"resultCode": result.text}]
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+        <div style="display: flex; align-items: center;justify-content: center;">
+            <p style="font-size: 36px; font-weight: bold;">Face Recognition, Face Attribute</p>
+        </div>
+        """
+    )
+
+    with gr.TabItem("Face Recognition"):
+        with gr.Row():
+            with gr.Column(scale=7):
+                with gr.Row():
+                    with gr.Column():
+                        image_input1 = gr.Image(type='pil')
+                        gr.Examples(['examples/1.webp', 'examples/2.webp', 'examples/3.webp', 'examples/4.webp'], 
+                                    inputs=image_input1)
+                    with gr.Column():
+                        image_input2 = gr.Image(type='pil')
+                        gr.Examples(['examples/5.webp', 'examples/6.webp', 'examples/7.webp', 'examples/8.webp'], 
+                                    inputs=image_input2)
+                verifyThreshold = gr.Slider(minimum=0, maximum=1, value=0.67, label="Verify Threshold")    
+                face_recog_button = gr.Button("Face Recognition")
+            with gr.Column(scale=3):
+                with gr.TabItem("Output"):
+                    recog_html_output = gr.HTML()
+                with gr.TabItem("JSON"):
+                    recog_json_output = gr.JSON()
+    with gr.TabItem("Face Attribute"):
+        with gr.Row():
+            with gr.Column():
+                image_input = gr.Image(type='pil')
+                gr.Examples(['examples/11.webp', 'examples/12.webp', 'examples/13.webp', 'examples/14.webp'], 
+                            inputs=image_input)
+                face_attr_button = gr.Button("Face Attribute")
+            with gr.Column():
+                with gr.TabItem("Output"):
+                    detect_html_output = gr.HTML()
+                with gr.TabItem("JSON"):
+                    detect_json_output = gr.JSON()
+
+
+    face_recog_button.click(compare_face, inputs=[image_input1, image_input2, verifyThreshold], outputs=[recog_html_output, recog_json_output])
+    face_attr_button.click(detect_face, inputs=[image_input], outputs=[detect_html_output, detect_json_output])
+
+demo.launch(server_name="0.0.0.0", server_port=7860)

dependency/lib/libonnxruntime.so

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

dependency/lib/libopyfaceenv.so

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

engine/bin/age.bin

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

engine/bin/detect1.bin

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

engine/bin/detect2.bin

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

engine/bin/em.bin

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

engine/bin/eyes.bin

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

engine/bin/gender.bin

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

engine/bin/mask.bin

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

engine/bin/recog1.bin

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

engine/bin/recog2.bin

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

engine/bin/recog3.bin

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

engine/conf/facerec/ag.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0"?>
+<opencv_storage>
+
+<age_gender_impl_name>version_3.0</age_gender_impl_name>
+
+<analysisa>bin/age.bin</analysisa>
+<age_use_cuda>false</age_use_cuda>
+<age_use_legacy>false</age_use_legacy>
+<analysisg>bin/gender.bin</analysisg>
+<gender_use_cuda>false</gender_use_cuda>
+<gender_use_legacy>false</gender_use_legacy>
+
+</opencv_storage>

engine/conf/facerec/config.xml

@@ -0,0 +1,2 @@
+<conf>
+</conf>

engine/conf/facerec/detect.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0"?>
+<opencv_storage>
+
+<capturer_impl_name>fld_capturer</capturer_impl_name>
+
+<capturer_type>frontal</capturer_type>
+
+
+<detector_type>refa</detector_type>
+<min_size>0.045</min_size>
+<max_size>3</max_size>
+<num_threads>1</num_threads>
+<score_threshold>0.89</score_threshold>
+<nms_iou_threshold>0.4</nms_iou_threshold>
+<coarse_score_threshold>0.5</coarse_score_threshold>
+
+<refa_id>refa-a</refa_id>
+<refa_filepath>bin/detect1.bin</refa_filepath>
+
+<use_cuda>0</use_cuda>
+<gpu_index>0</gpu_index>
+<use_advanced_multithreading>0</use_advanced_multithreading>
+
+<fitter_type>fda</fitter_type>
+<fda_file>bin/detect2.bin</fda_file>
+
+<iris_enabled>0</iris_enabled>
+<iris_config_filepath>iris_fitter.xml</iris_config_filepath>
+
+
+<downscale_rawsamples_to_preferred_size>1</downscale_rawsamples_to_preferred_size>
+
+</opencv_storage>

engine/conf/facerec/em.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<opencv_storage>
+
+<emotion_impl_name>version_2.0</emotion_impl_name>
+
+<analysis>bin/em.bin</analysis>
+<use_cuda>false</use_cuda>
+<use_legacy>false</use_legacy>
+
+</opencv_storage>

engine/conf/facerec/eyes.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<opencv_storage>
+
+<face_attribute_impl>the_one</face_attribute_impl>
+
+<face_attribute_name>eyes_openness_v2</face_attribute_name>
+<face_attribute_data>bin/eyes.bin</face_attribute_data>
+<score_threshold>0.5</score_threshold>
+
+</opencv_storage>

engine/conf/facerec/mask.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0"?>
+<opencv_storage>
+
+<face_attribute_impl>version_2.0</face_attribute_impl>
+
+<face_attribute_name>masked_face</face_attribute_name>
+<face_attribute_data>bin/mask.bin</face_attribute_data>
+<score_threshold>0.5</score_threshold>
+
+<use_mobile_gpu>0</use_mobile_gpu>
+
+</opencv_storage>

engine/conf/facerec/recog.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0"?>
+<opencv_storage>
+
+<recognizer_impl_name>method_link</recognizer_impl_name>
+<recognizer_config>conf/facerec/recog_param.xml</recognizer_config>
+
+</opencv_storage>

engine/conf/facerec/recog_param.xml

@@ -0,0 +1,341 @@
+<?xml version="1.0"?>
+<opencv_storage>
+
+<recognizer_impl_name>method12v1000</recognizer_impl_name>
+
+
+
+<part0>bin/detect2.bin</part0>
+<part1>bin/recog1.bin</part1>
+<part2>bin/recog2.bin</part2>
+<part3>bin/recog3.bin</part3>
+
+<use_mobile_gpu>0</use_mobile_gpu>
+<use_cuda>0</use_cuda>
+<gpu_index>0</gpu_index>
+
+
+<roc>
+1.512680053711
+0.000000000000
+0.017418799922
+0.000000000000
+
+244.525177001953
+0.000000000000
+0.036921270192
+0.000145137310
+
+487.537658691406
+0.000000000000
+0.070433743298
+0.000585138798
+
+730.550170898438
+0.000000000000
+0.091564692557
+0.001321136951
+
+973.562683105469
+0.000000000000
+0.102614454925
+0.002369165421
+
+1216.575195312500
+0.000000000000
+0.112338289618
+0.003732264042
+
+1459.587646484375
+0.000000000000
+0.131876721978
+0.005405783653
+
+1702.600219726562
+0.000000000000
+0.163213133812
+0.007417380810
+
+1945.612670898438
+0.000000000000
+0.215010792017
+0.009764373302
+
+2188.625244140625
+0.000000000000
+0.278898477554
+0.012435853481
+
+2431.637695312500
+0.000000000000
+0.353262901306
+0.015471816063
+
+2674.650146484375
+0.000000000000
+0.435616225004
+0.018863618374
+
+2917.662597656250
+0.000000000000
+0.517174601555
+0.022593140602
+
+3160.675048828125
+0.000000000000
+0.594927132130
+0.026714444160
+
+3403.687744140625
+0.000000000000
+0.665740191936
+0.031211495399
+
+3646.700195312500
+0.000000000000
+0.728241384029
+0.036059856415
+
+3889.712646484375
+0.000000000000
+0.782364964485
+0.041326820850
+
+4132.725097656250
+0.000000000000
+0.828701794147
+0.046990036964
+
+4375.737792968750
+0.000000000000
+0.869253814220
+0.053017497063
+
+4618.750000000000
+0.000000000000
+0.900053620338
+0.059491038322
+
+4861.762695312500
+0.000000000000
+0.925056338310
+0.066381156445
+
+5104.774902343750
+0.000000005995
+0.944028019905
+0.073648035526
+
+5347.787597656250
+0.000000007104
+0.958393573761
+0.081388950348
+
+5590.800292968750
+0.000000008051
+0.968550026417
+0.089514672756
+
+5833.812500000000
+0.000000009453
+0.976274311543
+0.098133325577
+
+6076.825195312500
+0.000000016849
+0.982362270355
+0.107202410698
+
+6319.837402343750
+0.000000037714
+0.986156880856
+0.116668164730
+
+6562.850097656250
+0.000000125729
+0.989229261875
+0.126655399799
+
+6805.862792968750
+0.000000322775
+0.990983843803
+0.137113332748
+
+7048.875000000000
+0.000000844537
+0.992396354675
+0.147979438305
+
+7291.887695312500
+0.000002360034
+0.993351519108
+0.168762803078
+
+7534.899902343750
+0.000006154218
+0.994017183781
+0.214203178883
+
+7777.912597656250
+0.000016113172
+0.994441568851
+0.278451800346
+
+8020.925292968750
+0.000040494200
+0.994999945164
+0.356456458569
+
+8263.937500000000
+0.000099464734
+0.995369017124
+0.441985607147
+
+8506.950195312500
+0.000238555382
+0.995669007301
+0.528621554375
+
+8749.962890625000
+0.000559987093
+0.995895981789
+0.611591219902
+
+8992.974609375000
+0.001302033430
+0.996132075787
+0.684468984604
+
+9235.987304687500
+0.003006055485
+0.996436715126
+0.741078972816
+
+9479.000000000000
+0.006861325353
+0.996610999107
+0.782298445702
+
+9722.012695312500
+0.015361220576
+0.996944129467
+0.817885696888
+
+9965.025390625000
+0.033221695572
+0.997113645077
+0.848900675774
+
+10208.037109375000
+0.067775554955
+0.997449994087
+0.876659750938
+
+10451.049804687500
+0.128415152431
+0.997725605965
+0.904105246067
+
+10694.062500000000
+0.222135275602
+0.998053014278
+0.929574251175
+
+10937.075195312500
+0.349268019199
+0.998477220535
+0.946929633617
+
+11180.087890625000
+0.499025940895
+0.998991847038
+0.953711867332
+
+11423.099609375000
+0.650276362896
+0.999405980110
+0.959191501141
+
+11666.112304687500
+0.781673550606
+0.999659240246
+0.964288055897
+
+11909.125000000000
+0.879517912865
+0.999745011330
+0.968977451324
+
+12152.137695312500
+0.941511988640
+0.999958992004
+0.973327934742
+
+12395.150390625000
+0.975172519684
+0.999983191490
+0.977318882942
+
+12638.162109375000
+0.990831315517
+0.999997973442
+0.980933845043
+
+12881.174804687500
+0.997046291828
+1.000000000000
+0.984228491783
+
+13124.187500000000
+0.999171257019
+1.000000000000
+0.987184703350
+
+13367.200195312500
+0.999799430370
+1.000000000000
+0.989796817303
+
+13610.212890625000
+0.999957025051
+1.000000000000
+0.992106020451
+
+13853.224609375000
+0.999992012978
+1.000000000000
+0.994101285934
+
+14096.237304687500
+0.999998986721
+1.000000000000
+0.995782136917
+
+14339.250000000000
+1.000000000000
+1.000000000000
+0.997178018093
+
+14582.262695312500
+1.000000000000
+1.000000000000
+0.998284399509
+
+14825.275390625000
+1.000000000000
+1.000000000000
+0.999105751514
+
+15068.287109375000
+1.000000000000
+1.000000000000
+0.999660372734
+
+15311.299804687500
+1.000000000000
+1.000000000000
+0.999948918819
+
+</roc>
+
+</opencv_storage>

engine/header.py

@@ -0,0 +1,51 @@
+import os
+import sys
+import numpy as np
+import ctypes, ctypes.util
+from enum import Enum
+from ctypes import *
+from numpy.ctypeslib import ndpointer
+
+def print_log(fmt): print("[LOG] \033[98m{}\033[00m" .format(fmt))
+def print_info(fmt): print("[INFO] \033[92m{}\033[00m" .format(fmt))
+def print_error(fmt): print("[ERR] \033[91m{}\033[00m" .format(fmt)) 
+def print_warning(fmt): print("[WARNING] \033[93m{}\033[00m" .format(fmt))
+
+class ENGINE_CODE(Enum):
+    E_NO_FACE = 0
+    E_ACTIVATION_ERROR = -1
+    E_ENGINE_INIT_ERROR = -2    
+
+class Face(Structure):
+    _fields_ = [("x", c_int32), ("y", c_int32), ("width", c_int32), ("height", c_int32), 
+        ("yaw", c_float), ("roll", c_float), ("pitch", c_float), 
+        ("age", c_int32), ("gender", c_int32),
+        ("neutral", c_float), ("happy", c_float), ("angry", c_float), 
+        ("surprised", c_float), ("disgusted", c_float), ("sad", c_float), ("scared", c_float), 
+        ("masked", c_int32), ("left_eye_opened", c_int32), ("right_eye_opened", c_int32),
+        ("featSize", c_int32),
+        ("featData", c_ubyte * 512)
+        ]
+    
+libPath = os.path.abspath(os.path.dirname(__file__)) + '/libopyfacerecog.so'
+lib = cdll.LoadLibrary(libPath)
+
+getHWID = lib.getHWID
+getHWID.argtypes = []
+getHWID.restype = c_char_p
+
+setLicenseKey = lib.setLicenseKey
+setLicenseKey.argtypes = [c_char_p]
+setLicenseKey.restype = c_int32
+
+initSDK = lib.initSDK
+initSDK.argtypes = [c_char_p]
+initSDK.restype = c_int32
+
+processImage = lib.processImage
+processImage.argtypes = [ndpointer(c_ubyte, flags='C_CONTIGUOUS'), c_int32, c_int32, POINTER(Face), c_int32]
+processImage.restype = c_int32
+
+verifyFeat = lib.verifyFeat
+verifyFeat.argtypes = [c_int32, c_ubyte * 512, c_int32, c_ubyte * 512]
+verifyFeat.restype = c_float

engine/libopyfacerecog.so

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

install.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+echo "Install environment..."
+
+# Install packages:
+sudo apt-get update -y && sudo apt-get install -y python3 python3-pip python3-opencv libusb-0.1-4
+
+# Install requirements:
+python3 -m pip install --upgrade pip && python3 -m pip install opencv-python flask flask-cors gradio datadog_api_client
+
+# Copy OpenVino library  
+sudo cp -rf dependency/lib/* /usr/lib
+
+echo "Installed successfully!"

license.txt

@@ -0,0 +1,2 @@
+f8I6pxZJPlJVJCz+AaEZdm5pva6Fu3hTADFzPLLHEP1SHkzolYyErq/nGREb3hB9aSP1WiqySDbv
+OWKJCJ5OhYI+r5POImX4ZzmQTBnU431MBLHZ5eH3lcgOdy1HNF1rIyF+rrU5Ncp/kHeRKTkg0D3y

run_demo.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+exec python3 demo.py &
+exec python3 app.py