Update DWPose visualization styles

utils/draw_dw_lib.py

@@ -14,12 +14,114 @@ from typing import List, Dict, Any, Optional, Tuple
 
 eps = 0.01
 
+RENDER_STYLES = {
+    "bold": {"line_scale": 3.0, "point_scale": 2.0},
+    "thin": {"line_scale": 1.0, "point_scale": 1.0},
+}
+
+
+def get_render_style(style: str = "bold") -> Dict[str, float]:
+    """Return named DWPose rendering style parameters."""
+    if style not in RENDER_STYLES:
+        raise ValueError(f"Unknown render style '{style}'. Choose from: {sorted(RENDER_STYLES)}")
+    return RENDER_STYLES[style]
+
+
+def filter_pose_by_confidence(
+    pose_data: Dict[str, Any],
+    conf_threshold: float = 0.6,
+) -> Dict[str, Any]:
+    """Filter low-confidence joints before rendering."""
+    filtered = {}
+    for key, value in pose_data.items():
+        if isinstance(value, np.ndarray):
+            filtered[key] = value.copy()
+        else:
+            filtered[key] = value
+
+    bodies = filtered.get("bodies")
+    body_scores = filtered.get("body_scores")
+    if bodies is not None:
+        bodies = np.array(bodies, copy=True)
+        min_valid = 1e-6
+        coord_mask = (bodies[:, 0] > min_valid) & (bodies[:, 1] > min_valid)
+
+        conf_mask = None
+        if body_scores is not None:
+            score_vec = np.asarray(body_scores).reshape(-1).astype(float)
+            conf_mask = score_vec < conf_threshold
+            if conf_mask.shape[0] < bodies.shape[0]:
+                conf_mask = np.pad(
+                    conf_mask,
+                    (0, bodies.shape[0] - conf_mask.shape[0]),
+                    constant_values=False,
+                )
+            elif conf_mask.shape[0] > bodies.shape[0]:
+                conf_mask = conf_mask[: bodies.shape[0]]
+
+        valid_mask = coord_mask if conf_mask is None else coord_mask & (~conf_mask)
+        bodies[~valid_mask, :] = 0
+        filtered["bodies"] = bodies
+
+        if body_scores is not None:
+            subset = np.array(body_scores, copy=True)
+            if subset.ndim == 1:
+                subset = subset.reshape(1, -1)
+        else:
+            subset = np.arange(bodies.shape[0], dtype=float).reshape(1, -1)
+
+        if subset.shape[1] < bodies.shape[0]:
+            subset = np.pad(
+                subset,
+                ((0, 0), (0, bodies.shape[0] - subset.shape[1])),
+                constant_values=-1,
+            )
+        elif subset.shape[1] > bodies.shape[0]:
+            subset = subset[:, : bodies.shape[0]]
+
+        subset[:, ~valid_mask] = -1
+        filtered["body_scores"] = subset
+
+    hands = filtered.get("hands")
+    hand_scores = filtered.get("hands_scores")
+    if hands is not None and hand_scores is not None:
+        hands = np.array(hands, copy=True)
+        scores = np.array(hand_scores)
+        if hands.ndim == 3 and scores.ndim in (2, 3):
+            for h in range(hands.shape[0]):
+                cur_scores = scores[h] if scores.ndim == 2 else scores[h]
+                mask = (cur_scores < conf_threshold) | (cur_scores <= 0)
+                hands[h][mask, :] = 0
+        elif hands.ndim == 2 and scores.ndim in (1, 2):
+            cur_scores = scores if scores.ndim == 1 else scores.reshape(-1)
+            mask = (cur_scores < conf_threshold) | (cur_scores <= 0)
+            hands[mask, :] = 0
+        filtered["hands"] = hands
+
+    faces = filtered.get("faces")
+    face_scores = filtered.get("faces_scores")
+    if faces is not None and face_scores is not None:
+        faces = np.array(faces, copy=True)
+        scores = np.array(face_scores)
+        if faces.ndim == 3 and scores.ndim in (2, 3):
+            for f in range(faces.shape[0]):
+                cur_scores = scores[f] if scores.ndim == 2 else scores[f]
+                mask = (cur_scores < conf_threshold) | (cur_scores <= 0)
+                faces[f][mask, :] = 0
+        elif faces.ndim == 2 and scores.ndim in (1, 2):
+            cur_scores = scores if scores.ndim == 1 else scores.reshape(-1)
+            mask = (cur_scores < conf_threshold) | (cur_scores <= 0)
+            faces[mask, :] = 0
+        filtered["faces"] = faces
+
+    return filtered
+
 def alpha_blend_color(color, alpha):
     """blend color according to point conf
     """
     return [int(c * alpha) for c in color]
 
-def draw_bodypose(canvas, candidate, subset, score, transparent=False):
+def draw_bodypose(canvas, candidate, subset, score, transparent=False, line_scale=1.0, point_scale=1.0):
     """Draw body pose on canvas
     Args:
         canvas: numpy array canvas to draw on
@@ -34,7 +136,7 @@ def draw_bodypose(canvas, candidate, subset, score, transparent=False):
     candidate = np.array(candidate)
     subset = np.array(subset)
 
-    stickwidth = 4
+    stickwidth = max(1, int(round(4 * line_scale)))
 
     limbSeq = [[2, 3], [2, 6], [3, 4], [4, 5], [6, 7], [7, 8], [2, 9], [9, 10],
                [10, 11], [2, 12], [12, 13], [13, 14], [2, 1], [1, 15], [15, 17],
@@ -82,11 +184,11 @@ def draw_bodypose(canvas, candidate, subset, score, transparent=False):
                 color = colors[i][:-1] + [int(255 * conf)]  # Adjust alpha based on confidence
             else:
                 color = colors[i]
-            cv2.circle(canvas, (int(x), int(y)), 4, color, thickness=-1)
+            cv2.circle(canvas, (int(x), int(y)), max(1, int(round(4 * point_scale))), color, thickness=-1)
 
     return canvas
 
-def draw_handpose(canvas, all_hand_peaks, all_hand_scores, transparent=False):
+def draw_handpose(canvas, all_hand_peaks, all_hand_scores, transparent=False, line_scale=1.0, point_scale=1.0):
     """Draw hand pose on canvas"""
     H, W, C = canvas.shape
 
@@ -105,10 +207,10 @@ def draw_handpose(canvas, all_hand_peaks, all_hand_scores, transparent=False):
             if x1 > eps and y1 > eps and x2 > eps and y2 > eps:
                 color = matplotlib.colors.hsv_to_rgb([ie / float(len(edges)), 1.0, 1.0])
                 if transparent:
-                    color = np.append(color, score)  # Add alpha channel
+                    color = tuple(int(c * 255) for c in color) + (int(score * 255),)
                 else:
-                    color = color * score
-                cv2.line(canvas, (x1, y1), (x2, y2), color * 255, thickness=2)
+                    color = tuple(int(c * score * 255) for c in color)
+                cv2.line(canvas, (x1, y1), (x2, y2), color, thickness=max(1, int(round(2 * line_scale))))
 
         for i, keypoint in enumerate(peaks):
             x, y = keypoint
@@ -116,13 +218,13 @@ def draw_handpose(canvas, all_hand_peaks, all_hand_scores, transparent=False):
             y = int(y * H)
             if x > eps and y > eps:
                 if transparent:
-                    color = (0, 0, 0, scores[i])  # Black with alpha
+                    color = (0, 0, 0, int(scores[i] * 255))
                 else:
-                    color = (0, 0, int(scores[i] * 255))  # Original color
-                cv2.circle(canvas, (x, y), 4, color, thickness=-1)
+                    color = (0, 0, int(scores[i] * 255))
+                cv2.circle(canvas, (x, y), max(1, int(round(4 * point_scale))), color, thickness=-1)
     return canvas
 
-def draw_facepose(canvas, all_lmks, all_scores, transparent=False):
+def draw_facepose(canvas, all_lmks, all_scores, transparent=False, point_scale=1.0):
     """Draw face pose on canvas"""
     H, W, C = canvas.shape
     for lmks, scores in zip(all_lmks, all_scores):
@@ -136,10 +238,21 @@ def draw_facepose(canvas, all_lmks, all_scores, transparent=False):
                 else:
                     conf = int(score * 255)
                     color = (conf, conf, conf)  # Original grayscale
-                cv2.circle(canvas, (x, y), 3, color, thickness=-1)
+                cv2.circle(canvas, (x, y), max(1, int(round(3 * point_scale))), color, thickness=-1)
     return canvas
 
-def draw_pose(pose, H, W, include_body=True, include_hand=True, include_face=True, ref_w=2160, transparent=False):
+def draw_pose(
+    pose,
+    H,
+    W,
+    include_body=True,
+    include_hand=True,
+    include_face=True,
+    ref_w=2160,
+    transparent=False,
+    line_scale=1.0,
+    point_scale=1.0,
+):
     """vis dwpose outputs with optional transparent background
 
     Args:
@@ -175,31 +288,74 @@ def draw_pose(pose, H, W, include_body=True, include_hand=True, include_face=Tru
         subset = bodies['subset']
         
         if include_body:
-            canvas = draw_bodypose(canvas, candidate, subset, score=bodies['score'], transparent=transparent)
+            canvas = draw_bodypose(
+                canvas,
+                candidate,
+                subset,
+                score=bodies['score'],
+                transparent=transparent,
+                line_scale=line_scale,
+                point_scale=point_scale,
+            )
 
         if include_hand:
-            canvas = draw_handpose(canvas, hands, processed_data['hands_score'], transparent=transparent)
+            canvas = draw_handpose(
+                canvas,
+                hands,
+                processed_data['hands_score'],
+                transparent=transparent,
+                line_scale=line_scale,
+                point_scale=point_scale,
+            )
 
         if include_face:
-            canvas = draw_facepose(canvas, faces, processed_data['faces_score'], transparent=transparent)
+            canvas = draw_facepose(
+                canvas,
+                faces,
+                processed_data['faces_score'],
+                transparent=transparent,
+                point_scale=point_scale,
+            )
     
     else:
         # 兼容旧的数据格式 - 作为备选方案
         try:
-            bodies = pose['bodies']
-            faces = pose['faces']
-            hands = pose['hands']
+            processed_data = process_pose_data(pose, H, W)
+            bodies = processed_data['bodies']
+            faces = processed_data['faces']
+            hands = processed_data['hands']
             candidate = bodies['candidate']
             subset = bodies['subset']
 
             if include_body:
-                canvas = draw_bodypose(canvas, candidate, subset, score=bodies['score'], transparent=transparent)
+                canvas = draw_bodypose(
+                    canvas,
+                    candidate,
+                    subset,
+                    score=bodies['score'],
+                    transparent=transparent,
+                    line_scale=line_scale,
+                    point_scale=point_scale,
+                )
 
             if include_hand:
-                canvas = draw_handpose(canvas, hands, pose['hands_score'], transparent=transparent)
+                canvas = draw_handpose(
+                    canvas,
+                    hands,
+                    processed_data['hands_score'],
+                    transparent=transparent,
+                    line_scale=line_scale,
+                    point_scale=point_scale,
+                )
 
             if include_face:
-                canvas = draw_facepose(canvas, faces, pose['faces_score'], transparent=transparent)
+                canvas = draw_facepose(
+                    canvas,
+                    faces,
+                    processed_data['faces_score'],
+                    transparent=transparent,
+                    point_scale=point_scale,
+                )
         except Exception as e:
             print(f"绘制旧格式数据失败: {str(e)}")
             # 返回空画布
@@ -270,14 +426,31 @@ def process_pose_data(pose_data: Dict[str, Any], height: int, width: int) -> Dic
         face_scores = np.array(all_face_scores) if all_face_scores else np.array([])
         
     else:
-        # 兼容性处理 - 如果不是新格式，返回空数据
-        bodies = np.array([])
-        subset = np.array([[]])
-        scores = np.array([[]])
-        hands = np.array([])
-        hand_scores = np.array([])
-        faces = np.array([])
-        face_scores = np.array([])
+        # 兼容旧的单人数据格式
+        raw_bodies = np.array(pose_data.get('bodies', []), dtype=np.float32)
+        raw_body_scores = np.array(pose_data.get('body_scores', []), dtype=np.float32)
+        raw_hands = np.array(pose_data.get('hands', []), dtype=np.float32)
+        raw_hand_scores = np.array(pose_data.get('hands_scores', []), dtype=np.float32)
+        raw_faces = np.array(pose_data.get('faces', []), dtype=np.float32)
+        raw_face_scores = np.array(pose_data.get('faces_scores', []), dtype=np.float32)
+
+        if raw_bodies.size > 0:
+            bodies = raw_bodies.reshape(-1, 2)
+            subset = np.arange(bodies.shape[0], dtype=np.int32)[None, :]
+
+            if raw_body_scores.size > 0:
+                scores = raw_body_scores.reshape(1, -1)
+            else:
+                scores = np.ones((1, bodies.shape[0]), dtype=np.float32)
+        else:
+            bodies = np.array([])
+            subset = np.array([[]])
+            scores = np.array([[]])
+
+        hands = raw_hands if raw_hands.size > 0 else np.array([])
+        hand_scores = raw_hand_scores if raw_hand_scores.size > 0 else np.array([])
+        faces = raw_faces if raw_faces.size > 0 else np.array([])
+        face_scores = raw_face_scores if raw_face_scores.size > 0 else np.array([])
     
     processed_data['bodies'] = {
         'candidate': bodies,
@@ -291,4 +464,4 @@ def process_pose_data(pose_data: Dict[str, Any], height: int, width: int) -> Dic
     processed_data['faces'] = faces
     processed_data['faces_score'] = face_scores
     
-    return processed_data
+    return processed_data