problem with fps

.gitignore

@@ -3,3 +3,4 @@ __pycache__/
 *.pyo
 *.pyd
 .env
+venv/

README.md

@@ -73,7 +73,7 @@ python3 main.py
 ```
 3. Запустится симулятор и изображение с камеры
 
-#### Запуск с ML-распознаванием специальных жестов
+#### Запуск с ML-распознаванием статических жестов
 1. Соберите датасет с нужными изображениями фото. Можете заснять собственные через `utils/capture_photo.py`:
 ```
 python3 -m utils/capture_photo.py --dir data/raw
@@ -109,6 +109,36 @@ python3 main.py
 ```
 7. Запустится симулятор и изображение с камеры
 
+#### Запуск с ML-распознаванием динамических жестов
+1. Соберите датасетс нужными последовательностями жестов.
+```
+python -m utils.record_dynamic --label wave_right --output dynamic_data.csv --duration 2.0
+```
+Нажмите `space`, подождите 3 секунды, последовательность точек с меткой сохранится в файл `dynamic_data.csv`. Нажмите `q` чтобы закончить.
+2. Обучите модель
+```
+python -m ml_gestures_dynamic.train --data dynamic_data.csv --model dynamic_model.h5 --max_len 14 --epochs 50 --test_size 0.2
+```
+Укажите путь до вашего файла, укажите путь, куда сохранить модель, а также укажите длину последовательности кадров (зависит от вашей камеры и железа, будет выводится при сборе данных)
+3. Оценка модели
+После обучения модель сохраняется, и создаётся отчёт `dynamic_model_report.json` с метриками (`accuracy`, `precision`, `recall`, `f1`, `confusion matrix`). Для повторной оценки используйте:
+```
+python -m ml_gestures_dynamic.evaluate --data dynamic_data.csv --model dynamic_model.h5 --max_len 14 --test_size 0.2
+```
+5. Подключить модель в `config.py`
+```
+DYNAMIC_GESTURE = {
+        'enabled': True,                     # включить/выключить
+        'model_path': 'ml_gestures/models/dynamic_model.h5',
+        'classes_path': 'ml_gestures//odels/dynamic_model_classes.pkl',
+        'window_size': 14,                   # длина буфера
+        'threshold': 0.7,                   # порог уверенности
+        'actions': {
+            'wave_left': 'reset',            # при жесте wave_left – перезапуск симулятора
+            'wave_right': 'restart',         # при wave_right – рестарт
+        }
+```
+
 ### Управление в симуляторе
 Симулятор – поле с препятствиями, стартом и финишем. Робот движется согласно командам. При столкновении – игра заканчивается (перезапуск по `r`). Закрытие окна игры или нажатие `q` в окне камеры – выход.
 1. Управление скоростями

config.py

@@ -18,6 +18,17 @@ class Config:
     SPECIAL_GESTURE_MODE = 'ml' #ml #geometric
     ML_GESTURE_MODEL = '/home/ubuntu/sirius/models/rf/special_model.pkl'
     ML_GESTURE_CLASSES = ['dome', 'cross', 'none']
+    
+    DYNAMIC_GESTURE = {
+        'enabled': True,                     # включить/выключить
+        'model_path': 'dynamic_model.h5',
+        'classes_path': 'dynamic_model_classes.pkl',
+        'window_size': 14,                   # длина буфера
+        'threshold': 0.7,                    # порог уверенности
+        'actions': {
+            'wave_left': 'reset',            # при жесте wave_left – перезапуск симулятора
+            'wave_right': 'restart',         # при wave_right – рестарт
+        }
 
     # ===== Робот =====
     ROBOT_MODE = 'simulator'

main.py

@@ -23,7 +23,17 @@ def main():
         model_path=cfg.ML_GESTURE_MODEL,
         class_names=cfg.ML_GESTURE_CLASSES
     )
-
+    
+    # Динамические жесты
+    if cfg.DYNAMIC_GESTURE['enabled']:
+        from ml_gestures_dynamic.predict import DynamicGesturePredictor
+        dynamic_predictor = DynamicGesturePredictor(
+            cfg.DYNAMIC_GESTURE['model_path'],
+            cfg.DYNAMIC_GESTURE['classes_path'],
+            cfg.DYNAMIC_GESTURE['window_size'],
+            cfg.DYNAMIC_GESTURE['threshold']
+        )
+        
     # Управление скоростями
     arm_control = ArmController(cfg.ARM_CONTROL, mirror=cfg.MIRROR_CAMERA)
 
@@ -56,6 +66,18 @@ def main():
 
         if result['success']:
             landmarks = result['landmarks']
+            
+            if result['success']:
+                if cfg.DYNAMIC_GESTURE['enabled']:
+                    dynamic_predictor.add_frame(landmarks)
+                    gesture = dynamic_predictor.predict()
+                    if gesture:
+                        action = cfg.DYNAMIC_GESTURE['actions'].get(gesture)
+                        if action == 'reset':
+                            robot.reset()
+                        elif action == 'restart':
+                            robot.reset()
+                
             vis_frame = detector.draw_landmarks(frame, result['pose_landmarks'])
 
             special = special_detector.predict(landmarks)

ml_gestures_dynamic/sequence_utils.py

@@ -19,7 +19,7 @@ def load_sequences_from_csv(csv_path, max_len=30, test_size=0.2, random_state=42
 
     sequences = {}
     for seq_id, group in df.groupby('sequence_id'):
-        group = group.sort_values('frame')
+        group = group.sort_values('frame_idx')
         label = group['label'].iloc[0]
         features = group[[f'f{i}' for i in range(99)]].values
         # Обрезаем или падинг

utils/record_dynamic.py

@@ -5,10 +5,11 @@ import sys
 import time
 from pathlib import Path
 import argparse
+import pandas as pd
 
 sys.path.append(str(Path(__file__).parent.parent))
 from skeleton.mediapipe_detector import MediaPipeDetector
-from ml_gestures.dynamic.feature_extractor import extract_sequence
+from ml_gestures_dynamic.feature_extractor import extract_sequence
 
 def main():
     parser = argparse.ArgumentParser()
@@ -17,6 +18,15 @@ def main():
     parser.add_argument('--camera', type=int, default=0)
     parser.add_argument('--duration', type=float, default=3.0, help='Длительность записи (сек)')
     args = parser.parse_args()
+    
+    output_path = Path(args.output)
+    
+    # Создаём файл с заголовком, если его ещё нет
+    if not output_path.exists():
+        with open(output_path, 'w', newline='') as f:
+            writer = csv.writer(f)
+            header = ['label', 'sequence_id', 'frame_idx'] + [f'f{i}' for i in range(99)]
+            writer.writerow(header)
 
     detector = MediaPipeDetector()
     cap = cv2.VideoCapture(args.camera)
@@ -26,8 +36,7 @@ def main():
 
     # Определяем следующий ID последовательности
     try:
-        import pandas as pd
+        df = pd.read_csv(output_path)
-        df = pd.read_csv(args.output)
         next_id = df['sequence_id'].max() + 1 if not df.empty else 0
     except:
         next_id = 0
@@ -46,27 +55,30 @@ def main():
         if result['success']:
             landmarks = result['landmarks']
             vis = detector.draw_landmarks(frame, result['pose_landmarks'])
-            if recording:
-                sequence.append(landmarks)
-                elapsed = time.time() - start_time
-                if elapsed >= args.duration:
-                    recording = False
-                    # Сохраняем последовательность
-                    seq_features = extract_sequence(sequence)
-                    with open(args.output, 'a', newline='') as f:
-                        writer = csv.writer(f)
-                        for i, feat in enumerate(seq_features):
-                            writer.writerow([args.label, next_id, i] + feat.tolist())
-                    print(f"Сохранено {len(sequence)} кадров для жеста {args.label}, ID={next_id}")
-                    sequence = []
-                    next_id += 1
         else:
             vis = frame
+            landmarks = None
 
+        # Если мы в режиме записи
         if recording:
+            if landmarks is not None:
+                sequence.append(landmarks)
+            elapsed = time.time() - start_time
+            # Отображаем прогресс записи
             cv2.putText(vis, f"RECORDING... {elapsed:.1f}/{args.duration}", (10, 30),
                         cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0,0,255), 2)
+            if elapsed >= args.duration:
+                recording = False
+                seq_features = extract_sequence(sequence)
+                with open(output_path, 'a', newline='') as f:
+                    writer = csv.writer(f)
+                    for i, feat in enumerate(seq_features):
+                        writer.writerow([args.label, next_id, i] + feat.tolist())
+                print(f"Сохранено {len(sequence)} кадров для жеста {args.label}, ID={next_id}")
+                sequence = []
+                next_id += 1
         else:
+            # Ожидание нажатия пробела
             cv2.putText(vis, f"Press SPACE to record '{args.label}'", (10, 30),
                         cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0,255,0), 2)
 
@@ -75,6 +87,36 @@ def main():
         if key == ord('q'):
             break
         if key == ord(' ') and not recording:
+            # Обратный отсчёт на живом видео
+            for i in range(3, 0, -1):
+                # Получаем свежий кадр для отсчёта
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                frame = cv2.flip(frame, 1)
+                result = detector.detect(frame)
+                if result['success']:
+                    vis = detector.draw_landmarks(frame, result['pose_landmarks'])
+                else:
+                    vis = frame
+                cv2.putText(vis, f"Starting in {i}...", (frame.shape[1]//2-100, frame.shape[0]//2),
+                            cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0,0,255), 3)
+                cv2.imshow('Record dynamic gesture', vis)
+                cv2.waitKey(1000)
+            # Показываем "GO!"
+            ret, frame = cap.read()
+            if ret:
+                frame = cv2.flip(frame, 1)
+                result = detector.detect(frame)
+                if result['success']:
+                    vis = detector.draw_landmarks(frame, result['pose_landmarks'])
+                else:
+                    vis = frame
+                cv2.putText(vis, "GO!", (frame.shape[1]//2-50, frame.shape[0]//2),
+                            cv2.FONT_HERSHEY_SIMPLEX, 2, (0,255,0), 3)
+                cv2.imshow('Record dynamic gesture', vis)
+                cv2.waitKey(500)
+            # Начинаем запись
             recording = True
             start_time = time.time()
             sequence = []