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

Dockerfile

@@ -0,0 +1,50 @@
+FROM ubuntu:20.04
+
+# Install system dependencies, including Python and pip
+RUN apt-get update -y && \
+    apt-get install -y --no-install-recommends \
+    python3.8 \
+    python3-pip \
+    libjpeg8 \
+    libwebp6 \
+    libpng16-16 \
+    libtbb2 \
+    libtiff5 \
+    libtbb-dev \
+    unzip \
+    libopenexr-dev \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Ensure pip is installed
+RUN python3.8 -m pip install --upgrade pip
+
+# Set up working directory
+RUN mkdir -p /root/kby-ai-palmprint
+WORKDIR /root/kby-ai-palmprint
+
+# Copy shared libraries and application files
+COPY ./libhand.so /usr/local/lib/
+COPY ./libopencv.zip .
+RUN unzip libopencv.zip
+RUN cp -f libopencv/* /usr/local/lib/ 
+RUN ldconfig
+
+# Copy Python and application files
+COPY ./handtool-0.2.1-py3-none-any.whl .
+COPY ./app.py .
+COPY ./roi.py .
+COPY ./requirements.txt .
+COPY ./run.sh .
+COPY ./img ./img
+
+# Install Python dependencies
+RUN pip3 install --no-cache-dir -r requirements.txt
+RUN chmod +x ./run.sh
+# Set up entrypoint
+CMD ["/root/kby-ai-palmprint/run.sh"]
+
+# Expose ports
+EXPOSE 8080 9000

app.py

@@ -0,0 +1,234 @@
+import sys
+sys.path.append('.')
+
+import os
+import base64
+import json
+import handtool
+import cv2
+import numpy as np
+from roi import get_roi, mat_to_bytes
+from flask import Flask, request, jsonify
+
+threshold = 0.15
+
+licensePath = "license.txt"
+license = ""
+
+config = handtool.EncoderConfig(29, 5, 5, 10)
+encoder = handtool.create_encoder(config)
+
+machineCode = encoder.getMachineCode()
+print("\nmachineCode: ", 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("\nlicense: ", license)
+
+ret = encoder.setActivation(license.encode('utf-8'))
+print("\nactivation: ", ret)
+
+_ = encoder.init()
+print("\ninit: ", ret)
+
+app = Flask(__name__) 
+
+@app.route('/compare_palmprint', methods=['POST'])
+def compare_palmprint():
+    result = "None"
+    similarity = -1
+
+    palm1 = None
+    palm2 = None
+    
+    file1 = request.files['file1']
+    file2 = request.files['file2']
+
+    try:
+        image1 = cv2.imdecode(np.frombuffer(file1.read(), np.uint8), cv2.IMREAD_COLOR)
+
+    except:
+        result = "Failed to open file1"
+        response = jsonify({"compare_result": result, "compare_similarity": similarity, "palm1": palm1, "palm2": palm2})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+
+    try:
+        image2 = cv2.imdecode(np.frombuffer(file2.read(), np.uint8), cv2.IMREAD_COLOR)
+    except:
+        result = "Failed to open file2"
+        response = jsonify({"compare_result": result, "compare_similarity": similarity, "palm1": palm1, "palm2": palm2})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+    
+    img1 = mat_to_bytes(image1)
+    img2 = mat_to_bytes(image2)
+    hand_type_1, x11, y11, x12, y12, detect_state_1 = encoder.detect_using_bytes(img1)
+    hand_type_2, x21, y21, x22, y22, detect_state_2 = encoder.detect_using_bytes(img2)
+
+    palm1 = {"hand_type": hand_type_1, "x1": x11, "y1": y11, "x2": x12, "y2": y12}
+    palm2 = {"hand_type": hand_type_2, "x1": x21, "y1": y21, "x2": x22, "y2": y22}
+
+    if hand_type_1 != hand_type_2:
+        result = "Different hand"
+        # print(f"\n 2 images are from the different hand\n similarity: 0.0")
+        similarity = 0.0
+        response = jsonify({"compare_result": result, "compare_similarity": similarity, "palm1": palm1, "palm2": palm2})
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+        
+    if detect_state_1 == 0 or detect_state_2 == 0:
+        if ret != 0:
+            result = "Activation failed"
+            response = jsonify({"compare_result": result, "compare_similarity": similarity, "palm1": palm1, "palm2": palm2})
+            response.status_code = 200
+            response.headers["Content-Type"] = "application/json; charset=utf-8"
+            return response
+            
+        # print(f"\n hand detection failed !\n plesae make sure that input hand image is valid or not.")
+        result = "hand detection failed !\nPlesae make sure that input hand image is valid or not."
+        response = jsonify({"compare_result": result, "compare_similarity": similarity, "palm1": palm1, "palm2": palm2})
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+        
+    if detect_state_1 >= 2 or detect_state_2 >= 2:
+        # print(f"\n multi-hand detected !\n plesae put one hand image, not multiple hand.")
+        result = "multi-hand detected !\nPlesae try on image with one hand , not multiple hand."
+        response = jsonify({"compare_result": result, "compare_similarity": similarity, "palm1": palm1, "palm2": palm2})
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+    roi1 = mat_to_bytes(get_roi(image1, hand_type_1, x11, y11, x12, y12))
+    roi2 = mat_to_bytes(get_roi(image2, hand_type_2, x21, y21, x22, y22))
+    
+    one_palmprint_code = encoder.encode_using_bytes(roi1)
+    another_palmprint_code = encoder.encode_using_bytes(roi2)
+    score = one_palmprint_code.compare_to(another_palmprint_code)
+
+    if score >= threshold:
+        result = "Same hand"
+        similarity = score
+        # print(f"\n 2 images are from the same hand\n similarity: {score}")
+    else:
+        result = "Different hand"
+        similarity = score
+        # print(f"\n 2 images are from the different hand\n similarity: {score}")
+    
+    response = jsonify({"compare_result": result, "compare_similarity": similarity, "palm1": palm1, "palm2": palm2})
+
+    response.status_code = 200
+    response.headers["Content-Type"] = "application/json; charset=utf-8"
+    return response
+
+@app.route('/compare_palmprint_base64', methods=['POST'])
+def compare_palmprint_base64():
+    result = "None"
+    similarity = -1
+
+    palm1 = None
+    palm2 = None
+    
+    content = request.get_json()
+
+    try:
+        imageBase64_1 = content['base64_1']
+        image_data1 = base64.b64decode(imageBase64_1) 
+        np_array = np.frombuffer(image_data1, np.uint8)
+        image1 = cv2.imdecode(np_array, cv2.IMREAD_COLOR)   
+    except:
+        result = "Failed to open file1"
+        response = jsonify({"compare_result": result, "compare_similarity": similarity, "palm1": palm1, "palm2": palm2})
+
+        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)
+        np_array = np.frombuffer(image_data2, np.uint8)
+        image2 = cv2.imdecode(np_array, cv2.IMREAD_COLOR)
+    except IOError as exc:
+        result = "Failed to open file2"
+        response = jsonify({"compare_result": result, "compare_similarity": similarity, "palm1": palm1, "palm2": palm2})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+    img1 = mat_to_bytes(image1)
+    img2 = mat_to_bytes(image2)
+    hand_type_1, x11, y11, x12, y12, detect_state_1 = encoder.detect_using_bytes(img1)
+    hand_type_2, x21, y21, x22, y22, detect_state_2 = encoder.detect_using_bytes(img2)
+
+    palm1 = {"hand_type": hand_type_1, "x1": x11, "y1": y11, "x2": x12, "y2": y12}
+    palm2 = {"hand_type": hand_type_2, "x1": x21, "y1": y21, "x2": x22, "y2": y22}
+
+    if hand_type_1 != hand_type_2:
+        result = "Different hand"
+        # print(f"\n 2 images are from the different hand\n similarity: 0.0")
+        similarity = 0.0
+        response = jsonify({"compare_result": result, "compare_similarity": similarity, "palm1": palm1, "palm2": palm2})
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+        
+    if detect_state_1 == 0 or detect_state_2 == 0:
+        if ret != 0:
+            result = "Activation failed"
+            response = jsonify({"compare_result": result, "compare_similarity": similarity, "palm1": palm1, "palm2": palm2})
+            response.status_code = 200
+            response.headers["Content-Type"] = "application/json; charset=utf-8"
+            return response
+            
+        # print(f"\n hand detection failed !\n plesae make sure that input hand image is valid or not.")
+        result = "hand detection failed !\nPlesae make sure that input hand image is valid or not."
+        response = jsonify({"compare_result": result, "compare_similarity": similarity, "palm1": palm1, "palm2": palm2})
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+        
+    if detect_state_1 >= 2 or detect_state_2 >= 2:
+        # print(f"\n multi-hand detected !\n plesae put one hand image, not multiple hand.")
+        result = "multi-hand detected !\nPlesae try on image with one hand , not multiple hand."
+        response = jsonify({"compare_result": result, "compare_similarity": similarity, "palm1": palm1, "palm2": palm2})
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+    roi1 = mat_to_bytes(get_roi(image1, hand_type_1, x11, y11, x12, y12))
+    roi2 = mat_to_bytes(get_roi(image2, hand_type_2, x21, y21, x22, y22))
+    
+    one_palmprint_code = encoder.encode_using_bytes(roi1)
+    another_palmprint_code = encoder.encode_using_bytes(roi2)
+    score = one_palmprint_code.compare_to(another_palmprint_code)
+
+    if score >= threshold:
+        result = "Same hand"
+        similarity = score
+        # print(f"\n 2 images are from the same hand\n similarity: {score}")
+    else:
+        result = "Different hand"
+        similarity = score
+        # print(f"\n 2 images are from the different hand\n similarity: {score}")
+    
+    response = jsonify({"compare_result": result, "compare_similarity": similarity, "palm1": palm1, "palm2": palm2})
+
+    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)

libhand.so

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

libopencv.zip

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

license.txt

@@ -0,0 +1,5 @@
+sJBJyD6qMa5QrFncFtWmTa6pe1nWGDPknhDsUNl6NCgcj7/Cd/t7qEngL/arKSDLYXYe2JJT8EFz
+3jDmSNAReSQOEsm+vwcN7yEDaJyRS6BCmoCTkQpfLfoviTJ6LhhOQZ197gvd0FaJGkP+0R2RVlcJ
+qCZPuKhF8JY4FI58Fu3cXQT1W4fJ8f1YHZ3xsg4JJ7cowE9PT3+5VEVnU8HjQM8+If8n3fWDm5cf
+T83pntPeSXKaHtiP3eOGzVTR+Wl6B3cUMYEjJ0RQI0Q66hrju9t/7BehTBO3Sct2PGUmWAeKJdaV
+m8DEZWvJ/UDLGx9TepF2Hh1hpFdCvTe7iQWOUQ==

requirements.txt

@@ -0,0 +1,6 @@
+flask
+flask-cors
+gradio==3.50.2
+datadog_api_client
+opencv-python
+handtool-0.2.1-py3-none-any.whl

roi.py

@@ -0,0 +1,92 @@
+import cv2
+import numpy as np
+
+roi_bad_pixel_number = 500  # the number of pixel where 3 values are zero in RGB channel on ROI image
+roi_aspect_ratio_threshold = 200  # the passable aspect ratio threshold of ROI image
+cupped_pose_threshold = 3  # this value determines if hand is cupped or not
+frame_margin = 300  # the extra marine size of the frame inputted into Google Mediapipe Graph (this value must be a
+# multiple of two)
+roi_size_threshold = 0.23
+
+def mat_to_bytes(mat):
+    """
+    Convert cv::Mat image data (NumPy array in Python) to raw bytes.
+    """
+    # Encode cv::Mat as PNG bytes
+    is_success, buffer = cv2.imencode(".png", mat)
+    if not is_success:
+        raise ValueError("Failed to encode cv::Mat image")
+    return buffer.tobytes()
+
+def img_crop(img_original, x2, x1, y2, y1, label):
+    
+    h, w, _ = img_original.shape
+    img = np.zeros((h + 20, w + 20, 3), np.uint8)
+    img[10:-10, 10:-10, :] = img_original
+
+    if label == "Left":
+        v1 = np.array([x2, y2])
+        v2 = np.array([x1, y1])
+    else:
+        v2 = np.array([x2, y2])
+        v1 = np.array([x1, y1])
+    
+    theta = np.arctan2((v2 - v1)[1], (v2 - v1)[0]) * 180 / np.pi
+    R = cv2.getRotationMatrix2D(tuple([int(v2[0]), int(v2[1])]), theta, 1)
+    
+    v1 = (R[:, :2] @ v1 + R[:, -1]).astype(int)
+    v2 = (R[:, :2] @ v2 + R[:, -1]).astype(int)
+    img_r = cv2.warpAffine(img, R, (w, h))
+    
+    if 1:
+        ux = int(v1[0] - (v2 - v1)[0] * 0.05)
+        uy = int(v1[1] + (v2 - v1)[0] * 0.05)
+        lx = int(v2[0] + (v2 - v1)[0] * 0.05)
+        ly = int(v2[1] + (v2 - v1)[0] * 1)
+    else:
+        ux = int(v1[0] - (v2 - v1)[0] * 0.1)
+        uy = int(v1[1] + (v2 - v1)[0] * 0.1)
+        lx = int(v2[0] + (v2 - v1)[0] * 0.1)
+        ly = int(v2[1] + (v2 - v1)[0] * 1.2)
+
+    # delta_y is movement value in y ward
+    delta_y = (ly - uy) * 0.15
+
+    ly = int(ly - delta_y)
+    uy = int(uy - delta_y)
+
+    delta_x = (lx - ux) * 0.01
+    lx = int(lx + delta_x)
+    ux = int(ux + delta_x)
+    
+    if label == "Right":
+        delta_x = (lx - ux) * 0.05
+        lx = int(lx + delta_x)
+        ux = int(ux + delta_x)
+    # roi = img_r
+    roi = img_r[uy:ly, ux:lx]
+    if roi.shape[0] == 0 or roi.shape[1] == 0:
+        print("error 1")
+        return None, 3
+    if abs(roi.shape[0] - roi.shape[1]) > roi_aspect_ratio_threshold:
+        print("error 2", abs(roi.shape[0] - roi.shape[1]))
+        return None, 4
+    if roi.shape[1] / w < roi_size_threshold:
+        print("error 3", roi.shape[1] / w)
+        return None, 7
+
+    n_zeros = np.count_nonzero(roi == 0)
+    # if n_zeros > roi_bad_pixel_number:
+        # print("error 4", n_zeros)
+        # return None, 5
+    return roi, 0
+            
+def get_roi(img, hand_type, x1, y1, x2, y2):
+    
+    if hand_type == 0:
+        label = "Left"
+    else:
+        label = "Right"
+    roi, _ = img_crop(img, x1, x2, y1, y2, label)
+    cv2.imwrite('test.jpg', roi)
+    return roi

run.sh

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