Added pphumanseg model to space

README.md

@@ -7,6 +7,12 @@ sdk: gradio
 sdk_version: 5.34.1
 app_file: app.py
 pinned: false
+short_description: Human segmentation using OpenCV PaddlePaddle humanseg ONNX model with Gradio UI
+tags:
+  - opencv
+  - Human segmentation
+  - PaddlePaddle
+  - Humanseg
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,67 @@
+import cv2 as cv
+import numpy as np
+import gradio as gr
+from huggingface_hub import hf_hub_download
+from pphumanseg import PPHumanSeg
+
+# Download ONNX model from Hugging Face
+model_path = hf_hub_download(repo_id="opencv/human_segmentation_pphumanseg", filename="human_segmentation_pphumanseg_2023mar.onnx")
+
+# Initialize PPHumanSeg model
+model = PPHumanSeg(
+    modelPath=model_path,
+    backendId=cv.dnn.DNN_BACKEND_OPENCV,
+    targetId=cv.dnn.DNN_TARGET_CPU
+)
+
+def get_color_map_list(num_classes):
+    num_classes += 1
+    color_map = num_classes * [0, 0, 0]
+    for i in range(num_classes):
+        j = 0
+        lab = i
+        while lab:
+            color_map[i * 3] |= (((lab >> 0) & 1) << (7 - j))
+            color_map[i * 3 + 1] |= (((lab >> 1) & 1) << (7 - j))
+            color_map[i * 3 + 2] |= (((lab >> 2) & 1) << (7 - j))
+            j += 1
+            lab >>= 3
+    return color_map[3:]
+
+def visualize(image, result, weight=0.6):
+    color_map = get_color_map_list(256)
+    color_map = np.array(color_map).reshape(256, 3).astype(np.uint8)
+
+    c1 = cv.LUT(result, color_map[:, 0])
+    c2 = cv.LUT(result, color_map[:, 1])
+    c3 = cv.LUT(result, color_map[:, 2])
+    pseudo_img = np.dstack((c1, c2, c3))
+
+    vis_result = cv.addWeighted(image, weight, pseudo_img, 1 - weight, 0)
+    return vis_result
+
+def segment_person(input_image):
+    image = cv.cvtColor(input_image, cv.COLOR_RGB2BGR)
+    h, w, _ = image.shape
+    resized = cv.resize(image, (192, 192))
+    resized = cv.cvtColor(resized, cv.COLOR_BGR2RGB)
+
+    result = model.infer(resized)
+    result = cv.resize(result[0, :, :], dsize=(w, h), interpolation=cv.INTER_NEAREST)
+
+    output = visualize(image, result)
+    output = cv.cvtColor(output, cv.COLOR_BGR2RGB)
+    return output
+
+# Gradio Interface
+demo = gr.Interface(
+    fn=segment_person,
+    inputs=gr.Image(type="numpy", label="Upload Image"),
+    outputs=gr.Image(type="numpy", label="Human Segmentation Output"),
+    title="Human Segmentation PPHumanSeg (OpenCV DNN)",
+    allow_flagging="never",
+    description="Upload an image to segment human regions using OpenCV's ONNX-based PPHumanSeg model."
+)
+
+if __name__ == "__main__":
+    demo.launch()

pphumanseg.py

@@ -0,0 +1,69 @@
+# This file is part of OpenCV Zoo project.
+# It is subject to the license terms in the LICENSE file found in the same directory.
+#
+# Copyright (C) 2021, Shenzhen Institute of Artificial Intelligence and Robotics for Society, all rights reserved.
+# Third party copyrights are property of their respective owners.
+
+import numpy as np
+import cv2 as cv
+
+class PPHumanSeg:
+    def __init__(self, modelPath, backendId=0, targetId=0):
+        self._modelPath = modelPath
+        self._backendId = backendId
+        self._targetId = targetId
+
+        self._model = cv.dnn.readNet(self._modelPath)
+        self._model.setPreferableBackend(self._backendId)
+        self._model.setPreferableTarget(self._targetId)
+
+        self._inputNames = ''
+        self._outputNames = ['save_infer_model/scale_0.tmp_1']
+        self._currentInputSize = None
+        self._inputSize = [192, 192]
+        self._mean = np.array([0.5, 0.5, 0.5])[np.newaxis, np.newaxis, :]
+        self._std = np.array([0.5, 0.5, 0.5])[np.newaxis, np.newaxis, :]
+
+    @property
+    def name(self):
+        return self.__class__.__name__
+
+    def setBackendAndTarget(self, backendId, targetId):
+        self._backendId = backendId
+        self._targetId = targetId
+        self._model.setPreferableBackend(self._backendId)
+        self._model.setPreferableTarget(self._targetId)
+
+    def _preprocess(self, image):
+
+        image = cv.cvtColor(image, cv.COLOR_BGR2RGB)
+
+        self._currentInputSize = image.shape
+        image = cv.resize(image, (192, 192))
+        
+        image = image.astype(np.float32, copy=False) / 255.0
+        image -= self._mean
+        image /= self._std
+        return cv.dnn.blobFromImage(image)
+
+    def infer(self, image):
+
+        # Preprocess
+        inputBlob = self._preprocess(image)
+
+        # Forward
+        self._model.setInput(inputBlob, self._inputNames)
+        outputBlob = self._model.forward()
+
+        # Postprocess
+        results = self._postprocess(outputBlob)
+
+        return results
+
+    def _postprocess(self, outputBlob):
+        
+        outputBlob = outputBlob[0]
+        outputBlob = cv.resize(outputBlob.transpose(1,2,0), (self._currentInputSize[1], self._currentInputSize[0]), interpolation=cv.INTER_LINEAR).transpose(2,0,1)[np.newaxis, ...]
+
+        result = np.argmax(outputBlob, axis=1).astype(np.uint8)
+        return result

requirements.txt

@@ -0,0 +1,4 @@
+opencv-python
+gradio
+numpy
+huggingface_hub