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

Dockerfile

@@ -1,8 +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-live
-WORKDIR /root/kby-ai-live
+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-live
+WORKDIR /root/kby-ai-live
+COPY ./libfacesdk1.so .
+COPY ./libimutils.so /usr/lib/libimutils.so
+COPY ./facesdk.py .
+COPY ./facebox.py .
+COPY ./app.py .
+COPY ./demo.py .
+COPY ./run.sh .
+COPY ./live_examples ./live_examples
+COPY ./requirements.txt .
+COPY ./data ./data
+RUN pip3 install -r requirements.txt
+CMD ["./run.sh"]
+EXPOSE 8088 9000

app.py

@@ -0,0 +1,335 @@
+import sys
+sys.path.append('.')
+
+import os
+import numpy as np
+import base64
+import io
+
+from PIL import Image, ExifTags
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from facesdk import getMachineCode
+from facesdk import setActivation
+from facesdk import faceDetection
+from facesdk import initSDK
+from facebox import FaceBox
+
+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)
+
+livenessThreshold = 0.7
+yawThreshold = 10
+pitchThreshold = 10
+rollThreshold = 10
+occlusionThreshold = 0.9
+eyeClosureThreshold = 0.8
+mouthOpeningThreshold = 0.5
+borderRate = 0.05
+smallFaceThreshold = 100
+lowQualityThreshold = 0.3
+hightQualityThreshold = 0.7
+luminanceDarkThreshold = 50
+luminanceLightThreshold = 200
+
+maxFaceCount = 10
+
+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__) 
+CORS(app)
+
+def apply_exif_rotation(image):
+    # Get the EXIF data
+    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("No EXIF data found")
+
+    return image
+    
+@app.route('/check_liveness', methods=['POST'])
+def check_liveness():
+    faces = []
+    isNotFront = None
+    isOcclusion = None
+    isEyeClosure = None
+    isMouthOpening = None
+    isBoundary = None
+    isSmall = None
+    quality = None
+    luminance = None
+    livenessScore = None
+
+    file = request.files['file']
+
+    try:
+        #image = apply_exif_rotation(Image.open(file)).convert('RGB')
+        image = Image.open(file)).convert('RGB')
+    except:
+        result = "Failed to open file"
+        faceState = {"is_not_front": isNotFront, "is_occluded": isOcclusion, "eye_closed": isEyeClosure, "mouth_opened": isMouthOpening, 
+                        "is_boundary_face": isBoundary, "is_small": isSmall, "quality": quality, "luminance": luminance, "result": result, "liveness_score": livenessScore}
+        response = jsonify({"face_state": faceState, "faces": faces})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+
+    image_np = np.asarray(image)
+
+    faceBoxes = (FaceBox * maxFaceCount)()
+    faceCount = faceDetection(image_np, image_np.shape[1], image_np.shape[0], faceBoxes, maxFaceCount)
+    if faceCount == 0:
+        image = image.rotate(90, expand=True)
+        faceCount = faceDetection(image_np, image_np.shape[1], image_np.shape[0], faceBoxes, maxFaceCount)        
+            if faceCount == 0:
+                image = image.rotate(90, expand=True)
+                faceCount = faceDetection(image_np, image_np.shape[1], image_np.shape[0], faceBoxes, maxFaceCount)        
+                if faceCount == 0:
+                    image = image.rotate(90, expand=True)
+                    faceCount = faceDetection(image_np, image_np.shape[1], image_np.shape[0], faceBoxes, maxFaceCount)        
+        
+
+    for i in range(faceCount):
+        landmark_68 = []
+        for j in range(68):
+            landmark_68.append({"x": faceBoxes[i].landmark_68[j * 2], "y": faceBoxes[i].landmark_68[j * 2 + 1]})
+        faces.append({"x1": faceBoxes[i].x1, "y1": faceBoxes[i].y1, "x2": faceBoxes[i].x2, "y2": faceBoxes[i].y2, 
+                      "liveness": faceBoxes[i].liveness, 
+                      "yaw": faceBoxes[i].yaw, "roll": faceBoxes[i].roll, "pitch": faceBoxes[i].pitch,
+                      "face_quality": faceBoxes[i].face_quality, "face_luminance": faceBoxes[i].face_luminance, "eye_dist": faceBoxes[i].eye_dist,
+                      "left_eye_closed": faceBoxes[i].left_eye_closed, "right_eye_closed": faceBoxes[i].right_eye_closed,
+                      "face_occlusion": faceBoxes[i].face_occlusion, "mouth_opened": faceBoxes[i].mouth_opened,
+                      "landmark_68": landmark_68})
+    
+    result = ""
+    if faceCount == 0:
+        result = "No face"
+#    elif faceCount > 1:
+#        result = "Multiple face"
+    elif faceCount < 0:
+        result = "License error!"
+    else:
+        livenessScore = faceBoxes[0].liveness
+        if livenessScore > livenessThreshold:
+            result = "Real"
+        else:
+            result = "Spoof"
+        
+        isNotFront = True
+        isOcclusion = False
+        isEyeClosure = False
+        isMouthOpening = False
+        isBoundary = False
+        isSmall = False
+        quality = "Low"
+        luminance = "Dark"
+        if abs(faceBoxes[0].yaw) < yawThreshold and abs(faceBoxes[0].roll) < rollThreshold and abs(faceBoxes[0].pitch) < pitchThreshold:
+            isNotFront = False
+        
+        if faceBoxes[0].face_occlusion > occlusionThreshold:
+            isOcclusion = True
+
+        if faceBoxes[0].left_eye_closed > eyeClosureThreshold or faceBoxes[0].right_eye_closed > eyeClosureThreshold:
+            isEyeClosure = True
+
+        if faceBoxes[0].mouth_opened > mouthOpeningThreshold:
+            isMouthOpening = True
+        
+        if (faceBoxes[0].x1 < image_np.shape[1] * borderRate or 
+            faceBoxes[0].y1 < image_np.shape[0] * borderRate or 
+                faceBoxes[0].x1 > image_np.shape[1] - image_np.shape[1] * borderRate or 
+                faceBoxes[0].x1 > image_np.shape[0] - image_np.shape[0] * borderRate):
+            isBoundary = True
+
+        if faceBoxes[0].eye_dist < smallFaceThreshold:
+            isSmall = True
+        
+        if faceBoxes[0].face_quality < lowQualityThreshold:
+            quality = "Low"
+        elif faceBoxes[0].face_quality < hightQualityThreshold:
+            quality = "Medium"
+        else:
+            quality = "High"
+        
+        if faceBoxes[0].face_luminance < luminanceDarkThreshold:
+            luminance = "Dark"
+        elif faceBoxes[0].face_luminance < luminanceLightThreshold:
+            luminance = "Normal"
+        else:
+            luminance = "Light"
+
+    faceState = {"is_not_front": isNotFront, "is_occluded": isOcclusion, "eye_closed": isEyeClosure, "mouth_opened": isMouthOpening, 
+                    "is_boundary_face": isBoundary, "is_small": isSmall, "quality": quality, "luminance": luminance, "result": result, "liveness_score": livenessScore}
+    response = jsonify({"face_state": faceState, "faces": faces})
+
+    response.status_code = 200
+    response.headers["Content-Type"] = "application/json; charset=utf-8"
+    return response
+
+@app.route('/check_liveness_base64', methods=['POST'])
+def check_liveness_base64():
+    faces = []
+    isNotFront = None
+    isOcclusion = None
+    isEyeClosure = None
+    isMouthOpening = None
+    isBoundary = None
+    isSmall = None
+    quality = None
+    luminance = None
+    livenessScore = None
+
+    content = request.get_json()
+
+    try:
+        imageBase64 = content['base64']
+        image_data = base64.b64decode(imageBase64)
+        #image = apply_exif_rotation(Image.open(io.BytesIO(image_data))).convert("RGB")
+        image = Image.open(io.BytesIO(image_data)).convert("RGB")
+    except:
+        result = "Failed to open file"
+        faceState = {"is_not_front": isNotFront, "is_occluded": isOcclusion, "eye_closed": isEyeClosure, "mouth_opened": isMouthOpening, 
+                        "is_boundary_face": isBoundary, "is_small": isSmall, "quality": quality, "luminance": luminance, "result": result, "liveness_score": livenessScore}
+        response = jsonify({"face_state": faceState, "faces": faces})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+
+    image_np = np.asarray(image)
+
+    faceBoxes = (FaceBox * maxFaceCount)()
+    faceCount = faceDetection(image_np, image_np.shape[1], image_np.shape[0], faceBoxes, maxFaceCount)
+    if faceCount == 0:
+        image = image.rotate(90, expand=True)
+        faceCount = faceDetection(image_np, image_np.shape[1], image_np.shape[0], faceBoxes, maxFaceCount)        
+            if faceCount == 0:
+                image = image.rotate(90, expand=True)
+                faceCount = faceDetection(image_np, image_np.shape[1], image_np.shape[0], faceBoxes, maxFaceCount)        
+                if faceCount == 0:
+                    image = image.rotate(90, expand=True)
+                    faceCount = faceDetection(image_np, image_np.shape[1], image_np.shape[0], faceBoxes, maxFaceCount)        
+
+    for i in range(faceCount):
+        landmark_68 = []
+        for j in range(68):
+            landmark_68.append({"x": faceBoxes[i].landmark_68[j * 2], "y": faceBoxes[i].landmark_68[j * 2 + 1]})
+        faces.append({"x1": faceBoxes[i].x1, "y1": faceBoxes[i].y1, "x2": faceBoxes[i].x2, "y2": faceBoxes[i].y2, 
+                      "liveness": faceBoxes[i].liveness, 
+                      "yaw": faceBoxes[i].yaw, "roll": faceBoxes[i].roll, "pitch": faceBoxes[i].pitch,
+                      "face_quality": faceBoxes[i].face_quality, "face_luminance": faceBoxes[i].face_luminance, "eye_dist": faceBoxes[i].eye_dist,
+                      "left_eye_closed": faceBoxes[i].left_eye_closed, "right_eye_closed": faceBoxes[i].right_eye_closed,
+                      "face_occlusion": faceBoxes[i].face_occlusion, "mouth_opened": faceBoxes[i].mouth_opened,
+                      "landmark_68": landmark_68})
+
+    result = ""
+    if faceCount == 0:
+        result = "No face"
+#    elif faceCount > 1:
+#        result = "Multiple face"
+    elif faceCount < 0:
+        result = "License error!"
+    else:
+        livenessScore = faceBoxes[0].liveness
+        if livenessScore > livenessThreshold:
+            result = "Real"
+        else:
+            result = "Spoof"
+        
+        isNotFront = True
+        isOcclusion = False
+        isEyeClosure = False
+        isMouthOpening = False
+        isBoundary = False
+        isSmall = False
+        quality = "Low"
+        luminance = "Dark"
+        if abs(faceBoxes[0].yaw) < yawThreshold and abs(faceBoxes[0].roll) < rollThreshold and abs(faceBoxes[0].pitch) < pitchThreshold:
+            isNotFront = False
+        
+        if faceBoxes[0].face_occlusion > occlusionThreshold:
+            isOcclusion = True
+
+        if faceBoxes[0].left_eye_closed > eyeClosureThreshold or faceBoxes[0].right_eye_closed > eyeClosureThreshold:
+            isEyeClosure = True
+
+        if faceBoxes[0].mouth_opened > mouthOpeningThreshold:
+            isMouthOpening = True
+        
+        if (faceBoxes[0].x1 < image_np.shape[1] * borderRate or 
+            faceBoxes[0].y1 < image_np.shape[0] * borderRate or 
+                faceBoxes[0].x1 > image_np.shape[1] - image_np.shape[1] * borderRate or 
+                faceBoxes[0].x1 > image_np.shape[0] - image_np.shape[0] * borderRate):
+            isBoundary = True
+
+        if faceBoxes[0].eye_dist < smallFaceThreshold:
+            isSmall = True
+        
+        if faceBoxes[0].face_quality < lowQualityThreshold:
+            quality = "Low"
+        elif faceBoxes[0].face_quality < hightQualityThreshold:
+            quality = "Medium"
+        else:
+            quality = "High"
+        
+        if faceBoxes[0].face_luminance < luminanceDarkThreshold:
+            luminance = "Dark"
+        elif faceBoxes[0].face_luminance < luminanceLightThreshold:
+            luminance = "Normal"
+        else:
+            luminance = "Light"
+
+    faceState = {"is_not_front": isNotFront, "is_occluded": isOcclusion, "eye_closed": isEyeClosure, "mouth_opened": isMouthOpening, 
+                    "is_boundary_face": isBoundary, "is_small": isSmall, "quality": quality, "luminance": luminance, "result": result, "liveness_score": livenessScore}
+    response = jsonify({"face_state": faceState, "faces": faces})
+
+    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)

demo.py

@@ -0,0 +1,153 @@
+import gradio as gr
+import requests
+import datadog_api_client
+from PIL import Image
+
+def check_liveness(frame):
+    url = "http://127.0.0.1:8080/check_liveness"
+    file = {'file': open(frame, 'rb')}
+
+    r = requests.post(url=url, files=file)
+    result = r.json().get('face_state').get('result')
+
+    html = None
+    faces = None
+    if r.json().get('face_state').get('is_not_front') is not None:
+        liveness_score = r.json().get('face_state').get('liveness_score')
+        eye_closed = r.json().get('face_state').get('eye_closed')
+        is_boundary_face = r.json().get('face_state').get('is_boundary_face')
+        is_not_front = r.json().get('face_state').get('is_not_front')
+        is_occluded = r.json().get('face_state').get('is_occluded')
+        is_small = r.json().get('face_state').get('is_small')
+        luminance = r.json().get('face_state').get('luminance')
+        mouth_opened = r.json().get('face_state').get('mouth_opened')
+        quality = r.json().get('face_state').get('quality')
+
+        html = ("<table>"
+                    "<tr>"
+                        "<th>Face State</th>"
+                        "<th>Value</th>"
+                    "</tr>"
+                    "<tr>"
+                        "<td>Result</td>"
+                        "<td>{result}</td>"
+                    "</tr>"
+                    "<tr>"
+                        "<td>Liveness Score</td>"
+                        "<td>{liveness_score}</td>"
+                    "</tr>"
+                    "<tr>"
+                        "<td>Quality</td>"
+                        "<td>{quality}</td>"
+                    "</tr>"
+                    "<tr>"
+                        "<td>Luminance</td>"
+                        "<td>{luminance}</td>"
+                    "</tr>"
+                    "<tr>"
+                        "<td>Is Small</td>"
+                        "<td>{is_small}</td>"
+                    "</tr>"
+                    "<tr>"
+                        "<td>Is Boundary</td>"
+                        "<td>{is_boundary_face}</td>"
+                    "</tr>"
+                    "<tr>"
+                        "<td>Is Not Front</td>"
+                        "<td>{is_not_front}</td>"
+                    "</tr>"
+                    "<tr>"
+                        "<td>Face Occluded</td>"
+                        "<td>{is_occluded}</td>"
+                    "</tr>"
+                    "<tr>"
+                        "<td>Eye Closed</td>"
+                        "<td>{eye_closed}</td>"
+                    "</tr>"
+                    "<tr>"
+                        "<td>Mouth Opened</td>"
+                        "<td>{mouth_opened}</td>"
+                    "</tr>"
+                    "</table>".format(liveness_score=liveness_score, quality=quality, luminance=luminance, is_small=is_small, is_boundary_face=is_boundary_face,
+                                      is_not_front=is_not_front, is_occluded=is_occluded, eye_closed=eye_closed, mouth_opened=mouth_opened, result=result))
+
+    else:
+        html = ("<table>"
+            "<tr>"
+                "<th>Face State</th>"
+                "<th>Value</th>"
+            "</tr>"
+            "<tr>"
+                "<td>Result</td>"
+                "<td>{result}</td>"
+            "</tr>"
+            "</table>".format(result=result))
+
+    try:
+        image = Image.open(frame)        
+
+        for face in r.json().get('faces'):
+            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 >= image.width:
+                x2 = image.width - 1
+            if y2 >= image.height:
+                y2 = image.height - 1
+
+            face_image = image.crop((x1, y1, x2, y2))
+            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)))
+
+            if faces is None:
+                faces = face_image
+            else:
+                new_image = Image.new('RGB',(faces.width + face_image.width + 10, 150), (80,80,80))
+
+                new_image.paste(faces,(0,0))
+                new_image.paste(face_image,(faces.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-liveness-detection:latest
+    sudo docker run -e LICENSE="xxxxx" -p 8080:8080 -p 9000:9000 kbyai/face-liveness-detection:latest
+    ```      
+    ## KYC Verification Demo
+    https://github.com/kby-ai/KYC-Verification    
+    """
+    )
+    with gr.TabItem("Face Liveness Detection"):
+        with gr.Row():
+            with gr.Column():
+                live_image_input = gr.Image(type='filepath')
+                gr.Examples(['live_examples/1.jpg', 'live_examples/2.jpg', 'live_examples/3.jpg', 'live_examples/4.jpg'], 
+                            inputs=live_image_input)
+                check_liveness_button = gr.Button("Check Liveness")
+            with gr.Column():
+                liveness_face_output = gr.Image(type="pil").style(height=150)
+                livness_result_output = gr.HTML()
+        
+        check_liveness_button.click(check_liveness, inputs=live_image_input, outputs=[liveness_face_output, livness_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), 
+        ("liveness", c_float), 
+        ("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)
+        ]

facesdk.py

@@ -0,0 +1,25 @@
+import os
+
+from ctypes import *
+from numpy.ctypeslib import ndpointer
+from facebox import FaceBox
+
+libPath = os.path.abspath(os.path.dirname(__file__)) + '/libfacesdk1.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
+

libfacesdk1.so

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

license.txt

@@ -0,0 +1,5 @@
+DFS2z+xIsvbAV0ZdS37aH68Sba8sPqW1QJc4RdxYg7aTrFgxZBGSMnwD0Hr6KC01EAhV0yM14UxQ
+NJT4a2ygemfrLW9zp1jOqjD+eWJNVZvUQHffnsCVJSKzvoo/Qu3BkYh2I8yJyAbW/QhdhN4Bt9yy
+EYzNRNW3iY/FM5CDLDeblSTx+iX5egoYLn1icsMyp6gbanY5kO5G7rclgGUaK5f0Pzjukwm1eGpe
+q9EkVd0iZkQaXAwEc+HCYRthS6GlTOl2qJIYyTPSEAX0QGF9ajVgWi4CUw6cdMfeFsGJbh3QFA0w
+gyO9k0z/MGsLrEmwSg4TkZl4UP9HCSxswok4AQ==

readme.txt

@@ -0,0 +1,9 @@
+####docker build
+sudo docker build --pull --rm -f Dockerfile -t kby-ai-live:latest .
+
+
+#### docker run with online license
+sudo docker run -e LICENSE="xxxxx" -p 8080:8080 -p 9000:9000 kby-ai-live
+
+#### docker run with offline license
+sudo docker run -v ./license.txt:/root/kby-ai-live/license.txt -p 8080:8080 -p 9000:9000 kby-ai-live

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-live
+exec python3 demo.py &
+exec python3 app.py