last dimas

README.md

@@ -19,7 +19,8 @@ gesture_rec/
 ├── skeleton/                    # Детекция скелета
 │   ├── oak_pose_detector.py     # Детектор на oak (efficienthrnet)
 │   └── mediapipe_detector.py    # MediaPipe
-├── gesture_control/             # Распознавание статичных жестов
+├── gesture_control/
+│   ├── arm_control.py           # Преобразование позы в значения для угловой и линейной скоростей
 │   └── special_gestures.py      # Специальные жесты (геометрия или ML)
 ├── ml_gestures/                 # ML для статичных жестов
 │   ├── feature_extractor.py     # Нормализация landmarks
@@ -51,17 +52,45 @@ cd gesture_rec
 git submodule update --init --recursive
 ```
 ### 2. Создание виртуального окружения
-Рекомендуется использовать виртуальное окружение:
+Рекомендуется использовать виртуальное окружение и Python 3.10:
 ```
-python3.11 -m venv venv
+python3.10 -m venv venv
 source venv/bin/activate
 ```
 
+Если у вас не скачен питон этой версии, сначала выполните:
+```
+sudo apt install python3.10 python3.10-venv
+```
+
+Если у нас не устанавливается питон 3.10, то это потому что он отсутствует в официальных репозиториях по умолчанию, надо добавить репозиторий перед скачиванием:
+```
+sudo apt update && sudo apt install -y software-properties-common
+sudo add-apt-repository ppa:deadsnakes/ppa
+sudo apt update
+```
+
+To install pip:
+
+    sudo apt install -y python3-pip
+
 ### 3. Установка зависимостей
 
+### 3.1. Способ 1
+
+Сделайте bash скрипт исполняемым и запустите последовательность установки:
+
+    chmod +x install_deps.sh
+    ./install_deps.sh
+    
+### 3.2. Способ 2
+
+Вручную:
+
     pip install --upgrade pip
     pip install numpy==1.24.3
     pip install pandas==2.0.3
+    pip install pyyaml
     pip install opencv-python==4.12.0.88
     pip install opencv-python-headless==4.12.0.88
     pip install matplotlib==3.7.5
@@ -91,6 +120,30 @@ source venv/bin/activate
         requests
     pip install numpy==1.24.3
     pip install scipy==1.11.0
+
+#### Типичные проблемы во время установки:
+Важно: красные предупреждения о нехватке зависимостей для tensorflow будут, но можно их игнорировать, т.к. эти модули не используются в данном проекте, а их установка мешает зависимостям MediaPipe.
+
+1. Если будет ошибка с `"AttributeError: google..."` но это потому что `tensorflow` подменяет версию библиотеки `protobuf`, выполните:
+```
+pip uninstall protobuf google protobuf
+pip install protobuf==3.20.3
+```
+Примечание: если у вас слабая видеокарта или нет CUDA, используйте `tensorflow-cpu` вместо `tensorflow`.
+
+2. Если будет проблема с функцией cv2.imshow() то, переустановите cv2 без заголовков:
+```
+pip uninstall opencv-python opencv-python-headless
+pip install opencv-python==4.12.0.88
+```
+3. Если будет ошибка с PIL, попробуйте обновить библиотеку:
+```
+pip upgrage pillow
+```
+4. **Внимание:** если вам пришлось делать после основной установки какие-то дополнительные, обязательно зафиксируйте еще раз версию numpy!
+```
+pip install numpy==1.24.3
+```
     
 ### 4. Проверка работы камеры
 Для веб-камеры достаточно, чтобы она была доступна по индексу (встроенная 0). Для OAK-D потребуется подключить устройство и установить права доступа (сделать это надо один раз):
@@ -160,7 +213,38 @@ vis = detector.draw_landmarks(frame, landmarks)
 
 Подробнее о параметрах модели в [репозитории](https://github.com/kschlegel/OAK-HumanPoseEstimation.git).
 
-### 1. Геометрическое распознавание жестов
+### 1. Определение значений скоростей
+По умолчанию преобразование позы в скорости реализовано в классе `ArmController` (файл `arm_control.py`).
+
+Чтобы изменить логику управления, выполните одно из действий:
+1. Изменить метод `compute_speeds` в `arm_control.py` – он должен принимать аргумент landmarks (список из 33 точек MediaPipe) и возвращать кортеж (linear, angular) – числа с плавающей точкой.
+2. Создать свой класс-наследник от `ArmController` и переопределить `compute_speeds`. Затем в `main.py` заменить создание экземпляра на свой класс.
+
+После этого не забудьте изменить параметры словаря `ARM_CONTROL`, вы можете добавлять туда свои поля и читать их в методе. Текущий класс создается и используется следующим образом:
+```
+from gesture_control.arm_control import ArmController
+
+mirror = True # для всех фронтальных камер
+ARM_CONTROL = {
+        'linear_arm': 'right',
+        'angular_arm': 'left',
+        'max_speed_linear': 1.0,
+        'max_speed_angular': 1.0,
+        'dead_zone': 0.2,
+        'debug': False
+    }
+arm_control = ArmController(ARM_CONTROL, mirror=mirror)
+linear, angular = arm_control.compute_speeds(landmarks) # Дальше эти скорости можно подавать на контроллер
+```
+- `ARM_CONTROL` – словарь:
+    - `linear_arm` – рука для линейной скорости ('left' или 'right')
+    - `angular_arm` – рука для угловой скорости
+    - `max_speed_linear` – макс. линейная скорость (м/с)
+    - `max_speed_angular` – макс. угловая скорость (рад/с)
+    - `dead_zone` – зона нечувствительности (0.0–1.0)
+    - `debug` – выводить отладочную информацию в консоль
+
+### 2. Геометрическое распознавание жестов
 Класс `SpecialGestureDetector` в режиме `mode='geometric'` анализирует координаты скелета и применяет набор правил.
 
 На текущий момент геометрически распознаются два жеста:
@@ -169,7 +253,7 @@ vis = detector.draw_landmarks(frame, landmarks)
 
 Все пороги (уверенность `min_conf`, коэффициенты) заданы внутри `_geometric_predict` и могут быть подстроены под ваши условия. Чтобы распознавать собственный жест, отредактируйте метод `_geometric_predict` в файле `gesture_control/special_gestures.py`.
 
-#### 1.1. Порядок действий:
+#### 2.1. Порядок действий:
 1. Определите, какие ключевые точки MediaPipe участвуют в жесте (список индексов см. в коде или в документации MediaPipe).
 2. Напишите условие, используя координаты `(x, y)` нужных точек. Например, жест «рука в сторону»: `left_wrist[0] > left_shoulder[0] + width` и `right_wrist[0] < right_shoulder[0] - width`.
 3. Вставьте проверку до финального return 'none', чтобы при совпадении условий возвращать строку с именем вашего жеста.
@@ -183,15 +267,15 @@ if arms_out:
 ```
 **Важно:** геометрический режим не требует обучения, но чувствителен к позе и ракурсу. Для более сложных жестов рекомендуем использовать ML.
 
-#### 1.2. Использование в коде:
+#### 2.2. Использование в коде:
 ```
 from gesture_control.special_gestures import SpecialGestureDetector
 detector = SpecialGestureDetector(mode='geometric')
 gesture = detector.predict(landmarks) # вернет none или название жеста
 ```
-### 2. ML-распознаванием статичных жестов
+### 3. ML-распознаванием статичных жестов
 Распознавание отдельных кадров с помощью обученного классификатора.
-#### 2.1. Сбор датасета
+#### 3.1. Сбор датасета
 Создай папку для изображений. Можешь поместить туда фотографии жестов из интернета. Либо же можешь самостоятельно снять изображения с камеры:
 Скрипт `utils/capture_photo.py` сохраняет изображения с камеры.
 ```
@@ -206,7 +290,7 @@ python3 utils/capture_photo.py --dir data/raw --camera_type web
 Управление: `s` – начать обратный отсчёт (3 сек) и сохранить фото, `q` – выход.
 Нажмите `s`, подождите 3 секунды, фото сохранится в папку `data/raw`. Нажмите `q` чтобы закончить.
 
-#### 2.2. Разметка
+#### 3.2. Разметка
 Скрипт `utils/annotate.py` показывает каждое фото с распознанным скелетом и позволяет назначить класс:
 ```
 python3 utils/annotate.py --folder data/raw --classes dome,cross,none --output data.csv
@@ -219,7 +303,7 @@ python3 utils/annotate.py --folder data/raw --classes dome,cross,none --output d
 
 Управление: для каждого фото нажмите цифру, соответствующую жесту (1–dome, 2–cross, 3–none), или `n` для пропуска или `q` – выйти. При выходе данные сохранятся в `gesture_data.csv`. CSV с колонками `class`, `f0…f98` (99 нормализованных координат).
 
-#### 2.3. Обучение модели
+#### 3.3. Обучение модели
 ```
 python3 ml_gestures/train.py --csv data.csv --model ml_gestures/models/special_model.pkl --type mlp --balance --target_classes dome,cross
 ```
@@ -234,7 +318,7 @@ python3 ml_gestures/train.py --csv data.csv --model ml_gestures/models/special_m
 
 После обучения сохраняются модель и отчёт `special_model_report.json` с метриками (accuracy, precision/recall/f1 по классам, матрица ошибок).
 
-#### 2.4. Оценка модели
+#### 3.4. Оценка модели
 После обучения модель сохраняется, и создаётся отчёт `special_model_report.json` с метриками (`accuracy`, `precision`, `recall`, `f1`, `confusion matrix`). Для повторной оценки используйте:
 ```
 python3 ml_gestures/evaluate.py --csv data.csv --model ml_gestures/models/special_model.pkl --test_size 0.2
@@ -246,7 +330,7 @@ python3 ml_gestures/evaluate.py --csv data.csv --model ml_gestures/models/specia
 
 Печатает результаты тестирования в консоль.
 
-#### 2.5. Использование обученной модели
+#### 3.5. Использование обученной модели
 ```
 from ml_gestures.predict import MLGesturePredictor
 
@@ -254,9 +338,9 @@ predictor = MLGesturePredictor('model.pkl', class_names=['dome','cross','none'])
 gesture = predictor.predict(landmarks)   # возвращает строку с классом
 ```
 
-### 3. ML-распознавание динамических жестов
+### 4. ML-распознавание динамических жестов
 Распознавание жестов по последовательности кадров с помощью LSTM.
-#### 3.1. Сбор датасета
+#### 4.1. Сбор датасета
 Скрипт `utils/record_dynamic.py` записывает серию кадров (скелет) в течение заданной длительности.
 ```
 python3 utils/record_dynamic --label wave_right --output dynamic_data.csv --duration 2.0
@@ -271,7 +355,7 @@ python3 utils/record_dynamic --label wave_right --output dynamic_data.csv --dura
 Управление: нажмите `space`, через 3 секунды начнется запись, последовательность точек с меткой сохранится в файл `dynamic_data.csv`. В CSV сохраняются колонки: `label`, `sequence_id`, `frame_idx`, `f0…f98`. Нажмите `q` чтобы закончить.
 
 **Важно**: при записи в консоль выводится число кадров последовательности – используйте его как ориентир для `--max_len` в обучении (можно округлить вверх).
-#### 3.2. Обучение LSTM
+#### 4.2. Обучение LSTM
 ```
 python3 ml_gestures_dynamic/train --data dynamic_data.csv --model dynamic_model.h5 --max_len 14 --epochs 50 --test_size 0.2
 ```
@@ -286,7 +370,7 @@ python3 ml_gestures_dynamic/train --data dynamic_data.csv --model dynamic_model.
 
 После обучения сохраняются: модель (`.h5`), файл с классами (`_classes.pkl`) и отчёт (`_report.json`) с метриками.
 
-#### 3.3. Оценка модели
+#### 4.3. Оценка модели
 После обучения модель сохраняется, и создаётся отчёт `dynamic_model_report.json` с метриками (`accuracy`, `precision`, `recall`, `f1`, `confusion matrix`). Для повторной оценки используйте:
 ```
 python3 ml_gestures_dynamic/evaluate --data dynamic_data.csv --model dynamic_model.h5 --max_len 14 --test_size 0.2
@@ -297,7 +381,7 @@ python3 ml_gestures_dynamic/evaluate --data dynamic_data.csv --model dynamic_mod
 - `--max_len` – длина последовательности (количество кадров). Должен совпадать с длиной, использованной при записи. Если последовательности короче, они дополняются нулями; если длиннее – обрезаются.
 - `--test_size` – доля тестовой выборки (по умолчанию 0.2).
 
-#### 3.4. Использование в коде
+#### 4.4. Использование в коде
 Класс `DynamicGesturePredictor` накапливает кадры в буфере и выдаёт предсказание, когда накоплено достаточно данных.
 ```
 from ml_gestures_dynamic.predict import DynamicGesturePredictor

gesture_control/arm_control.py

@@ -0,0 +1,148 @@
+import numpy as np
+
+class ArmController:
+    def __init__(self, config, mirror=False):
+        self.config = config
+        self.mirror = mirror
+        self.shoulder_idx = {'left': 11, 'right': 12}
+        self.wrist_idx = {'left': 15, 'right': 16}
+        self.hip_idx = {'left': 23, 'right': 24}
+        self.dead_zone = config.get('dead_zone', 0.2)
+        self.debug = config.get('debug', False)
+        
+    def _get_side_indices(self, side):
+        """
+        Возвращает (shoulder_idx, wrist_idx) для заданной стороны (left/right).
+        При mirror=True интерпретируем сторону как в реальности: левая/правая рука.
+        """
+        if self.mirror:
+            if side == 'left':
+                s_idx = 12
+                w_idx = 16
+            else:
+                s_idx = 11
+                w_idx = 15
+        else:
+            if side == 'left':
+                s_idx = 11
+                w_idx = 15
+            else:
+                s_idx = 12
+                w_idx = 16
+        return s_idx, w_idx
+
+    def _get_shoulder_width(self, landmarks):
+        """Ширина плеч для нормировки горизонтальных смещений."""
+        left = landmarks[11][:2]
+        right = landmarks[12][:2]
+        width = np.linalg.norm(right - left)
+        if width < 50 or width > 300:
+            return None
+        return width
+
+    def _get_torso_height(self, landmarks):
+        """Высота торса для нормировки вертикальных смещений."""
+        left_shoulder = landmarks[11][:2]
+        right_shoulder = landmarks[12][:2]
+        left_hip = landmarks[23][:2]
+        right_hip = landmarks[24][:2]
+        shoulder_center = (left_shoulder + right_shoulder) / 2
+        hip_center = (left_hip + right_hip) / 2
+        height = np.linalg.norm(shoulder_center - hip_center)
+        if height < 50:
+            return None
+        return height
+
+    def _horizontal_displacement_rel(self, landmarks, side):
+        """
+        Нормированное горизонтальное смещение запястья относительно плеча.
+        Сторона `side` — это реальная сторона руки
+        """
+        s_idx, w_idx = self._get_side_indices(side)
+
+        if landmarks[s_idx][3] < 0.5 or landmarks[w_idx][3] < 0.5:
+            return 0.0
+
+        shoulder = landmarks[s_idx][:2]
+        wrist = landmarks[w_idx][:2]
+
+        shoulder_width = self._get_shoulder_width(landmarks)
+        if shoulder_width is None:
+            return 0.0
+
+        disp = wrist[0] - shoulder[0]
+        return disp / shoulder_width
+
+    def _vertical_displacement_rel(self, landmarks, side):
+        """
+        Вертикальное смещение: верх/низ запястья относительно плеча.
+        Сторона `side` — реальная сторона руки.
+        """
+        s_idx, w_idx = self._get_side_indices(side)
+
+        if landmarks[s_idx][3] < 0.5 or landmarks[w_idx][3] < 0.5:
+            return 0.0
+
+        shoulder = landmarks[s_idx][:2]
+        wrist = landmarks[w_idx][:2]
+
+        torso_height = self._get_torso_height(landmarks)
+        if torso_height is None:
+            return 0.0
+
+        disp = shoulder[1] - wrist[1]
+        return disp / torso_height
+
+    '''
+    def compute_speeds(self, landmarks):
+        if (landmarks[11][3] < 0.5 or landmarks[12][3] < 0.5 or
+            landmarks[15][3] < 0.5 or landmarks[16][3] < 0.5):
+            if self.debug:
+                print("Руки не видны")
+            return 0.0, 0.0
+
+        linear_side = self.config['linear_arm']
+        angular_side = self.config['angular_arm']
+
+        lin_rel = self._horizontal_displacement_rel(landmarks, linear_side)
+        ang_rel = self._vertical_displacement_rel(landmarks, angular_side)
+
+        if self.debug:
+            print(f"lin_rel={lin_rel:.3f}, ang_rel={ang_rel:.3f}")
+
+        # Линейная скорость (только вперёд)
+        if lin_rel < self.dead_zone:
+            linear = 0.0
+        else:
+            linear = min(lin_rel, 1.0) * self.config['max_speed_linear']
+
+        # Угловая скорость
+        if abs(ang_rel) < self.dead_zone:
+            angular = 0.0
+        else:
+            ang_rel_clipped = np.clip(ang_rel, -1.0, 1.0)
+            angular = ang_rel_clipped * self.config['max_speed_angular']
+
+        return linear, angular
+    '''
+    def compute_speeds(self, w, h, landmarks):
+        linear = 0
+        angular = 0
+        if 3*w/5>landmarks[19][0]>2*w/5:
+            angular = 0
+        if 3*w/5<landmarks[19][0]:
+            angular = (landmarks[19][0]*5)/(2*w)-1
+        if landmarks[15][0]<2*w/5:
+            angular = (landmarks[19][0]-3*w/5)/(2*w/5)
+        if 3*h/5>landmarks[19][1]>2*h/5:
+            linear = 0
+        if 3*h/5<landmarks[19][1]:
+            linear = -((landmarks[19][1]*5)/(2*h)-1)
+        if landmarks[19][1]<2*h/5:
+            linear = -(landmarks[19][1]-3*h/5)/(2*h/5)
+
+
+
+        print(f"{linear},{angular}")
+        return linear, angular
+

gesture_control/special_gestures.py

@@ -1,10 +1,10 @@
 import numpy as np
-from ml_gestures.predict import MLGesturePredictor
 
 class SpecialGestureDetector:
     def __init__(self, mode='geometric', model_path=None, class_names=None):
         self.mode = mode
         if mode == 'ml':
+            from ml_gestures.predict import MLGesturePredictor
             if model_path is None or class_names is None:
                 raise ValueError("Для ML нужны model_path и class_names")
             self.ml_predictor = MLGesturePredictor(model_path, class_names)
@@ -54,7 +54,7 @@ class SpecialGestureDetector:
         l_hip = landmarks[idx['left_hip']][:2]
         r_hip = landmarks[idx['right_hip']][:2]
         nose = np.array(landmarks[idx['nose']][:2])
-        
+
         shoulder_center_y = (l_sh[1] + r_sh[1]) / 2
         hip_center_y = (l_hip[1] + r_hip[1]) / 2
         torso_height = hip_center_y - shoulder_center_y
@@ -74,11 +74,30 @@ class SpecialGestureDetector:
             v2 = wrist - elbow
             return angle_between_vectors(v1, v2)
 
+        def segments_intersect(p1, p2, p3, p4):
+            def cross(o, a, b):
+                return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o [1])* (b[0] - o[0])
+            d1 = cross(p3, p4, p1)
+            d2 = cross(p3, p4, p2)
+            d3 = cross(p1, p2, p3)
+            d4 = cross(p1, p2, p4)
+            return (d1 * d2 < 0) and (d3 * d4 < 0)
+
+        def line_intersection(p1, p2, p3, p4):
+            d1 = p2 - p1
+            d2 = p4 -p3
+            denom = d1[0] * d2[1] - d1[1] * d2[0]
+            if abs(denom) < 1e-6:
+                return None
+            t = ((p3[0] - p1[0]) * d2[1] - (p3[1] - p1[1]) * d2[0]) / denom
+            return p1 + t * d1
+
         # ---- Вычисляем углы ----
         l_angle = elbow_angle(l_sh, l_el, l_wr)   # угол в левом локте
         r_angle = elbow_angle(r_sh, r_el, r_wr)   # угол в правом локте
 
         # ---- КРЕСТ ----
+        '''
         # 1. Оба локтя сильно согнуты (< 100°)
         elbows_bent = (l_angle < 100 and r_angle < 100)
         # 2. Левое запястье правее правого (перекрест)
@@ -90,6 +109,15 @@ class SpecialGestureDetector:
         )
 
         cross = elbows_bent and wrists_crossed and wrists_at_chest
+        if cross:
+            return 'cross'
+        '''
+        forearms_cross = segments_intersect(l_el, l_wr, r_el, r_wr)
+        intersection = line_intersection(l_el, l_wr, r_el, r_wr)
+        intersection_on_chest = False
+        if intersection is not None:
+            intersection_on_chest = (shoulder_center_y - 0.2 * torso_height < intersection[1] < hip_center_y + 0.2 * torso_height)
+        cross = forearms_cross and intersection_on_chest
         if cross:
             return 'cross'
 

install_deps.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+set -e
+
+pip install --upgrade pip
+
+pip install numpy==1.24.3
+pip install pandas==2.0.3
+pip install pyyaml==6.0.3
+pip install opencv-python==4.12.0.88
+pip install opencv-python-headless==4.12.0.88
+pip install matplotlib==3.7.5
+pip install protobuf==3.20.3
+
+# PyTorch CPU - нужен только для tensorflow, достаточно под CPU в целом, но можно поставить GPU, но тогда возиться с CUDA
+pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu
+
+# MediaPipe
+pip install --no-deps mediapipe==0.10.11
+pip install attrs
+
+pip install scikit-learn==1.3.2
+pip install joblib==1.4.2
+pip install depthai==2.28.0
+
+# TensorFlow
+pip install --no-deps tensorflow==2.13.1
+
+pip install \
+    absl-py \
+    astunparse \
+    flatbuffers \
+    gast \
+    google-pasta \
+    grpcio \
+    h5py \
+    keras==2.13.1 \
+    libclang \
+    opt-einsum \
+    tensorboard==2.13.0 \
+    tensorflow-estimator==2.13.0 \
+    termcolor \
+    wrapt \
+    requests
+    
+pip install numpy==1.24.3
+pip install scipy==1.11.0
+
+echo "все установлено"