Upload 33 files

.gitignore

@@ -0,0 +1 @@
+/data

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.8-slim
+RUN apt-get update -y
+RUN apt-get install -y libpcsclite-dev psmisc    
+RUN mkdir -p /root/kby-ai-idcard
+WORKDIR /root/kby-ai-idcard
+COPY ./libidsdk.so .
+COPY ./idsdk.py .
+COPY ./app.py .
+COPY ./requirements.txt .
+COPY ./data ./data
+RUN pip3 install -r requirements.txt
+CMD [ "python3", "app.py"]
+EXPOSE 8080

README.md

@@ -1,11 +1,187 @@
----
-title: Test1
-emoji: 🏆
-colorFrom: green
-colorTo: blue
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<p align="center">
+  <a href="https://play.google.com/store/apps/dev?id=7086930298279250852" target="_blank">
+    <img alt="" src="https://github-production-user-asset-6210df.s3.amazonaws.com/125717930/246971879-8ce757c3-90dc-438d-807f-3f3d29ddc064.png" width=500/>
+  </a>  
+</p>
+
+👏 Product List
+
+https://github.com/kby-ai/Product
+
+👏  We have published the Face Liveness Detection, Face Recognition SDK and ID Card Recognition SDK for the server.
+
+  - [FaceLivenessDetection-Docker](https://github.com/kby-ai/FaceLivenessDetection-Docker)
+
+  - [FaceRecognition-Docker](https://github.com/kby-ai/FaceRecognition-Docker)
+
+  - [IDCardRecognition-Docker](https://github.com/kby-ai/IDCardRecognition-Docker)
+
+# IDCardRecognition-Docker
+
+## Introduction
+
+The demo project demonstrates the server-based recognition capabilities for ID cards, passports, and driver's licenses.
+
+At the core of this project lies the ID Card Recognition SDK, which has been developed to provide comprehensive support for recognizing ID cards, passports, and driver's licenses from over 180 countries.
+
+> The demo is integrated with KBY-AI's ID Card Recognition Server SDK.
+
+> For other solutions, please explore the following:
+>
+> [Face Liveness Detection - Android(Basic SDK)](https://github.com/kby-ai/FaceLivenessDetection-Android)
+>
+> [Face Liveness Detection - iOS(Basic SDK)](https://github.com/kby-ai/FaceLivenessDetection-iOS)
+>
+> [Face Recognition - Android(Stdndard SDK)](https://github.com/kby-ai/FaceRecognition-Android)
+>
+> [Face Recognition - iOS(Standard SDK)](https://github.com/kby-ai/FaceRecognition-iOS)
+>
+> [Face Recognition - Flutter(Standard SDK)](https://github.com/kby-ai/FaceRecognition-Flutter)
+>
+> [Face Recognition - React-Native(Standard SDK)](https://github.com/kby-ai/FaceRecognition-React-Native)
+>
+> [Face Attribute - Android(Premium SDK)](https://github.com/kby-ai/FaceAttribute-Android)
+>
+> [Face Attribute - iOS(Premium SDK)](https://github.com/kby-ai/FaceAttribute-iOS)
+
+## Try the API
+### Online Demo
+  You can test the SDK using images from the following URL:
+  https://web.kby-ai.com
+  
+  ![image](https://github.com/kby-ai/IDCardRecognition-Docker/assets/125717930/ff395174-d3e9-4198-bfc8-6024a8c31734)
+  
+### Postman
+  To test the API, you can use Postman. Here are the endpoints for testing:
+  - Test with an image file: Send a POST request to http://18.221.33.238:8082/idcard_recognition
+  - Test with a base64-encoded image: Send a POST request to http://18.221.33.238:8082/idcard_recognition_base64
+
+    You can download the Postman collection to easily access and use these endpoints. [click here](https://github.com/kby-ai/IDCardRecognition-Docker/tree/main/postman/kby-ai-idcard.postman_collection.json)
+    
+    ![image](https://github.com/kby-ai/IDCardRecognition-Docker/assets/125717930/0ec93826-76d7-47a7-9065-6bd353bc79b3)
+
+## SDK License
+
+This project uses KBY-AI's Face Recognition Server SDK, which requires a license per machine.
+
+- The code below shows how to use the license: https://github.com/kby-ai/IDCardRecognition-Docker/blob/9f8138fa83d39a80a95e71b52048dbfc6579558c/app.py#L14-L25
+
+- In order to request the license, please provide us with the machine code obtained from the "getMachineCode" function.
+
+  Please contact us:
+  ```
+  Email: [email protected]
+
+  Telegram: @kbyai
+
+  WhatsApp: +19092802609
+
+  Skype: live:.cid.66e2522354b1049b
+
+## How to run
+
+### 1. System Requirements
+  - CPU: 2 cores or more (Recommended: 2 cores)
+  - RAM: 4 GB or more (Recommended: 8 GB)
+  - HDD: 4 GB or more (Recommended: 8 GB)
+  - OS: Ubuntu 20.04 or later
+
+### 2. Setup and Test
+  - Clone the project:
+    ```
+    git clone https://github.com/kby-ai/IDCardRecognition-Docker.git
+    ```
+  - Download the model from Google Drive: [click here](https://drive.google.com/file/d/19vA7ZOlo19BcW8v4iCoCGahUEbgKCo48/view?usp=sharing)
+    ```
+    cd IDCardRecognition-Docker
+    
+    wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1fmTUG7a9IoMA8QiXR9A0xf3Cr6D5UkdC' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=1fmTUG7a9IoMA8QiXR9A0xf3Cr6D5UkdC" -O data.zip && rm -rf /tmp/cookies.txt
+    
+    unzip data.zip
+    ```
+  - Build the Docker image:
+    ```
+    sudo docker build --pull --rm -f Dockerfile -t kby-ai-idcard:latest .
+    ```
+  - Run the Docker container:
+    ```
+    sudo docker run -v ./license.txt:/root/kby-ai-idcard/license.txt -p 8082:8080 kby-ai-idcard
+    ```
+  - Send us the machine code and then we will give you a license key.
+  
+    After that, update the license.txt file by overwriting the license key that you received. Then, run the Docker container again.
+    
+    ![image](https://github.com/kby-ai/IDCardRecognition-Docker/assets/125717930/deab4a80-ae99-4646-a37d-b1441cff4dde)
+    
+    ![image](https://github.com/kby-ai/IDCardRecognition-Docker/assets/125717930/7994cecd-05fb-42e7-a21d-986da0e2d796)
+
+  - To test the API, you can use Postman. Here are the endpoints for testing:
+
+    Test with an image file: Send a POST request to http://{xx.xx.xx.xx}:8082/idcard_recognition
+    
+    Test with a base64-encoded image: Send a POST request to http://{xx.xx.xx.xx}:8082/idcard_recognition_base64
+    
+    You can download the Postman collection to easily access and use these endpoints. [click here](https://github.com/kby-ai/IDCardRecognition-Docker/tree/main/postman/kby-ai-idcard.postman_collection.json)
+
+### 3. Execute the Gradio demo
+  - Setup Gradio
+    Ensure that you have the necessary dependencies installed. 
+    
+    Gradio requires Python 3.6 or above. 
+    
+    You can install Gradio using pip by running the following command:
+    ```
+    pip install gradio
+    ```
+  - Run the demo
+    Run it using the following command:
+    ```
+    cd gradio
+    python demo.py
+    ```
+  - You can test within the following URL:    
+    http://127.0.0.1:9000
+    
+## About SDK
+
+### 1. Initializing the SDK
+
+- Step One
+
+  First, obtain the machine code for activation and request a license based on the machine code.
+  ```
+  machineCode = getMachineCode()
+  print("machineCode: ", machineCode.decode('utf-8'))
+  ```
+  
+- Step Two
+
+  Next, activate the SDK using the received license.
+  ```
+  setActivation(license.encode('utf-8'))
+  ```  
+  If activation is successful, the return value will be SDK_SUCCESS. Otherwise, an error value will be returned.
+
+- Step Three
+
+  After activation, call the initialization function of the SDK.
+  ```
+  initSDK()
+  ```
+  If initialization is successful, the return value will be SDK_SUCCESS. Otherwise, an error value will be returned.
+
+### 2. APIs
+
+  - ID Card Recognition
+
+    The SDK provides a single API for ID card recognition.
+    
+    The function can be used as follows:
+
+    ```
+    ret = idcardRecognition(base64_image.encode('utf-8'))
+    ```
+    
+    The function accepts only one parameter, which should be the base64-encoded format of the image (e.g., JPG, PNG, etc.).
+
+    If the recognition is successful, the function will return a JSON-formatted string containing the recognized information. In case of failure, the return value will be NULL.

app.py

@@ -0,0 +1,79 @@
+import sys
+sys.path.append('.')
+
+import os
+import base64
+import json
+
+from flask import Flask, request, jsonify
+from idsdk import getMachineCode
+from idsdk import setActivation
+from idsdk import initSDK
+from idsdk import idcardRecognition
+
+licensePath = "license.txt"
+license = ""
+
+machineCode = getMachineCode()
+print("machineCode: ", machineCode.decode('utf-8'))
+
+try:
+    with open(licensePath, 'r') as file:
+        license = file.read()
+except IOError as exc:
+    print("failed to open license.txt: ", exc.errno)
+print("license: ", license)
+
+ret = setActivation(license.encode('utf-8'))
+print("activation: ", ret)
+
+ret = initSDK()
+print("init: ", ret)
+
+app = Flask(__name__) 
+
+@app.route('/idcard_recognition', methods=['POST'])
+def idcard_recognition():
+    try:
+        file = request.files['file']
+
+        base64_image = base64.b64encode(file.read()).decode('utf-8')
+        ret = idcardRecognition(base64_image.encode('utf-8'))
+
+        if ret != None:
+            j = json.loads(ret)
+            j.update({"Status": "Ok"})
+            response = jsonify(j)
+        else:
+            response = jsonify({"Status": "Error"})
+    except:
+        response = jsonify({"Status": "Error"})
+
+    response.status_code = 200
+    response.headers["Content-Type"] = "application/json; charset=utf-8"
+    return response
+
+@app.route('/idcard_recognition_base64', methods=['POST'])
+def idcard_recognition_base64():
+    try:
+        content = request.get_json()
+        base64_image = content['base64']
+
+        ret = idcardRecognition(base64_image.encode('utf-8'))
+
+        if ret != None:
+            j = json.loads(ret)
+            j.update({"Status": "Ok"})
+            response = jsonify(j)
+        else:
+            response = jsonify({"Status": "Error"})
+    except:
+        response = jsonify({"Status": "Error"})
+
+    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:9214b2a4e3a83dffd64264e473ca60abe160bc5a4b9362dabc038e4a8618bfcf
+size 87370348

gradio/demo.py

@@ -0,0 +1,357 @@
+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]
+
+def compare_face(frame1, frame2):
+    url = "http://127.0.0.1:8081/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]
+
+def idcard_recognition(frame):
+    url = "http://127.0.0.1:8082/idcard_recognition"
+    files = {'file': open(frame, 'rb')}
+
+    r = requests.post(url=url, files=files)
+
+    html = None
+    images = None
+    mrz = None
+
+    status = r.json().get('Status')
+    table_value = ""
+
+    if r.json().get('MRZ') is not None:
+        mrz = r.json().get('MRZ')
+
+    for key, value in r.json().items():
+        if key == 'Status' or key == 'Images' or key == 'MRZ' or key == 'Position':
+            continue
+
+        mrz_value = ''
+        if mrz is not None and mrz.get(key) is not None:
+            mrz_value = mrz[key]
+            del mrz[key]
+
+        row_value = ("<tr>"
+                        "<td>{key}</td>"
+                        "<td>{value}</td>"
+                        "<td>{mrz_value}</td>"
+                    "</tr>".format(key=key, value=value, mrz_value=mrz_value))
+        table_value = table_value + row_value
+
+
+    if mrz is not None:
+        for key, value in mrz.items():
+            if key == 'MRZ':
+                value = value.replace('<', '&lt;')
+                value = value.replace(',', '<p>')
+
+            row_value = ("<tr>"
+                            "<td>{key}</td>"
+                            "<td>{value}</td>"
+                            "<td>{mrz_value}</td>"
+                        "</tr>".format(key=key, value='', mrz_value=value))
+            table_value = table_value + row_value
+            
+
+    html = ("<table>"
+                "<tr>"
+                    "<th style=""width:20%"">Field</th>"
+                    "<th style=""width:40%"">Value</th>"
+                    "<th style=""width:40%"">MRZ</th>"
+                "</tr>"
+                "<tr>"
+                    "<td>Status</td>"
+                    "<td>{status}</td>"
+                    "<td></td>"
+                "</tr>"
+                "{table_value}"
+                "</table>".format(status=status, table_value=table_value))
+    
+    table_value = ""
+    for key, value in r.json().items():
+        if key == 'Images':
+            for image_key, image_value in value.items():
+                row_value = ("<tr>"
+                                "<td>{key}</td>"
+                                "<td><img src=""data:image/png;base64,{base64_image} width = '200'  height= '100' /></td>"
+                            "</tr>".format(key=image_key, base64_image=image_value))
+                table_value = table_value + row_value
+
+    images = ("<table>"
+                "<tr>"
+                    "<th>Field</th>"
+                    "<th>Image</th>"
+                "</tr>"
+                "{table_value}"
+                "</table>".format(table_value=table_value))
+    
+    return [html, images]
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+    # KBY-AI Technology
+    We offer SDKs for face recognition, liveness detection, and ID card recognition.
+    """
+    )
+    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])
+    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])
+    with gr.TabItem("ID Card Recognition"):
+        with gr.Row():
+            with gr.Column(scale=3):
+                id_image_input = gr.Image(type='filepath')
+                gr.Examples(['idcard_examples/1.jpg', 'idcard_examples/2.jpg', 'idcard_examples/3.jpg'], 
+                            inputs=id_image_input)
+                id_recognition_button = gr.Button("ID Card Recognition")
+            with gr.Column(scale=5):
+                id_result_output = gr.HTML()
+        
+            with gr.Column(scale=2):
+                image_result_output = gr.HTML()
+
+        id_recognition_button.click(idcard_recognition, inputs=id_image_input, outputs=[id_result_output, image_result_output])
+
+demo.launch(server_name="0.0.0.0", server_port=9000)

header/idsdk.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum SDK_ERROR
+{
+	SDK_SUCCESS = 0,
+	SDK_LICENSE_KEY_ERROR = -1,
+	SDK_LICENSE_APPID_ERROR = -2,
+	SDK_LICENSE_EXPIRED = -3,
+	SDK_NO_ACTIVATED = -4,
+	SDK_INIT_ERROR = -5,
+};
+
+
+/*
+* Get the machine code for SDK activation
+*/
+const char* getMachineCode();
+
+/*
+* Activate the SDK using the provided license
+*/
+
+int setActivation(char* license);
+
+/*
+* Initialize the SDK with the specified model path
+*/
+int initSDK();
+
+/*
+* The function accepts only one parameter, which should be the base64-encoded format of the image (e.g., JPG, PNG, etc.).
+* If the recognition is successful, the function will return a JSON-formatted string containing the recognized information. In case of failure, the return value will be NULL.
+*/
+char* idcardRecognition(char* image_base64);
+
+#ifdef __cplusplus
+}
+#endif

idsdk.py

@@ -0,0 +1,23 @@
+import os
+
+from ctypes import *
+
+libPath = os.path.abspath(os.path.dirname(__file__)) + '/libidsdk.so'
+idsdk = cdll.LoadLibrary(libPath)
+
+getMachineCode = idsdk.getMachineCode
+getMachineCode.argtypes = []
+getMachineCode.restype = c_char_p
+
+setActivation = idsdk.setActivation
+setActivation.argtypes = [c_char_p]
+setActivation.restype = c_int32
+
+initSDK = idsdk.initSDK
+initSDK.argtypes = []
+initSDK.restype = c_int32
+
+idcardRecognition = idsdk.idcardRecognition
+idcardRecognition.argtypes = [c_char_p]
+idcardRecognition.restype = c_char_p
+

license.txt

@@ -0,0 +1,6 @@
+To obtain the license, please get in touch with us through the following contact details:
+
+Email: [email protected]
+Telegram: @kbyai
+WhatsApp: +19092802609
+Skype: live:.cid.66e2522354b1049b

postman/kby-ai-idcard.postman_collection.json

@@ -0,0 +1,73 @@
+{
+	"info": {
+		"_postman_id": "ae453c9a-d672-4e3d-bf4e-3847473197bc",
+		"name": "kby-ai-idcard",
+		"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
+		"_exporter_id": "2379931"
+	},
+	"item": [
+		{
+			"name": "idcard_recognition",
+			"request": {
+				"method": "POST",
+				"header": [],
+				"body": {
+					"mode": "formdata",
+					"formdata": [
+						{
+							"key": "file",
+							"type": "file",
+							"src": []
+						}
+					]
+				},
+				"url": {
+					"raw": "http://18.221.33.238:8082/idcard_recognition",
+					"protocol": "http",
+					"host": [
+						"18",
+						"221",
+						"33",
+						"238"
+					],
+					"port": "8082",
+					"path": [
+						"idcard_recognition"
+					]
+				}
+			},
+			"response": []
+		},
+		{
+			"name": "idcard_recognition_base64",
+			"request": {
+				"method": "POST",
+				"header": [],
+				"body": {
+					"mode": "raw",
+					"raw": "{\r\n    \"base64\":\"xxx\"\r\n}",
+					"options": {
+						"raw": {
+							"language": "json"
+						}
+					}
+				},
+				"url": {
+					"raw": "http://127.0.0.1:8082/idcard_recognition_base64",
+					"protocol": "http",
+					"host": [
+						"127",
+						"0",
+						"0",
+						"1"
+					],
+					"port": "8082",
+					"path": [
+						"idcard_recognition_base64"
+					]
+				}
+			},
+			"response": []
+		}
+	]
+}

requirements.txt

@@ -0,0 +1,2 @@
+flask
+flask-cors