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

Dockerfile

@@ -0,0 +1,45 @@
+FROM openvino/ubuntu20_runtime:2024.5.0
+
+USER root
+RUN rm -rf /var/lib/apt/lists/* && apt update && apt install -y unzip \
+    libjpeg8 \
+    libwebp6 \
+    libpng16-16 \
+    libtbb2 \
+    libtiff5 \
+    libtbb-dev \
+    libopenexr-dev \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libgomp1
+
+# Set up working directory
+RUN mkdir -p /home/openvino/kby-ai-fire
+WORKDIR /home/openvino/kby-ai-fire
+
+# Copy shared libraries and application files
+COPY ./libopencv.zip .
+RUN unzip libopencv.zip
+RUN cp -f libopencv/* /usr/local/lib/ 
+RUN ldconfig
+
+# Copy Python and application files
+COPY ./libfire.so .
+COPY ./app.py .
+COPY ./firesdk.py .
+COPY ./requirements.txt .
+COPY ./license.txt .
+COPY ./run.sh .
+COPY ./ncnn.zip .
+RUN unzip ncnn.zip
+
+# Install Python dependencies
+
+RUN pip3 install --no-cache-dir -r requirements.txt
+# RUN chmod +x ./run.sh
+# USER openvino
+# Set up entrypoint
+CMD ["bash", "./run.sh"]
+
+# Expose ports
+EXPOSE 8080 9000

app.py

@@ -0,0 +1,171 @@
+import sys
+sys.path.append('.')
+
+import os
+import base64
+import json
+from ctypes import *
+from firesdk import *
+import cv2
+import numpy as np
+from flask import Flask, request, jsonify
+
+
+licensePath = "license.txt"
+license = ""
+
+machineCode = getMachineCode()
+print("\nmachineCode: ", machineCode.decode('utf-8'))
+
+try:
+    with open(licensePath, 'r') as file:
+        license = file.read().strip()
+except IOError as exc:
+    print("failed to open license.txt: ", exc.errno)
+
+print("\nlicense: ", license)
+
+ret = setActivation(license.encode('utf-8'))
+print("\nactivation: ", ret)
+
+ret = initSDK()
+print("init: ", ret)
+
+app = Flask(__name__) 
+
+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()
+
+@app.route('/fire', methods=['POST'])
+def fire():
+    result = "None"
+    object_name = {}
+    box = {}
+    pro = {}
+    
+    file = request.files['file']
+    
+    try:
+        image = cv2.imdecode(np.frombuffer(file.read(), np.uint8), cv2.IMREAD_COLOR)
+        # image = cv2.resize(image, (1024, 640))
+    except:
+        result = "Failed to open file"
+        response = jsonify({"result": result, "class": object_name, "coordinate": box, "score": pro})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+
+    img_byte = mat_to_bytes(image)
+    
+    box_array = (c_int * 1024)()  # Assuming a maximum of 256 rectangles
+    score_array = (c_float * 1024)()  # Assuming a maximum of 256 rectangles
+    label_array = (c_int * 1024)()
+    
+    cnt = getFireDetection(img_byte, len(img_byte), label_array, box_array, score_array)
+
+    rectangles = [
+    (box_array[i * 4], box_array[i * 4 + 1], box_array[i * 4 + 2], box_array[i * 4 + 3])
+    for i in range(cnt)]
+    scores = [score_array[i] for i in range(cnt)]
+    labels = [label_array[i] for i in range(cnt)]
+
+    # print(f"detection number: {cnt}, box: {rectangles}, labels: {labels}, scores: {scores} \n")
+
+    if cnt == 0:
+        result = "Nothing Detected !"
+        response = jsonify({"result": result, "class": object_name, "coordinate": box, "score": pro})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+    
+    result = "Fire or Smoke Detected !"
+    for i in range(cnt):
+        if labels[i] == 0:
+            object_name[f"id {i + 1}"] = "fire"
+        else:
+            object_name[f"id {i + 1}"] = "smoke"
+        box[f"id {i + 1}"] = rectangles[i]
+        pro[f"id {i + 1}"] = scores[i]
+    
+    response = jsonify({"result": result, "class": object_name, "coordinate": box, "score": pro})
+
+    response.status_code = 200
+    response.headers["Content-Type"] = "application/json; charset=utf-8"
+    return response
+
+@app.route('/fire_base64', methods=['POST'])
+def fire_base64():
+
+    result = "None"
+    object_name = {}
+    box = {}
+    pro = {}
+    
+    content = request.get_json()
+
+    try:
+        imageBase64 = content['base64']
+        image_data = base64.b64decode(imageBase64) 
+        np_array = np.frombuffer(image_data, np.uint8)
+        image = cv2.imdecode(np_array, cv2.IMREAD_COLOR)  
+        # image = cv2.resize(image, (1024, 640)) 
+    except:
+        result = "Failed to open file1"
+        response = jsonify({"result": result, "class": object_name, "coordinate": box, "score": pro})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+    
+
+    img_byte = mat_to_bytes(image)
+    
+    box_array = (c_int * 1024)()  # Assuming a maximum of 256 rectangles
+    score_array = (c_float * 1024)()  # Assuming a maximum of 256 rectangles
+    label_array = (c_int * 1024)()
+    
+    cnt = getFireDetection(img_byte, len(img_byte), label_array, box_array, score_array)
+
+    rectangles = [
+    (box_array[i * 4], box_array[i * 4 + 1], box_array[i * 4 + 2], box_array[i * 4 + 3])
+    for i in range(cnt)]
+    scores = [score_array[i] for i in range(cnt)]
+    labels = [label_array[i] for i in range(cnt)]
+
+    # print(f"detection number: {cnt}, box: {rectangles}, labels: {labels}, scores: {scores} \n")
+
+    if cnt == 0:
+        result = "Nothing Detected !"
+        response = jsonify({"result": result, "class": object_name, "coordinate": box, "score": pro})
+
+        response.status_code = 200
+        response.headers["Content-Type"] = "application/json; charset=utf-8"
+        return response
+    
+    result = "Fire or Smoke Detected !"
+    for i in range(cnt):
+        if labels[i] == 0:
+            object_name[f"id {i + 1}"] = "fire"
+        else:
+            object_name[f"id {i + 1}"] = "smoke"
+        box[f"id {i + 1}"] = rectangles[i]
+        pro[f"id {i + 1}"] = scores[i]
+    
+    response = jsonify({"result": result, "class": object_name, "coordinate": box, "score": pro})
+
+    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,100 @@
+import gradio as gr
+import requests
+from PIL import Image
+import io
+import cv2
+import numpy as np
+
+alpr_count = 0
+def plot_one_box(x, img, color=None, label=None, score=None, line_thickness=3):
+	# Plots one bounding box on image img
+    tl = line_thickness or round(0.002 * (img.shape[0] + img.shape[1]) / 2) + 1  # line/font thickness
+    color = color
+    c1, c2 = (int(x[0]), int(x[1])), (int(x[2])+int(x[0]), int(x[3])+int(x[1]))
+    cv2.rectangle(img, c1, c2, color, thickness=tl, lineType=cv2.LINE_AA)
+    if label:
+        tf = max(tl - 1, 1)  # font thickness
+        t_size = cv2.getTextSize(label, 0, fontScale=tl / 3, thickness=tf)[0]
+        c2 = c1[0] + t_size[0], c1[1] - t_size[1] - 3
+        cv2.rectangle(img, c1, c2, color, -1, cv2.LINE_AA)  # filled
+        cv2.putText(img, label, (c1[0], c1[1] - 2), 0, tl / 3, [0, 0, 0], thickness=tf, lineType=cv2.LINE_AA)
+
+        pro = f"{score:.3f}"
+        t_size = cv2.getTextSize(pro, 0, fontScale=tl / 3, thickness=tf)[0]
+        c1 = c2
+        c2 = c1[0] + t_size[0], c1[1] + t_size[1] + 3
+        cv2.rectangle(img, c1, c2, [0, 255, 255], -1, cv2.LINE_AA)  # filled
+        cv2.putText(img, pro, (c1[0], c2[1] - 2), 0, tl / 3, [0, 0, 0], thickness=tf, lineType=cv2.LINE_AA)
+    return img
+    
+def fire(frame):
+    global fire_count
+    
+    fire_count = fire_count + 1
+    print("fire_count", fire_count) 
+    url = "http://127.0.0.1:8080/fire"
+    file = {'file': open(frame, 'rb')}
+
+    r = requests.post(url=url, files=file)
+   
+    fire_output = None
+    result = r.json().get('result')
+    object_name = r.json().get('class')
+    box = r.json().get('coordinate')
+    pro = r.json().get('score')
+    # print("\n number: ", plate_number)
+    # print("\n coordinate: ", box)
+    # print("\n score: ", pro)
+    try:
+        image = cv2.imread(frame, cv2.IMREAD_COLOR)
+        if image is None:
+            print('image is null')
+            sys.exit()
+        # image = cv2.resize(image, (1024, 640))
+        for obj_name in object_name:
+            # print(plate_number)
+            image = plot_one_box(box[obj_name], image, label=object_name[obj_name], score=pro[obj_name], color=[0, 255, 0], line_thickness=1)
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        
+        fire_output = image.copy()
+        
+    except:
+        pass
+
+    return fire_output
+    
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+    # KBY-AI Fire/Smoke Detection SDK Demo
+    We offer SDKs for face recognition, liveness detection(anti-spoofing), ID card recognition and ID document liveness detection. 
+    We also specialize in providing outsourcing services with a variety of technical stacks like AI(Computer Vision/Machine Learning), mobile apps, and web apps.
+    
+    ##### KYC Verification Demo - https://github.com/kby-ai/KYC-Verification-Demo-Android
+    ##### ID Capture Web Demo - https://cap.kby-ai.com
+    """
+    )
+
+    with gr.TabItem("Fire/Smoke Detection"):
+        gr.Markdown(
+            """
+        ##### Docker Hub - https://hub.docker.com/r/kbyai/fire-smoke-detection
+        ```bash
+        sudo docker pull kbyai/fire-smoke-detection:latest
+        sudo docker run -v ./license.txt:/home/openvino/kby-ai-fire/license.txt -p 8081:8080 -p 9001:9000 kbyai/fire-smoke-detection:latest
+        ```
+        """
+        )
+        with gr.Row():
+            with gr.Column():
+                alpr_image_input = gr.Image(type='filepath', height=300)
+                gr.Examples(['fire_examples/test1.jpg', 'fire_examples/test2.jpg', 'fire_examples/test3.jpg', 'fire_examples/test4.jpg'], 
+                            inputs=alpr_image_input)
+                fire_confirmation_button = gr.Button("Confirm")
+            with gr.Column():
+                fire_output = gr.Image(type="numpy")
+
+        fire_confirmation_button.click(fire, inputs=alpr_image_input, outputs=fire_output)
+    gr.HTML('<a href="https://visitorbadge.io/status?path=https%3A%2F%2Fweb.kby-ai.com%2F"><img src="https://api.visitorbadge.io/api/combined?path=https%3A%2F%2Fweb.kby-ai.com%2F&label=VISITORS&countColor=%23263759" /></a>')
+
+demo.launch(server_name="0.0.0.0", server_port=7860)

firesdk.py

@@ -0,0 +1,22 @@
+import os
+
+from ctypes import *
+
+libPath = os.path.abspath(os.path.dirname(__file__)) + '/libfire.so'
+firesdk = cdll.LoadLibrary(libPath)
+
+getMachineCode = firesdk.getMachineCode
+getMachineCode.argtypes = []
+getMachineCode.restype = c_char_p
+
+setActivation = firesdk.setActivation
+setActivation.argtypes = [c_char_p]
+setActivation.restype = c_int32
+
+initSDK = firesdk.initSDK
+initSDK.argtypes = []
+initSDK.restype = c_int32
+
+getFireDetection = firesdk.get_fire_using_bytes
+getFireDetection.argtypes = [c_char_p, c_ulong, POINTER(c_int), POINTER(c_int), POINTER(c_float)]
+getFireDetection.restype = c_int32

libfire.so

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

libopencv.zip

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

ncnn.zip

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

requirements.txt

@@ -0,0 +1,5 @@
+flask
+flask-cors
+gradio==3.50.2
+datadog_api_client
+opencv-python

run.sh

@@ -0,0 +1,3 @@
+# cd /home/openvino/kby-ai-alpr
+exec python3 demo.py &
+exec python3 app.py