swastikbansal commited on
Commit
c7265b1
·
verified ·
1 Parent(s): 4846423

Reverted to utils to func without rest

Browse files
Files changed (1) hide show
  1. utils.py +6 -136
utils.py CHANGED
@@ -1,147 +1,17 @@
 
 
 
1
  import numpy as np
2
- import time
3
 
4
  class Utils:
5
- def __init__(self, axes, restSpeed, minPoints, requiredFrames):
6
  self.axes = axes
7
- self.REST_SPEED_THRESHOLD = restSpeed # pixels/second
8
- self.MIN_POINTS_FOR_REST = minPoints
9
- self.REQUIRED_CONSECUTIVE_FRAMES = requiredFrames
10
-
11
- self.rest_buffer_frame = 0
12
- # persistent state used across consecutive calls to is_resting
13
- self.prev_positions = {
14
- "positions": {}, # dict e.g. {"left_wrist": np.array([...]), ...}
15
- "timestamp": None,
16
- "counters": { # consecutive low-speed frame counters per key
17
- "left_wrist": 0,
18
- "right_wrist": 0,
19
- "left_shoulder": 0,
20
- "right_shoulder": 0
21
- },
22
- "rest_start_time": None
23
- }
24
-
25
- def _landmark_to_pixel(self, landmark, img_shape):
26
- """Convert normalized landmark to pixel (x,y)."""
27
- h, w = img_shape[0], img_shape[1]
28
- return np.array([landmark.x * w, landmark.y * h], dtype=float)
29
-
30
- # Replace previous is_resting with time-based version
31
- def is_resting(self, res_hands, img_shape, rest_delay_seconds: float = 2.0, fps: float = None):
32
- """
33
- Time-based rest detection.
34
- Returns True if average landmark speed stays below REST_SPEED_THRESHOLD
35
- for at least rest_delay_seconds.
36
- """
37
- current_time = time.time()
38
- points = {}
39
-
40
- # Hands: get wrist landmark (index 0) if available
41
- if getattr(res_hands, "multi_hand_landmarks", None) and getattr(res_hands, "multi_handedness", None):
42
- for hand_landmarks, handedness in zip(res_hands.multi_hand_landmarks, res_hands.multi_handedness):
43
- label = handedness.classification[0].label
44
- try:
45
- wrist = self._landmark_to_pixel(hand_landmarks.landmark[0], img_shape)
46
- except Exception:
47
- continue
48
-
49
- if label == 'Left':
50
- points['left_wrist'] = wrist
51
- elif label == 'Right':
52
- points['right_wrist'] = wrist
53
-
54
- # Initialize previous timestamp if missing
55
- if self.prev_positions['timestamp'] is None:
56
- self.prev_positions['timestamp'] = current_time
57
- self.prev_positions['positions'].update({k: v for k, v in points.items()})
58
- self.prev_positions['rest_start_time'] = None
59
- return False
60
-
61
- # No landmarks detected -> not resting (reset)
62
- if len(points) < 1:
63
- self.prev_positions['timestamp'] = current_time
64
- self.prev_positions['positions'].update({k: v for k, v in points.items()})
65
- self.prev_positions['rest_start_time'] = None
66
- # reset counters for keys that are missing
67
- for k in self.prev_positions['counters']:
68
- if k not in points:
69
- self.prev_positions['counters'][k] = 0
70
- return False
71
-
72
- dt = current_time - self.prev_positions['timestamp']
73
- if dt <= 0:
74
- self.prev_positions['timestamp'] = current_time
75
- self.prev_positions['positions'].update({k: v for k, v in points.items()})
76
- self.prev_positions['rest_start_time'] = None
77
- return False
78
-
79
- speeds = []
80
- speed_map = {}
81
-
82
- # compute speeds only where previous positions exist
83
- for key, cur_pos in points.items():
84
- prev_pos = self.prev_positions['positions'].get(key)
85
- if prev_pos is not None:
86
- dist = np.linalg.norm(cur_pos - prev_pos)
87
- speed = dist / dt
88
- speeds.append(speed)
89
- speed_map[key] = speed
90
-
91
- # update timestamp and previous positions for next call
92
- self.prev_positions['timestamp'] = current_time
93
- self.prev_positions['positions'].update({k: v for k, v in points.items()})
94
-
95
- # reset counters for disappeared landmarks
96
- for k in list(self.prev_positions['counters'].keys()):
97
- if k not in speed_map:
98
- self.prev_positions['counters'][k] = 0
99
-
100
- # Optionally scale threshold for very low FPS if fps provided
101
- adjusted_threshold = self.REST_SPEED_THRESHOLD
102
- if fps is not None and fps > 0:
103
- adjusted_threshold = self.REST_SPEED_THRESHOLD * (30.0 / max(fps, 1.0))
104
-
105
- # Using avg speed to detect on enough landmarks
106
- if len(speeds) >= self.MIN_POINTS_FOR_REST:
107
- avg_speed = float(np.mean(speeds))
108
- if avg_speed < adjusted_threshold:
109
- if self.prev_positions['rest_start_time'] is None:
110
- self.prev_positions['rest_start_time'] = current_time
111
- # Check duration
112
- if (current_time - self.prev_positions['rest_start_time']) >= rest_delay_seconds:
113
- return True
114
- else:
115
- # Reset rest tracking if movement detected
116
- self.prev_positions['rest_start_time'] = None
117
- for k in self.prev_positions['counters']:
118
- self.prev_positions['counters'][k] = 0
119
- return False
120
-
121
- # Single landmark case: treat similarly
122
- if len(speeds) == 1:
123
- key = next(iter(speed_map))
124
- speed = speed_map[key]
125
- if speed < adjusted_threshold:
126
- if self.prev_positions['rest_start_time'] is None:
127
- self.prev_positions['rest_start_time'] = current_time
128
- if (current_time - self.prev_positions['rest_start_time']) >= rest_delay_seconds:
129
- return True
130
- else:
131
- self.prev_positions['rest_start_time'] = None
132
- self.prev_positions['counters'][key] = 0
133
- return False
134
-
135
- # default
136
- self.prev_positions['rest_start_time'] = None
137
- return False
138
-
139
-
140
  def calculate_angle1(self, vec1, vec2):
141
  dot_product = np.dot(vec1, vec2)
142
  norm_vec1 = np.linalg.norm(vec1)
143
  norm_vec2 = np.linalg.norm(vec2)
144
- self.cosine_angle = dot_product / (norm_vec1 * norm_vec2) if norm_vec1 and norm_vec2 else 0
145
  return self.cosine_angle
146
 
147
  def get_coordinates_safe(self, landmark, index):
 
1
+ import cv2
2
+ import mediapipe as mp
3
+ import pickle
4
  import numpy as np
 
5
 
6
  class Utils:
7
+ def __init__(self, axes):
8
  self.axes = axes
9
+
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
10
  def calculate_angle1(self, vec1, vec2):
11
  dot_product = np.dot(vec1, vec2)
12
  norm_vec1 = np.linalg.norm(vec1)
13
  norm_vec2 = np.linalg.norm(vec2)
14
+ self.cosine_angle = dot_product / (norm_vec1 * norm_vec2)
15
  return self.cosine_angle
16
 
17
  def get_coordinates_safe(self, landmark, index):