commented the logs

backend/gradio_labanmovementanalysis/visualizer.py

@@ -68,7 +68,7 @@ class PoseVisualizer:
             show_direction_arrows: Whether to show movement direction arrows
             show_metrics: Whether to display text metrics on frame
         """
-        print("[TRACE] PoseVisualizer.__init__ called")
+        # print("[TRACE] PoseVisualizer.__init__ called")
         self.trail_length = trail_length
         self.show_skeleton = show_skeleton
         self.show_trails = show_trails
@@ -102,16 +102,16 @@ class PoseVisualizer:
         Returns:
             Annotated frame
         """
-        print(f"[TRACE] visualize_frame(frame_index={frame_index}, num_poses={len(pose_results)})")
+        # print(f"[TRACE] visualize_frame(frame_index={frame_index}, num_poses={len(pose_results)})")
         vis_frame = frame.copy()
         if not pose_results:
-            print(f"[DEBUG] Frame {frame_index}: No pose results (no detections)")
+            # print(f"[DEBUG] Frame {frame_index}: No pose results (no detections)")
             return vis_frame  # No people detected, return original frame
         
         # Draw for each detected person
         for person_idx, pose in enumerate(pose_results):
             if not pose.keypoints or all(math.isnan(kp.x) or math.isnan(kp.y) for kp in pose.keypoints):
-                print(f"[DEBUG] Frame {frame_index}, Person {person_idx}: All keypoints are NaN or missing, skipping drawing for this person.")
+                # print(f"[DEBUG] Frame {frame_index}, Person {person_idx}: All keypoints are NaN or missing, skipping drawing for this person.")
                 continue
             
             # Update trails
@@ -156,7 +156,7 @@ class PoseVisualizer:
         Returns:
             Path to created video
         """
-        print(f"[TRACE] generate_overlay_video(num_frames={len(frames)})")
+        # print(f"[TRACE] generate_overlay_video(num_frames={len(frames)})")
         try:
             if len(frames) != len(all_pose_results) or len(frames) != len(all_movement_metrics):
                 raise ValueError("Mismatched lengths between frames, poses, and metrics")
@@ -167,9 +167,9 @@ class PoseVisualizer:
             ):
                 annotated_frame = self.visualize_frame(frame, poses, metrics, i)
                 annotated_frames.append(annotated_frame)
-            print(f"[DEBUG] About to assemble video with {len(annotated_frames)} frames.")
+            # print(f"[DEBUG] About to assemble video with {len(annotated_frames)} frames.")
             for idx, f in enumerate(annotated_frames):
-                print(f"[DEBUG] Frame {idx} shape: {f.shape if hasattr(f, 'shape') else type(f)}")
+                # print(f"[DEBUG] Frame {idx} shape: {f.shape if hasattr(f, 'shape') else type(f)}")
             from . import video_utils
             return video_utils.assemble_video(annotated_frames, output_path, fps)
         except Exception as e:
@@ -179,7 +179,7 @@ class PoseVisualizer:
     
     def _update_trails(self, pose: PoseResult, person_id: int):
         """Update motion trails for a person."""
-        print(f"[TRACE] _update_trails(person_id={person_id})")
+        # print(f"[TRACE] _update_trails(person_id={person_id})")
         if person_id not in self.trails:
             self.trails[person_id] = {}
         
@@ -196,7 +196,7 @@ class PoseVisualizer:
     
     def _draw_trails(self, frame: np.ndarray, person_id: int):
         """Draw motion trails for a person."""
-        print(f"[TRACE] _draw_trails(person_id={person_id})")
+        # print(f"[TRACE] _draw_trails(person_id={person_id})")
         if person_id not in self.trails:
             return
         
@@ -211,9 +211,9 @@ class PoseVisualizer:
                 x1, y1 = trail[i-1]
                 x2, y2 = trail[i]
                 if math.isnan(x1) or math.isnan(y1) or math.isnan(x2) or math.isnan(y2):
-                    print(f"[DEBUG] _draw_trails: NaN detected in trail for person {person_id}, joint {joint_name}, skipping segment.")
+                    # print(f"[DEBUG] _draw_trails: NaN detected in trail for person {person_id}, joint {joint_name}, skipping segment.")
                     continue
-                print(f"[DEBUG] _draw_trails: Converting to int: ({x1}*{w}, {y1}*{h}) and ({x2}*{w}, {y2}*{h})")
+                # print(f"[DEBUG] _draw_trails: Converting to int: ({x1}*{w}, {y1}*{h}) and ({x2}*{w}, {y2}*{h})")
                 alpha = i / len(trail)
                 color = tuple(int(c * alpha) for c in (255, 255, 255))
                 
@@ -226,7 +226,7 @@ class PoseVisualizer:
     
     def _draw_skeleton(self, frame: np.ndarray, pose: PoseResult, color: Tuple[int, int, int]):
         """Draw pose skeleton."""
-        print(f"[TRACE] _draw_skeleton()")
+        # print(f"[TRACE] _draw_skeleton()")
         h, w = frame.shape[:2]
         
         # Create keypoint lookup
@@ -251,10 +251,10 @@ class PoseVisualizer:
                     kp2 = kp_dict[name2]
                     
                     if math.isnan(kp1.x) or math.isnan(kp1.y) or math.isnan(kp2.x) or math.isnan(kp2.y):
-                        print(f"[DEBUG] _draw_skeleton: NaN detected in skeleton for keypoints {name1}, {name2}, skipping line.")
+                        # print(f"[DEBUG] _draw_skeleton: NaN detected in skeleton for keypoints {name1}, {name2}, skipping line.")
                         continue
                     
-                    print(f"[DEBUG] _draw_skeleton: Converting to int: ({kp1.x}*{w}, {kp1.y}*{h}) and ({kp2.x}*{w}, {kp2.y}*{h})")
+                    # print(f"[DEBUG] _draw_skeleton: Converting to int: ({kp1.x}*{w}, {kp1.y}*{h}) and ({kp2.x}*{w}, {kp2.y}*{h})")
                     # Convert to pixel coordinates
                     pt1 = (int(kp1.x * w), int(kp1.y * h))
                     pt2 = (int(kp2.x * w), int(kp2.y * h))
@@ -265,7 +265,7 @@ class PoseVisualizer:
     def _draw_keypoints(self, frame: np.ndarray, pose: PoseResult, 
                        metrics: Optional[MovementMetrics] = None):
         """Draw individual keypoints."""
-        print(f"[TRACE] _draw_keypoints()")
+        # print(f"[TRACE] _draw_keypoints()")
         h, w = frame.shape[:2]
         
         for kp in pose.keypoints:
@@ -273,10 +273,10 @@ class PoseVisualizer:
                 continue
             
             if math.isnan(kp.x) or math.isnan(kp.y):
-                print(f"[DEBUG] _draw_keypoints: NaN detected in keypoint {kp.name}, skipping.")
+                # print(f"[DEBUG] _draw_keypoints: NaN detected in keypoint {kp.name}, skipping.")
                 continue
             
-            print(f"[DEBUG] _draw_keypoints: Converting to int: ({kp.x}*{w}, {kp.y}*{h})")
+            # print(f"[DEBUG] _draw_keypoints: Converting to int: ({kp.x}*{w}, {kp.y}*{h})")
             # Convert to pixel coordinates
             pt = (int(kp.x * w), int(kp.y * h))
             
@@ -290,7 +290,7 @@ class PoseVisualizer:
     def _draw_direction_arrow(self, frame: np.ndarray, pose: PoseResult,
                              metrics: MovementMetrics):
         """Draw arrow indicating movement direction."""
-        print(f"[TRACE] _draw_direction_arrow()")
+        # print(f"[TRACE] _draw_direction_arrow()")
         if metrics.direction == Direction.STATIONARY:
             return
         
@@ -300,13 +300,13 @@ class PoseVisualizer:
         xs = [kp.x for kp in pose.keypoints if kp.confidence > 0.3 and not math.isnan(kp.x)]
         ys = [kp.y for kp in pose.keypoints if kp.confidence > 0.3 and not math.isnan(kp.y)]
         if not xs or not ys:
-            print(f"[DEBUG] _draw_direction_arrow: No valid keypoints for direction arrow, skipping.")
+            # print(f"[DEBUG] _draw_direction_arrow: No valid keypoints for direction arrow, skipping.")
             return
-        print(f"[DEBUG] _draw_direction_arrow: Converting to int: ({np.mean(xs)}*{w}, {np.mean(ys)}*{h})")
+        # print(f"[DEBUG] _draw_direction_arrow: Converting to int: ({np.mean(xs)}*{w}, {np.mean(ys)}*{h})")
         center_x = np.mean(xs)
         center_y = np.mean(ys)
         if math.isnan(center_x) or math.isnan(center_y):
-            print(f"[DEBUG] _draw_direction_arrow: NaN detected in center, skipping arrow.")
+            # print(f"[DEBUG] _draw_direction_arrow: NaN detected in center, skipping arrow.")
             return
         center = (int(center_x * w), int(center_y * h))
         
@@ -334,7 +334,7 @@ class PoseVisualizer:
     
     def _draw_metrics_overlay(self, frame: np.ndarray, metrics: MovementMetrics):
         """Draw text overlay with movement metrics."""
-        print(f"[TRACE] _draw_metrics_overlay()")
+        # print(f"[TRACE] _draw_metrics_overlay()")
         # Define text properties
         font = cv2.FONT_HERSHEY_SIMPLEX
         font_scale = 0.6
@@ -343,7 +343,7 @@ class PoseVisualizer:
         # Sanitize metrics
         def safe_metric(val, name):
             if isinstance(val, float) and math.isnan(val):
-                print(f"[DEBUG] _draw_metrics_overlay: {name} is NaN, replacing with 0.0")
+                # print(f"[DEBUG] _draw_metrics_overlay: {name} is NaN, replacing with 0.0")
                 return 0.0
             return val
 
@@ -381,7 +381,7 @@ class PoseVisualizer:
     
     def _get_color_for_metrics(self, metrics: Optional[MovementMetrics]) -> Tuple[int, int, int]:
         """Get color based on movement metrics."""
-        print(f"[TRACE] _get_color_for_metrics()")
+        # print(f"[TRACE] _get_color_for_metrics()")
         if metrics is None:
             return (255, 255, 255)  # White default
         
@@ -389,7 +389,7 @@ class PoseVisualizer:
     
     def _confidence_to_color(self, confidence: float) -> Tuple[int, int, int]:
         """Convert confidence score to color (green=high, red=low)."""
-        print(f"[TRACE] _confidence_to_color(confidence={confidence})")
+        # print(f"[TRACE] _confidence_to_color(confidence={confidence})")
         # Use HSV color space for smooth gradient
         hue = confidence * 120  # 0=red, 120=green
         rgb = colorsys.hsv_to_rgb(hue / 360, 1.0, 1.0)
@@ -397,7 +397,7 @@ class PoseVisualizer:
     
     def _get_skeleton_for_model(self, keypoints: List[Keypoint]) -> List[Tuple[int, int]]:
         """Determine which skeleton definition to use based on keypoints."""
-        print(f"[TRACE] _get_skeleton_for_model(num_keypoints={len(keypoints)})")
+        # print(f"[TRACE] _get_skeleton_for_model(num_keypoints={len(keypoints)})")
         # Simple heuristic: if we have more than 20 keypoints, use MediaPipe skeleton
         if len(keypoints) > 20:
             return self.MEDIAPIPE_SKELETON
@@ -405,7 +405,7 @@ class PoseVisualizer:
     
     def _get_keypoint_names_for_model(self, keypoints: List[Keypoint]) -> List[str]:
         """Get ordered list of keypoint names for the model."""
-        print(f"[TRACE] _get_keypoint_names_for_model(num_keypoints={len(keypoints)})")
+        # print(f"[TRACE] _get_keypoint_names_for_model(num_keypoints={len(keypoints)})")
         # If keypoints have names, use them
         if keypoints and keypoints[0].name:
             return [kp.name for kp in keypoints]