first commit

.gitattributes

@@ -33,3 +33,8 @@ 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
+yolo11n-pose.pt filter=lfs diff=lfs merge=lfs -text
+test-images/ filter=lfs diff=lfs merge=lfs -text
+test-images/test2.jpg filter=lfs diff=lfs merge=lfs -text
+test-images/test3.jpg filter=lfs diff=lfs merge=lfs -text
+test-images/test1.jpg filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,37 @@
+import gradio as gr
+import cv2
+import numpy as np
+from ultralytics import YOLO
+from utils import PlotPose
+
+
+def show_example(path):
+    return cv2.cvtColor(cv2.imread(path), cv2.COLOR_BGR2RGB)
+
+
+def get_response(input_img):
+    result = model(input_img)
+    pred_kpts = result[0].keypoints.data.numpy()
+    out_img=result[0].orig_img.copy()
+    plotpose.lw=int(input_img.shape[0]*input_img.shape[1]*0.00001)
+    if len(pred_kpts)>0:
+        for i in range(len(pred_kpts)):
+            out_img = plotpose.plot(out_img, pred_kpts[i])
+
+    return out_img.astype(np.uint8)
+
+
+if __name__ == "__main__":
+    model = YOLO("yolo11n-pose.pt")
+    plotpose=PlotPose()
+    model.to("cpu")
+    iface = gr.Interface(
+        cache_examples=False,
+        fn=get_response,
+        inputs=[gr.Image(type="numpy")],  # Accepts image input
+        examples=[[show_example('test-images/test1.jpg')],[show_example('test-images/test2.jpg')],[show_example('test-images/test3.jpg')]],
+        outputs=[gr.Image(type="numpy")],
+        title="Posture-Estimation-YOLO11",
+        description="Upload images to predict human keypoint")
+
+    iface.launch()

requirements.txt

@@ -0,0 +1,4 @@
+opencv_python
+ultralytics
+gradio
+

utils.py

@@ -0,0 +1,98 @@
+import cv2
+from ultralytics.utils.plotting import colors
+
+
+
+class PlotPose:
+
+    def __init__(self):
+        self.skeleton = [
+            [16, 14],
+            [14, 12],
+            [17, 15],
+            [15, 13],
+            [12, 13],
+            [6, 12],
+            [7, 13],
+            [6, 7],
+            [6, 8],
+            [7, 9],
+            [8, 10],
+            [9, 11],
+            [2, 3],
+            [1, 2],
+            [1, 3],
+            [2, 4],
+            [3, 5],
+            [4, 6],
+            [5, 7],
+        ]
+
+        self.limb_color = colors.pose_palette[[9, 9, 9, 9, 7, 7, 7, 0, 0, 0, 0, 0, 16, 16, 16, 16, 16, 16, 16]]
+        self.kpt_color = colors.pose_palette[[16, 16, 16, 16, 16, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9]]
+
+
+    def plot(self,im,
+        kpts,
+        shape=(640, 640),
+        radius=None,
+        kpt_line=True,
+        conf_thres= 0.25,):
+
+        """
+                Plot keypoints on the image.
+
+                Args:
+                    im (numpy array): img to plot keypoints
+                    kpts (numpy arrayr): Keypoints, shape [17, 3] (x, y, confidence).
+                    shape (tuple, optional): Image shape (h, w).
+                    radius (int, optional): Keypoint radius.
+                    kpt_line (bool, optional): Draw lines between keypoints.
+                    conf_thres (float, optional): Confidence threshold.
+                    kpt_color (tuple, optional): Keypoint color (B, G, R).
+
+                Note:
+                    - `kpt_line=True` currently only supports human pose plotting.
+                    - Modifies self.im in-place.
+                    - If self.pil is True, converts image to numpy array and back to PIL.
+                """
+        self.lw = 4
+        radius = radius if radius is not None else self.lw
+        nkpt, ndim = kpts.shape
+        is_pose = nkpt == 17 and ndim in {2, 3}
+        kpt_line &= is_pose  # `kpt_line=True` for now only supports human pose plotting
+        for i, k in enumerate(kpts):
+            color_k = self.kpt_color[i].tolist()
+            # color_k = kpt_color or (kpt_color[i].tolist() if is_pose else colors(i))
+            x_coord, y_coord = k[0], k[1]
+            if x_coord % shape[1] != 0 and y_coord % shape[0] != 0:
+                if len(k) == 3:
+                    conf = k[2]
+                    if conf < conf_thres:
+                        continue
+                cv2.circle(im, (int(x_coord), int(y_coord)), radius, 255, -1, lineType=cv2.LINE_AA)
+
+        if kpt_line:
+            ndim = kpts.shape[-1]
+            for i, sk in enumerate(self.skeleton):
+                pos1 = (int(kpts[(sk[0] - 1), 0]), int(kpts[(sk[0] - 1), 1]))
+                pos2 = (int(kpts[(sk[1] - 1), 0]), int(kpts[(sk[1] - 1), 1]))
+                if ndim == 3:
+                    conf1 = kpts[(sk[0] - 1), 2]
+                    conf2 = kpts[(sk[1] - 1), 2]
+                    if conf1 < conf_thres or conf2 < conf_thres:
+                        continue
+                if pos1[0] % shape[1] == 0 or pos1[1] % shape[0] == 0 or pos1[0] < 0 or pos1[1] < 0:
+                    continue
+                if pos2[0] % shape[1] == 0 or pos2[1] % shape[0] == 0 or pos2[0] < 0 or pos2[1] < 0:
+                    continue
+                cv2.line(
+                    im,
+                    pos1,
+                    pos2,
+                    self.limb_color[i].tolist(),
+                    thickness=int(self.lw ),
+                    lineType=cv2.LINE_AA,
+                )
+
+        return im

yolo11n-pose.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:869e83fcdffdc7371fa4e34cd8e51c838cc729571d1635e5141e3075e9319dc0
+size 6255593