Upload 35 files

PoseClassification/bootstrap.py

@@ -0,0 +1,242 @@
+import cv2
+from matplotlib import pyplot as plt
+import numpy as np
+import os, csv
+from PIL import Image, ImageDraw
+import sys
+import tqdm
+
+from mediapipe.python.solutions import drawing_utils as mp_drawing
+from mediapipe.python.solutions import pose as mp_pose
+
+from PoseClassification.utils import show_image
+
+class BootstrapHelper(object):
+    """Helps to bootstrap images and filter pose samples for classification."""
+
+    def __init__(self, images_in_folder, images_out_folder, csvs_out_folder):
+        self._images_in_folder = images_in_folder
+        self._images_out_folder = images_out_folder
+        self._csvs_out_folder = csvs_out_folder
+
+        # Get list of pose classes and print image statistics.
+        self._pose_class_names = sorted(
+            [n for n in os.listdir(self._images_in_folder) if not n.startswith(".")]
+        )
+
+    def bootstrap(self, per_pose_class_limit=None):
+        """Bootstraps images in a given folder.
+
+        Required image in folder (same use for image out folder):
+          pushups_up/
+            image_001.jpg
+            image_002.jpg
+            ...
+          pushups_down/
+            image_001.jpg
+            image_002.jpg
+            ...
+          ...
+
+        Produced CSVs out folder:
+          pushups_up.csv
+          pushups_down.csv
+
+        Produced CSV structure with pose 3D landmarks:
+          sample_00001,x1,y1,z1,x2,y2,z2,....
+          sample_00002,x1,y1,z1,x2,y2,z2,....
+        """
+        # Create output folder for CVSs.
+        if not os.path.exists(self._csvs_out_folder):
+            os.makedirs(self._csvs_out_folder)
+
+        for pose_class_name in self._pose_class_names:
+            print("Bootstrapping ", pose_class_name, file=sys.stderr)
+
+            # Paths for the pose class.
+            images_in_folder = os.path.join(self._images_in_folder, pose_class_name)
+            images_out_folder = os.path.join(self._images_out_folder, pose_class_name)
+            csv_out_path = os.path.join(self._csvs_out_folder, pose_class_name + ".csv")
+            if not os.path.exists(images_out_folder):
+                os.makedirs(images_out_folder)
+
+            with open(csv_out_path, "w") as csv_out_file:
+                csv_out_writer = csv.writer(
+                    csv_out_file, delimiter=",", quoting=csv.QUOTE_MINIMAL
+                )
+                # Get list of images.
+                image_names = sorted(
+                    [n for n in os.listdir(images_in_folder) if not n.startswith(".")]
+                )
+                if per_pose_class_limit is not None:
+                    image_names = image_names[:per_pose_class_limit]
+
+                # Bootstrap every image.
+                for image_name in tqdm.tqdm(image_names):
+                    # Load image.
+                    input_frame = cv2.imread(os.path.join(images_in_folder, image_name))
+                    input_frame = cv2.cvtColor(input_frame, cv2.COLOR_BGR2RGB)
+
+                    # Initialize fresh pose tracker and run it.
+                    # with mp_pose.Pose(upper_body_only=False) as pose_tracker:
+                    with mp_pose.Pose() as pose_tracker:
+                        result = pose_tracker.process(image=input_frame)
+                        pose_landmarks = result.pose_landmarks
+
+                    # Save image with pose prediction (if pose was detected).
+                    output_frame = input_frame.copy()
+                    if pose_landmarks is not None:
+                        mp_drawing.draw_landmarks(
+                            image=output_frame,
+                            landmark_list=pose_landmarks,
+                            connections=mp_pose.POSE_CONNECTIONS,
+                        )
+                    output_frame = cv2.cvtColor(output_frame, cv2.COLOR_RGB2BGR)
+                    cv2.imwrite(
+                        os.path.join(images_out_folder, image_name), output_frame
+                    )
+
+                    # Save landmarks if pose was detected.
+                    if pose_landmarks is not None:
+                        # Get landmarks.
+                        frame_height, frame_width = (
+                            output_frame.shape[0],
+                            output_frame.shape[1],
+                        )
+                        pose_landmarks = np.array(
+                            [
+                                [
+                                    lmk.x * frame_width,
+                                    lmk.y * frame_height,
+                                    lmk.z * frame_width,
+                                ]
+                                for lmk in pose_landmarks.landmark
+                            ],
+                            dtype=np.float32,
+                        )
+                        assert pose_landmarks.shape == (
+                            33,
+                            3,
+                        ), "Unexpected landmarks shape: {}".format(pose_landmarks.shape)
+                        csv_out_writer.writerow(
+                            [image_name] + pose_landmarks.flatten().astype(str).tolist()
+                        )
+
+                    # Draw XZ projection and concatenate with the image.
+                    projection_xz = self._draw_xz_projection(
+                        output_frame=output_frame, pose_landmarks=pose_landmarks
+                    )
+                    output_frame = np.concatenate((output_frame, projection_xz), axis=1)
+
+    def _draw_xz_projection(self, output_frame, pose_landmarks, r=0.5, color="red"):
+        frame_height, frame_width = output_frame.shape[0], output_frame.shape[1]
+        img = Image.new("RGB", (frame_width, frame_height), color="white")
+
+        if pose_landmarks is None:
+            return np.asarray(img)
+
+        # Scale radius according to the image width.
+        r *= frame_width * 0.01
+
+        draw = ImageDraw.Draw(img)
+        for idx_1, idx_2 in mp_pose.POSE_CONNECTIONS:
+            # Flip Z and move hips center to the center of the image.
+            x1, y1, z1 = pose_landmarks[idx_1] * [1, 1, -1] + [0, 0, frame_height * 0.5]
+            x2, y2, z2 = pose_landmarks[idx_2] * [1, 1, -1] + [0, 0, frame_height * 0.5]
+
+            draw.ellipse([x1 - r, z1 - r, x1 + r, z1 + r], fill=color)
+            draw.ellipse([x2 - r, z2 - r, x2 + r, z2 + r], fill=color)
+            draw.line([x1, z1, x2, z2], width=int(r), fill=color)
+
+        return np.asarray(img)
+
+    def align_images_and_csvs(self, print_removed_items=False):
+        """Makes sure that image folders and CSVs have the same sample.
+
+        Leaves only intersetion of samples in both image folders and CSVs.
+        """
+        for pose_class_name in self._pose_class_names:
+            # Paths for the pose class.
+            images_out_folder = os.path.join(self._images_out_folder, pose_class_name)
+            csv_out_path = os.path.join(self._csvs_out_folder, pose_class_name + ".csv")
+
+            # Read CSV into memory.
+            rows = []
+            with open(csv_out_path) as csv_out_file:
+                csv_out_reader = csv.reader(csv_out_file, delimiter=",")
+                for row in csv_out_reader:
+                    rows.append(row)
+
+            # Image names left in CSV.
+            image_names_in_csv = []
+
+            # Re-write the CSV removing lines without corresponding images.
+            with open(csv_out_path, "w") as csv_out_file:
+                csv_out_writer = csv.writer(
+                    csv_out_file, delimiter=",", quoting=csv.QUOTE_MINIMAL
+                )
+                for row in rows:
+                    image_name = row[0]
+                    image_path = os.path.join(images_out_folder, image_name)
+                    if os.path.exists(image_path):
+                        image_names_in_csv.append(image_name)
+                        csv_out_writer.writerow(row)
+                    elif print_removed_items:
+                        print("Removed image from CSV: ", image_path)
+
+            # Remove images without corresponding line in CSV.
+            for image_name in os.listdir(images_out_folder):
+                if image_name not in image_names_in_csv:
+                    image_path = os.path.join(images_out_folder, image_name)
+                    os.remove(image_path)
+                    if print_removed_items:
+                        print("Removed image from folder: ", image_path)
+
+    def analyze_outliers(self, outliers):
+        """Classifies each sample against all other to find outliers.
+
+        If sample is classified differrently than the original class - it should
+        either be deleted or more similar samples should be added.
+        """
+        for outlier in outliers:
+            image_path = os.path.join(
+                self._images_out_folder, outlier.sample.class_name, outlier.sample.name
+            )
+
+            print("Outlier")
+            print("  sample path =    ", image_path)
+            print("  sample class =   ", outlier.sample.class_name)
+            print("  detected class = ", outlier.detected_class)
+            print("  all classes =    ", outlier.all_classes)
+
+            img = cv2.imread(image_path)
+            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+            show_image(img, figsize=(20, 20))
+
+    def remove_outliers(self, outliers):
+        """Removes outliers from the image folders."""
+        for outlier in outliers:
+            image_path = os.path.join(
+                self._images_out_folder, outlier.sample.class_name, outlier.sample.name
+            )
+            os.remove(image_path)
+
+    def print_images_in_statistics(self):
+        """Prints statistics from the input image folder."""
+        self._print_images_statistics(self._images_in_folder, self._pose_class_names)
+
+    def print_images_out_statistics(self):
+        """Prints statistics from the output image folder."""
+        self._print_images_statistics(self._images_out_folder, self._pose_class_names)
+
+    def _print_images_statistics(self, images_folder, pose_class_names):
+        print("Number of images per pose class:")
+        for pose_class_name in pose_class_names:
+            n_images = len(
+                [
+                    n
+                    for n in os.listdir(os.path.join(images_folder, pose_class_name))
+                    if not n.startswith(".")
+                ]
+            )
+            print("  {}: {}".format(pose_class_name, n_images))

PoseClassification/pose_classifier.py

@@ -0,0 +1,208 @@
+import numpy as np
+import os, csv
+
+
+class PoseSample(object):
+    def __init__(self, name, landmarks, class_name, embedding):
+        self.name = name
+        self.landmarks = landmarks
+        self.class_name = class_name
+        self.embedding = embedding
+
+
+class PoseSampleOutlier(object):
+    def __init__(self, sample, detected_class, all_classes):
+        self.sample = sample
+        self.detected_class = detected_class
+        self.all_classes = all_classes
+
+
+class PoseClassifier(object):
+    """Classifies pose landmarks."""
+
+    def __init__(
+        self,
+        pose_samples_folder,
+        pose_embedder,
+        file_extension="csv",
+        file_separator=",",
+        n_landmarks=33,
+        n_dimensions=3,
+        top_n_by_max_distance=30,
+        top_n_by_mean_distance=10,
+        axes_weights=(1.0, 1.0, 0.2),
+    ):
+        self._pose_embedder = pose_embedder
+        self._n_landmarks = n_landmarks
+        self._n_dimensions = n_dimensions
+        self._top_n_by_max_distance = top_n_by_max_distance
+        self._top_n_by_mean_distance = top_n_by_mean_distance
+        self._axes_weights = axes_weights
+
+        self._pose_samples = self._load_pose_samples(
+            pose_samples_folder,
+            file_extension,
+            file_separator,
+            n_landmarks,
+            n_dimensions,
+            pose_embedder,
+        )
+
+    def _load_pose_samples(
+        self,
+        pose_samples_folder,
+        file_extension,
+        file_separator,
+        n_landmarks,
+        n_dimensions,
+        pose_embedder,
+    ):
+        """Loads pose samples from a given folder.
+
+        Required folder structure:
+          neutral_standing.csv
+          pushups_down.csv
+          pushups_up.csv
+          squats_down.csv
+          ...
+
+        Required CSV structure:
+          sample_00001,x1,y1,z1,x2,y2,z2,....
+          sample_00002,x1,y1,z1,x2,y2,z2,....
+          ...
+        """
+        # Each file in the folder represents one pose class.
+        file_names = [
+            name
+            for name in os.listdir(pose_samples_folder)
+            if name.endswith(file_extension)
+        ]
+
+        pose_samples = []
+        for file_name in file_names:
+            # Use file name as pose class name.
+            class_name = file_name[: -(len(file_extension) + 1)]
+
+            # Parse CSV.
+            with open(os.path.join(pose_samples_folder, file_name)) as csv_file:
+                csv_reader = csv.reader(csv_file, delimiter=file_separator)
+                for row in csv_reader:
+                    assert (
+                        len(row) == n_landmarks * n_dimensions + 1
+                    ), "Wrong number of values: {}".format(len(row))
+                    landmarks = np.array(row[1:], np.float32).reshape(
+                        [n_landmarks, n_dimensions]
+                    )
+                    pose_samples.append(
+                        PoseSample(
+                            name=row[0],
+                            landmarks=landmarks,
+                            class_name=class_name,
+                            embedding=pose_embedder(landmarks),
+                        )
+                    )
+
+        return pose_samples
+
+    def find_pose_sample_outliers(self):
+        """Classifies each sample against the entire database."""
+        # Find outliers in target poses
+        outliers = []
+        for sample in self._pose_samples:
+            # Find nearest poses for the target one.
+            pose_landmarks = sample.landmarks.copy()
+            pose_classification = self.__call__(pose_landmarks)
+            class_names = [
+                class_name
+                for class_name, count in pose_classification.items()
+                if count == max(pose_classification.values())
+            ]
+
+            # Sample is an outlier if nearest poses have different class or more than
+            # one pose class is detected as nearest.
+            if sample.class_name not in class_names or len(class_names) != 1:
+                outliers.append(
+                    PoseSampleOutlier(sample, class_names, pose_classification)
+                )
+
+        return outliers
+
+    def __call__(self, pose_landmarks):
+        """Classifies given pose.
+
+        Classification is done in two stages:
+          * First we pick top-N samples by MAX distance. It allows to remove samples
+            that are almost the same as given pose, but has few joints bent in the
+            other direction.
+          * Then we pick top-N samples by MEAN distance. After outliers are removed
+            on a previous step, we can pick samples that are closes on average.
+
+        Args:
+          pose_landmarks: NumPy array with 3D landmarks of shape (N, 3).
+
+        Returns:
+          Dictionary with count of nearest pose samples from the database. Sample:
+            {
+              'pushups_down': 8,
+              'pushups_up': 2,
+            }
+        """
+        # Check that provided and target poses have the same shape.
+        assert pose_landmarks.shape == (
+            self._n_landmarks,
+            self._n_dimensions,
+        ), "Unexpected shape: {}".format(pose_landmarks.shape)
+
+        # Get given pose embedding.
+        pose_embedding = self._pose_embedder(pose_landmarks)
+        flipped_pose_embedding = self._pose_embedder(
+            pose_landmarks * np.array([-1, 1, 1])
+        )
+
+        # Filter by max distance.
+        #
+        # That helps to remove outliers - poses that are almost the same as the
+        # given one, but has one joint bent into another direction and actually
+        # represnt a different pose class.
+        max_dist_heap = []
+        for sample_idx, sample in enumerate(self._pose_samples):
+            max_dist = min(
+                np.max(np.abs(sample.embedding - pose_embedding) * self._axes_weights),
+                np.max(
+                    np.abs(sample.embedding - flipped_pose_embedding)
+                    * self._axes_weights
+                ),
+            )
+            max_dist_heap.append([max_dist, sample_idx])
+
+        max_dist_heap = sorted(max_dist_heap, key=lambda x: x[0])
+        max_dist_heap = max_dist_heap[: self._top_n_by_max_distance]
+
+        # Filter by mean distance.
+        #
+        # After removing outliers we can find the nearest pose by mean distance.
+        mean_dist_heap = []
+        for _, sample_idx in max_dist_heap:
+            sample = self._pose_samples[sample_idx]
+            mean_dist = min(
+                np.mean(np.abs(sample.embedding - pose_embedding) * self._axes_weights),
+                np.mean(
+                    np.abs(sample.embedding - flipped_pose_embedding)
+                    * self._axes_weights
+                ),
+            )
+            mean_dist_heap.append([mean_dist, sample_idx])
+
+        mean_dist_heap = sorted(mean_dist_heap, key=lambda x: x[0])
+        mean_dist_heap = mean_dist_heap[: self._top_n_by_mean_distance]
+
+        # Collect results into map: (class_name -> n_samples)
+        class_names = [
+            self._pose_samples[sample_idx].class_name
+            for _, sample_idx in mean_dist_heap
+        ]
+        result = {
+            class_name: class_names.count(class_name) for class_name in set(class_names)
+        }
+
+        return result

PoseClassification/pose_embedding.py

@@ -0,0 +1,237 @@
+import numpy as np
+import math
+
+class FullBodyPoseEmbedding(object):
+    """Converts 3D pose landmarks into 3D embedding."""
+
+    def __init__(self, torso_size_multiplier=2.5):
+        # Multiplier to apply to the torso to get minimal body size.
+        self._torso_size_multiplier = torso_size_multiplier
+
+        # Names of the landmarks as they appear in the prediction.
+        self._landmark_names = [
+            "nose",
+            "left_eye_inner",
+            "left_eye",
+            "left_eye_outer",
+            "right_eye_inner",
+            "right_eye",
+            "right_eye_outer",
+            "left_ear",
+            "right_ear",
+            "mouth_left",
+            "mouth_right",
+            "left_shoulder",
+            "right_shoulder",
+            "left_elbow",
+            "right_elbow",
+            "left_wrist",
+            "right_wrist",
+            "left_pinky_1",
+            "right_pinky_1",
+            "left_index_1",
+            "right_index_1",
+            "left_thumb_2",
+            "right_thumb_2",
+            "left_hip",
+            "right_hip",
+            "left_knee",
+            "right_knee",
+            "left_ankle",
+            "right_ankle",
+            "left_heel",
+            "right_heel",
+            "left_foot_index",
+            "right_foot_index",
+        ]
+
+    def __call__(self, landmarks):
+        """Normalizes pose landmarks and converts to embedding
+
+        Args:
+          landmarks - NumPy array with 3D landmarks of shape (N, 3).
+
+        Result:
+          Numpy array with pose embedding of shape (M, 3) where `M` is the number of
+          pairwise distances defined in `_get_pose_distance_embedding`.
+        """
+        assert landmarks.shape[0] == len(
+            self._landmark_names
+        ), "Unexpected number of landmarks: {}".format(landmarks.shape[0])
+
+        # Get pose landmarks.
+        landmarks = np.copy(landmarks)
+
+        # Normalize landmarks.
+        landmarks = self._normalize_pose_landmarks(landmarks)
+
+        # Get embedding.
+        embedding = self._get_pose_distance_embedding(landmarks)
+
+        return embedding
+
+    def _normalize_pose_landmarks(self, landmarks):
+        """Normalizes landmarks translation and scale."""
+        landmarks = np.copy(landmarks)
+
+        # Normalize translation.
+        pose_center = self._get_pose_center(landmarks)
+        landmarks -= pose_center
+
+        # Normalize scale.
+        pose_size = self._get_pose_size(landmarks, self._torso_size_multiplier)
+        landmarks /= pose_size
+        # Multiplication by 100 is not required, but makes it eaasier to debug.
+        landmarks *= 100
+
+        return landmarks
+
+    def _get_pose_center(self, landmarks):
+        """Calculates pose center as point between hips."""
+        left_hip = landmarks[self._landmark_names.index("left_hip")]
+        right_hip = landmarks[self._landmark_names.index("right_hip")]
+        center = (left_hip + right_hip) * 0.5
+        return center
+
+    def _get_pose_size(self, landmarks, torso_size_multiplier):
+        """Calculates pose size.
+
+        It is the maximum of two values:
+          * Torso size multiplied by `torso_size_multiplier`
+          * Maximum distance from pose center to any pose landmark
+        """
+        # This approach uses only 2D landmarks to compute pose size.
+        landmarks = landmarks[:, :2]
+
+        # Hips center.
+        left_hip = landmarks[self._landmark_names.index("left_hip")]
+        right_hip = landmarks[self._landmark_names.index("right_hip")]
+        hips = (left_hip + right_hip) * 0.5
+
+        # Shoulders center.
+        left_shoulder = landmarks[self._landmark_names.index("left_shoulder")]
+        right_shoulder = landmarks[self._landmark_names.index("right_shoulder")]
+        shoulders = (left_shoulder + right_shoulder) * 0.5
+
+        # Torso size as the minimum body size.
+        torso_size = np.linalg.norm(shoulders - hips)
+
+        # Max dist to pose center.
+        pose_center = self._get_pose_center(landmarks)
+        max_dist = np.max(np.linalg.norm(landmarks - pose_center, axis=1))
+
+        return max(torso_size * torso_size_multiplier, max_dist)
+
+    def _get_pose_distance_embedding(self, landmarks):
+        """Converts pose landmarks into 3D embedding.
+
+        We use several pairwise 3D distances to form pose embedding. All distances
+        include X and Y components with sign. We differnt types of pairs to cover
+        different pose classes. Feel free to remove some or add new.
+
+        Args:
+          landmarks - NumPy array with 3D landmarks of shape (N, 3).
+
+        Result:
+          Numpy array with pose embedding of shape (M, 3) where `M` is the number of
+          pairwise distances.
+        """
+        embedding = np.array(
+            [
+                # One joint.
+                self._get_distance(
+                    self._get_average_by_names(landmarks, "left_hip", "right_hip"),
+                    self._get_average_by_names(
+                        landmarks, "left_shoulder", "right_shoulder"
+                    ),
+                ),
+                self._get_distance_by_names(landmarks, "left_shoulder", "left_elbow"),
+                self._get_distance_by_names(landmarks, "right_shoulder", "right_elbow"),
+                self._get_distance_by_names(landmarks, "left_elbow", "left_wrist"),
+                self._get_distance_by_names(landmarks, "right_elbow", "right_wrist"),
+                self._get_distance_by_names(landmarks, "left_hip", "left_knee"),
+                self._get_distance_by_names(landmarks, "right_hip", "right_knee"),
+                self._get_distance_by_names(landmarks, "left_knee", "left_ankle"),
+                self._get_distance_by_names(landmarks, "right_knee", "right_ankle"),
+                # Two joints.
+                self._get_distance_by_names(landmarks, "left_shoulder", "left_wrist"),
+                self._get_distance_by_names(landmarks, "right_shoulder", "right_wrist"),
+                self._get_distance_by_names(landmarks, "left_hip", "left_ankle"),
+                self._get_distance_by_names(landmarks, "right_hip", "right_ankle"),
+                # Four joints.
+                self._get_distance_by_names(landmarks, "left_hip", "left_wrist"),
+                self._get_distance_by_names(landmarks, "right_hip", "right_wrist"),
+                # Five joints.
+                self._get_distance_by_names(landmarks, "left_shoulder", "left_ankle"),
+                self._get_distance_by_names(landmarks, "right_shoulder", "right_ankle"),
+                self._get_distance_by_names(landmarks, "left_hip", "left_wrist"),
+                self._get_distance_by_names(landmarks, "right_hip", "right_wrist"),
+                # Cross body.
+                self._get_distance_by_names(landmarks, "left_elbow", "right_elbow"),
+                self._get_distance_by_names(landmarks, "left_knee", "right_knee"),
+                self._get_distance_by_names(landmarks, "left_wrist", "right_wrist"),
+                self._get_distance_by_names(landmarks, "left_ankle", "right_ankle"),
+                # Body bent direction.
+                self._get_distance(
+                    self._get_average_by_names(landmarks, 'left_wrist', 'left_ankle'),
+                    landmarks[self._landmark_names.index('left_hip')]),
+                self._get_distance(
+                    self._get_average_by_names(landmarks, 'right_wrist', 'right_ankle'),
+                    landmarks[self._landmark_names.index('right_hip')]),
+                # Angle between landmarks - cf https://www.kaggle.com/code/venkatkumar001/yoga-pose-recognition-mediapipe
+                # self._calculateAngle(landmarks, "left_hip", "left_knee", "left_ankle"),
+                # self._calculateAngle(landmarks, "right_hip", "right_knee", "right_ankle"),
+                # self._calculateAngle(landmarks, "left_shoulder", "left_elbow", "left_wrist"),
+                # self._calculateAngle(landmarks, "right_shoulder", "right_elbow", "right_wrist")
+
+            ]
+        )
+        # print(embedding)
+        # print(embbeding.shape)
+        # print(type(embedding))
+        # print(type(landmarks[self._landmark_names.index('right_hip')]))
+        # print(landmarks[self._landmark_names.index('right_hip')])
+        return embedding
+
+    def _get_average_by_names(self, landmarks, name_from, name_to):
+        lmk_from = landmarks[self._landmark_names.index(name_from)]
+        lmk_to = landmarks[self._landmark_names.index(name_to)]
+        return (lmk_from + lmk_to) * 0.5
+
+    def _get_distance_by_names(self, landmarks, name_from, name_to):
+        lmk_from = landmarks[self._landmark_names.index(name_from)]
+        lmk_to = landmarks[self._landmark_names.index(name_to)]
+        return self._get_distance(lmk_from, lmk_to)
+
+    def _get_distance(self, lmk_from, lmk_to):
+        return lmk_to - lmk_from
+
+    def _calculateAngle(self, landmarks, name1, name2, name3):
+        '''
+        This function calculates angle between three different landmarks.
+        Args:
+            landmark1: The first landmark containing the x,y and z coordinates.
+            landmark2: The second landmark containing the x,y and z coordinates.
+            landmark3: The third landmark containing the x,y and z coordinates.
+        Returns:
+            angle: The calculated angle between the three landmarks.
+
+        cf https://www.kaggle.com/code/venkatkumar001/yoga-pose-recognition-mediapipe
+        '''
+
+        # Get the required landmarks coordinates.
+        x1, y1, _ = landmarks[self._landmark_names.index(name1)]
+        x2, y2, _ = landmarks[self._landmark_names.index(name2)]
+        x3, y3, _ = landmarks[self._landmark_names.index(name3)]
+
+        # Calculate the angle between the three points
+        angle = math.degrees(math.atan2(y3 - y2, x3 - x2) - math.atan2(y1 - y2, x1 - x2))
+        
+        # Check if the angle is less than zero.
+        if angle < 0:
+
+            # Add 360 to the found angle.
+            angle += 360
+        
+        # Return the calculated angle.
+        return angle

PoseClassification/pose_embedding_2.py

@@ -0,0 +1,246 @@
+import numpy as np
+import math
+
+class FullBodyPoseEmbedding(object):
+    """Converts 3D pose landmarks into 3D embedding."""
+
+    def __init__(self, torso_size_multiplier=2.5):
+        # Multiplier to apply to the torso to get minimal body size.
+        self._torso_size_multiplier = torso_size_multiplier
+
+        # Names of the landmarks as they appear in the prediction.
+        self._landmark_names = [
+            "nose",
+            "left_eye_inner",
+            "left_eye",
+            "left_eye_outer",
+            "right_eye_inner",
+            "right_eye",
+            "right_eye_outer",
+            "left_ear",
+            "right_ear",
+            "mouth_left",
+            "mouth_right",
+            "left_shoulder",
+            "right_shoulder",
+            "left_elbow",
+            "right_elbow",
+            "left_wrist",
+            "right_wrist",
+            "left_pinky_1",
+            "right_pinky_1",
+            "left_index_1",
+            "right_index_1",
+            "left_thumb_2",
+            "right_thumb_2",
+            "left_hip",
+            "right_hip",
+            "left_knee",
+            "right_knee",
+            "left_ankle",
+            "right_ankle",
+            "left_heel",
+            "right_heel",
+            "left_foot_index",
+            "right_foot_index",
+        ]
+
+    def __call__(self, landmarks):
+        """Normalizes pose landmarks and converts to embedding
+
+        Args:
+          landmarks - NumPy array with 3D landmarks of shape (N, 3).
+
+        Result:
+          Numpy array with pose embedding of shape (M, 3) where `M` is the number of
+          pairwise distances defined in `_get_pose_distance_embedding`.
+        """
+        assert landmarks.shape[0] == len(
+            self._landmark_names
+        ), "Unexpected number of landmarks: {}".format(landmarks.shape[0])
+
+        # Get pose landmarks.
+        landmarks = np.copy(landmarks)
+
+        # Normalize landmarks.
+        landmarks = self._normalize_pose_landmarks(landmarks)
+
+        # Get embedding.
+        embedding = self._get_pose_distance_embedding(landmarks)
+
+        # Add angle embedding
+        embedding_angle = self._get_pose_angle_embedding(landmarks)
+
+        assert embedding.shape == embedding_angle.shape, f"Error in embeddings shape : distance embed {embedding.shape} and angle {embedding_angle.shape}"
+
+        return embedding
+
+    def _normalize_pose_landmarks(self, landmarks):
+        """Normalizes landmarks translation and scale."""
+        landmarks = np.copy(landmarks)
+
+        # Normalize translation.
+        pose_center = self._get_pose_center(landmarks)
+        landmarks -= pose_center
+
+        # Normalize scale.
+        pose_size = self._get_pose_size(landmarks, self._torso_size_multiplier)
+        landmarks /= pose_size
+        # Multiplication by 100 is not required, but makes it eaasier to debug.
+        landmarks *= 100
+
+        return landmarks
+
+    def _get_pose_center(self, landmarks):
+        """Calculates pose center as point between hips."""
+        left_hip = landmarks[self._landmark_names.index("left_hip")]
+        right_hip = landmarks[self._landmark_names.index("right_hip")]
+        center = (left_hip + right_hip) * 0.5
+        return center
+
+    def _get_pose_size(self, landmarks, torso_size_multiplier):
+        """Calculates pose size.
+
+        It is the maximum of two values:
+          * Torso size multiplied by `torso_size_multiplier`
+          * Maximum distance from pose center to any pose landmark
+        """
+        # This approach uses only 2D landmarks to compute pose size.
+        landmarks = landmarks[:, :2]
+
+        # Hips center.
+        left_hip = landmarks[self._landmark_names.index("left_hip")]
+        right_hip = landmarks[self._landmark_names.index("right_hip")]
+        hips = (left_hip + right_hip) * 0.5
+
+        # Shoulders center.
+        left_shoulder = landmarks[self._landmark_names.index("left_shoulder")]
+        right_shoulder = landmarks[self._landmark_names.index("right_shoulder")]
+        shoulders = (left_shoulder + right_shoulder) * 0.5
+
+        # Torso size as the minimum body size.
+        torso_size = np.linalg.norm(shoulders - hips)
+
+        # Max dist to pose center.
+        pose_center = self._get_pose_center(landmarks)
+        max_dist = np.max(np.linalg.norm(landmarks - pose_center, axis=1))
+
+        return max(torso_size * torso_size_multiplier, max_dist)
+
+    def _get_pose_distance_embedding(self, landmarks):
+        """Converts pose landmarks into 3D embedding.
+
+        We use several pairwise 3D distances to form pose embedding. All distances
+        include X and Y components with sign. We differnt types of pairs to cover
+        different pose classes. Feel free to remove some or add new.
+
+        Args:
+          landmarks - NumPy array with 3D landmarks of shape (N, 3).
+
+        Result:
+          Numpy array with pose embedding of shape (M, 3) where `M` is the number of
+          pairwise distances.
+        """
+        embedding = np.array(
+            [
+                # One joint.
+                self._get_distance(
+                    self._get_average_by_names(landmarks, "left_hip", "right_hip"),
+                    self._get_average_by_names(
+                        landmarks, "left_shoulder", "right_shoulder"
+                    ),
+                ),
+                self._get_distance_by_names(landmarks, "left_shoulder", "left_elbow"),
+                self._get_distance_by_names(landmarks, "right_shoulder", "right_elbow"),
+                self._get_distance_by_names(landmarks, "left_elbow", "left_wrist"),
+                self._get_distance_by_names(landmarks, "right_elbow", "right_wrist"),
+                self._get_distance_by_names(landmarks, "left_hip", "left_knee"),
+                self._get_distance_by_names(landmarks, "right_hip", "right_knee"),
+                self._get_distance_by_names(landmarks, "left_knee", "left_ankle"),
+                self._get_distance_by_names(landmarks, "right_knee", "right_ankle"),
+                # Two joints.
+                self._get_distance_by_names(landmarks, "left_shoulder", "left_wrist"),
+                self._get_distance_by_names(landmarks, "right_shoulder", "right_wrist"),
+                self._get_distance_by_names(landmarks, "left_hip", "left_ankle"),
+                self._get_distance_by_names(landmarks, "right_hip", "right_ankle"),
+                # Four joints.
+                self._get_distance_by_names(landmarks, "left_hip", "left_wrist"),
+                self._get_distance_by_names(landmarks, "right_hip", "right_wrist"),
+                # Five joints.
+                self._get_distance_by_names(landmarks, "left_shoulder", "left_ankle"),
+                self._get_distance_by_names(landmarks, "right_shoulder", "right_ankle"),
+                self._get_distance_by_names(landmarks, "left_hip", "left_wrist"),
+                self._get_distance_by_names(landmarks, "right_hip", "right_wrist"),
+                # Cross body.
+                self._get_distance_by_names(landmarks, "left_elbow", "right_elbow"),
+                self._get_distance_by_names(landmarks, "left_knee", "right_knee"),
+                self._get_distance_by_names(landmarks, "left_wrist", "right_wrist"),
+                self._get_distance_by_names(landmarks, "left_ankle", "right_ankle"),
+                # Body bent direction.
+                self._get_distance(
+                    self._get_average_by_names(landmarks, 'left_wrist', 'left_ankle'),
+                    landmarks[self._landmark_names.index('left_hip')]),
+                self._get_distance(
+                    self._get_average_by_names(landmarks, 'right_wrist', 'right_ankle'),
+                    landmarks[self._landmark_names.index('right_hip')])
+
+            ]
+        )
+        # print(embedding)
+        # print(embbeding.shape)
+        # print(type(embedding))
+        # print(type(landmarks[self._landmark_names.index('right_hip')]))
+        # print(landmarks[self._landmark_names.index('right_hip')])
+        return embedding
+
+    def _get_average_by_names(self, landmarks, name_from, name_to):
+        lmk_from = landmarks[self._landmark_names.index(name_from)]
+        lmk_to = landmarks[self._landmark_names.index(name_to)]
+        return (lmk_from + lmk_to) * 0.5
+
+    def _get_distance_by_names(self, landmarks, name_from, name_to):
+        lmk_from = landmarks[self._landmark_names.index(name_from)]
+        lmk_to = landmarks[self._landmark_names.index(name_to)]
+        return self._get_distance(lmk_from, lmk_to)
+
+    def _get_distance(self, lmk_from, lmk_to):
+        return lmk_to - lmk_from
+
+    def _get_pose_angle_embedding(self, landmarks):
+        embedding = [
+                # Angle between landmarks - cf https://www.kaggle.com/code/venkatkumar001/yoga-pose-recognition-mediapipe
+                self._calculateAngle(landmarks, "left_hip", "left_knee", "left_ankle"),
+                self._calculateAngle(landmarks, "right_hip", "right_knee", "right_ankle"),
+                self._calculateAngle(landmarks, "left_shoulder", "left_elbow", "left_wrist"),
+                self._calculateAngle(landmarks, "right_shoulder", "right_elbow", "right_wrist")
+        ]
+        return embedding
+
+    def _calculateAngle(self, landmarks, name1, name2, name3):
+        '''
+        This function calculates angle between three different landmarks.
+        Args:
+            landmark1: The first landmark containing the x,y and z coordinates.
+            landmark2: The second landmark containing the x,y and z coordinates.
+            landmark3: The third landmark containing the x,y and z coordinates.
+        Returns:
+            angle: The calculated angle between the three landmarks.
+
+        cf https://www.kaggle.com/code/venkatkumar001/yoga-pose-recognition-mediapipe
+        '''
+        # Get the required landmarks coordinates.
+        x1, y1, _ = landmarks[self._landmark_names.index(name1)]
+        x2, y2, _ = landmarks[self._landmark_names.index(name2)]
+        x3, y3, _ = landmarks[self._landmark_names.index(name3)]
+
+        # Calculate the angle between the three points
+        angle = math.degrees(math.atan2(y3 - y2, x3 - x2) - math.atan2(y1 - y2, x1 - x2))
+        
+        # Check if the angle is less than zero.
+        if angle < 0:
+
+            # Add 360 to the found angle.
+            angle += 360
+        
+        # Return the calculated angle.
+        return angle

PoseClassification/utils.py

@@ -0,0 +1,129 @@
+from matplotlib import pyplot as plt
+import numpy as np
+
+
+def show_image(img, figsize=(10, 10)):
+    """Shows output PIL image."""
+    plt.figure(figsize=figsize)
+    plt.imshow(img)
+    plt.show()
+
+
+class EMADictSmoothing(object):
+    """Smoothes pose classification. Exponential moving average (EMA)."""
+
+    def __init__(self, window_size=10, alpha=0.2):
+        self._window_size = window_size
+        self._alpha = alpha
+
+        self._data_in_window = []
+
+    def __call__(self, data):
+        """Smoothes given pose classification.
+
+        Smoothing is done by computing Exponential Moving Average for every pose
+        class observed in the given time window. Missed pose classes arre replaced
+        with 0.
+
+        Args:
+          data: Dictionary with pose classification. Sample:
+              {
+                'pushups_down': 8,
+                'pushups_up': 2,
+              }
+
+        Result:
+          Dictionary in the same format but with smoothed and float instead of
+          integer values. Sample:
+            {
+              'pushups_down': 8.3,
+              'pushups_up': 1.7,
+            }
+        """
+        # Add new data to the beginning of the window for simpler code.
+        self._data_in_window.insert(0, data)
+        self._data_in_window = self._data_in_window[: self._window_size]
+
+        # Get all keys.
+        keys = set([key for data in self._data_in_window for key, _ in data.items()])
+
+        # Get smoothed values.
+        smoothed_data = dict()
+        for key in keys:
+            factor = 1.0
+            top_sum = 0.0
+            bottom_sum = 0.0
+            for data in self._data_in_window:
+                value = data[key] if key in data else 0.0
+
+                top_sum += factor * value
+                bottom_sum += factor
+
+                # Update factor.
+                factor *= 1.0 - self._alpha
+
+            smoothed_data[key] = top_sum / bottom_sum
+
+        return smoothed_data
+
+
+class RepetitionCounter(object):
+    """Counts number of repetitions of given target pose class."""
+
+    def __init__(self, class_name, enter_threshold=6, exit_threshold=4):
+        self._class_name = class_name
+
+        # If pose counter passes given threshold, then we enter the pose.
+        self._enter_threshold = enter_threshold
+        self._exit_threshold = exit_threshold
+
+        # Either we are in given pose or not.
+        self._pose_entered = False
+
+        # Number of times we exited the pose.
+        self._n_repeats = 0
+
+    @property
+    def n_repeats(self):
+        return self._n_repeats
+    
+    def reset(self):
+        self._n_repeats = 0
+
+    def __call__(self, pose_classification):
+        """Counts number of repetitions happend until given frame.
+
+        We use two thresholds. First you need to go above the higher one to enter
+        the pose, and then you need to go below the lower one to exit it. Difference
+        between the thresholds makes it stable to prediction jittering (which will
+        cause wrong counts in case of having only one threshold).
+
+        Args:
+          pose_classification: Pose classification dictionary on current frame.
+            Sample:
+              {
+                'pushups_down': 8.3,
+                'pushups_up': 1.7,
+              }
+
+        Returns:
+          Integer counter of repetitions.
+        """
+        # Get pose confidence.
+        pose_confidence = 0.0
+        if self._class_name in pose_classification:
+            pose_confidence = pose_classification[self._class_name]
+
+        # On the very first frame or if we were out of the pose, just check if we
+        # entered it on this frame and update the state.
+        if not self._pose_entered:
+            self._pose_entered = pose_confidence > self._enter_threshold
+            return self._n_repeats
+
+        # If we were in the pose and are exiting it, then increase the counter and
+        # update the state.
+        if pose_confidence < self._exit_threshold:
+            self._n_repeats += 1
+            self._pose_entered = False
+
+        return self._n_repeats

PoseClassification/visualize.py

@@ -0,0 +1,139 @@
+import io
+from PIL import Image, ImageFont, ImageDraw
+import requests
+import matplotlib.pyplot as plt
+
+
+class PoseClassificationVisualizer(object):
+    """Keeps track of classifcations for every frame and renders them."""
+
+    def __init__(
+        self,
+        class_name,
+        plot_location_x=0.05,
+        plot_location_y=0.05,
+        plot_max_width=0.4,
+        plot_max_height=0.4,
+        plot_figsize=(9, 4),
+        plot_x_max=None,
+        plot_y_max=None,
+        counter_location_x=0.85,
+        counter_location_y=0.05,
+        counter_font_path="https://github.com/googlefonts/roboto/blob/main/src/hinted/Roboto-Regular.ttf?raw=true",
+        counter_font_color="red",
+        counter_font_size=0.15,
+    ):
+        self._class_name = class_name
+        self._plot_location_x = plot_location_x
+        self._plot_location_y = plot_location_y
+        self._plot_max_width = plot_max_width
+        self._plot_max_height = plot_max_height
+        self._plot_figsize = plot_figsize
+        self._plot_x_max = plot_x_max
+        self._plot_y_max = plot_y_max
+        self._counter_location_x = counter_location_x
+        self._counter_location_y = counter_location_y
+        self._counter_font_path = counter_font_path
+        self._counter_font_color = counter_font_color
+        self._counter_font_size = counter_font_size
+
+        self._counter_font = None
+
+        self._pose_classification_history = []
+        self._pose_classification_filtered_history = []
+
+    def __call__(
+        self,
+        frame,
+        pose_classification,
+        pose_classification_filtered,
+        repetitions_count,
+    ):
+        """Renders pose classifcation and counter until given frame."""
+        # Extend classification history.
+        self._pose_classification_history.append(pose_classification)
+        self._pose_classification_filtered_history.append(pose_classification_filtered)
+
+        # Output frame with classification plot and counter.
+        output_img = Image.fromarray(frame)
+
+        output_width = output_img.size[0]
+        output_height = output_img.size[1]
+
+        # Draw the plot.
+        img = self._plot_classification_history(output_width, output_height)
+        img.thumbnail(
+            (
+                int(output_width * self._plot_max_width),
+                int(output_height * self._plot_max_height),
+            ),
+            Image.LANCZOS,
+        )
+        output_img.paste(
+            img,
+            (
+                int(output_width * self._plot_location_x),
+                int(output_height * self._plot_location_y),
+            ),
+        )
+
+        # Draw the count.
+        output_img_draw = ImageDraw.Draw(output_img)
+        if self._counter_font is None:
+            font_size = int(output_height * self._counter_font_size)
+            font_request = requests.get(self._counter_font_path, allow_redirects=True)
+            self._counter_font = ImageFont.truetype(
+                io.BytesIO(font_request.content), size=font_size
+            )
+        output_img_draw.text(
+            (
+                output_width * self._counter_location_x,
+                output_height * self._counter_location_y,
+            ),
+            str(repetitions_count),
+            font=self._counter_font,
+            fill=self._counter_font_color,
+        )
+
+        return output_img
+
+    def _plot_classification_history(self, output_width, output_height):
+        fig = plt.figure(figsize=self._plot_figsize)
+
+        for classification_history in [
+            self._pose_classification_history,
+            self._pose_classification_filtered_history,
+        ]:
+            y = []
+            for classification in classification_history:
+                if classification is None:
+                    y.append(None)
+                elif self._class_name in classification:
+                    y.append(classification[self._class_name])
+                else:
+                    y.append(0)
+            plt.plot(y, linewidth=7)
+
+        plt.grid(axis="y", alpha=0.75)
+        plt.xlabel("Frame")
+        plt.ylabel("Confidence")
+        plt.title("Classification history for `{}`".format(self._class_name))
+        plt.legend(loc="upper right")
+
+        if self._plot_y_max is not None:
+            plt.ylim(top=self._plot_y_max)
+        if self._plot_x_max is not None:
+            plt.xlim(right=self._plot_x_max)
+
+        # Convert plot to image.
+        buf = io.BytesIO()
+        dpi = min(
+            output_width * self._plot_max_width / float(self._plot_figsize[0]),
+            output_height * self._plot_max_height / float(self._plot_figsize[1]),
+        )
+        fig.savefig(buf, dpi=dpi)
+        buf.seek(0)
+        img = Image.open(buf)
+        plt.close()
+
+        return img

README.md

@@ -1,14 +1,191 @@
----
-title: YOGAI
-emoji: 🐠
-colorFrom: purple
-colorTo: green
-sdk: gradio
-sdk_version: 5.3.0
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: yoga app
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Projet ACV-2
+
+## Exécution rapide 
+
+**Installation uv**
+
+> curl -LsSf https://astral.sh/uv/install.sh | sh
+
+> uv self update
+
+**Installation et execution du projet**
+
+> git clone git@github.com:LexouLam/projet-acv-2.git
+
+> cd projet-acv-2
+
+> uv venv --python 3.12
+
+> uv sync
+
+> source .venv/bin/activate
+
+> uv run classify\_video.py live --display
+
+OU 
+
+> uv run classify\_video.py data/videos/tree_vid_1.mp4 --display
+
+## Documentation
+
+Team : Impredalam
+
+INFO GLOBALE:
+
+Gardez en tête que la branche “main” du projet ne doit jamais être bugée, le code qu’elle contient doit
+toujours pouvoir s’exécuter (sauf bug non anticipé qui nécessitera un “hot-fix”).
+
+======
+JOUR 1
+======
+
+Le thème abordé est la détection et la classification de pose humaine dans le cadre d’une application de
+sport à domicile.
+
+------------------------------------------------------------------------------
+TODO JOUR 1:
+
+---DONE--- 1. Trouver un nom pour votre groupe et un nom pour le projet. 
+---DONE--- 2. Mettre en place un dépôt git                                   
+---DONE--- 3. Explorer la base de code déjà existante
+            - algorithme de détection/classification de poses,
+            - algorithme de comptage sur un flux vidéo.
+---DONE--- 4. Constituer une base de données annotées pour « entraîner » l’algorithme avec quelques images de vous faisant des pompes.                 
+---DONE--- 5. Préparer une vidéo démontrant la faisabilité d’un tel projet. 
+---DONE--- 6. Optionnel J1 : une démo live + un repo git structuré sans notebook. 
+
+------------------------------------------------------------------------------
+1. stand-up                  ---DONE---
+
+2. Prise en compte des exigences client suite à
+la dernière livraison,       ---DONE---
+
+3. tération de code          ---DONE---
+
+4. 16h : livraison au client ---DONE---
+
+5. 17h : concours de pompe   ---POSTPONED---
+
+------------------------------------------------------------------------------
+RESULTAT:
+
+    Programme founctionnelle, qui détecte les pompes et les compte, formé avec les images d'Internet, nos propres photos, inversées horizontalement pour rendre l'ensemble de données plus grand et plus riche.
+
+    Acev un logo de notre équipe
+------------------------------------------------------------------------------
+
+======
+JOUR 2
+======
+
+Développer le vrai projet qui pourra être utilisé par la société.
+Sujet: cours de yoga : classification des positions classiques
+
+Le client veut un programme python exécutable en ligne de commande avec une interface simple.
+
+------------------------------------------------------------------------------
+TODO JOUR 2:
+
+---DONE--- 1. Choix d’un sujet parmi les quatres proposés.
+2. Planification et répartition des tâches, structuration du projet git.
+---DONE--- 3. Constitution d’une base de données adaptée au sujet choisi (réalisée vous-même, ou pas ?).
+4. Sortir du notebook, script avec arguments.
+     https://docs.python.org/3/library/argparse.html
+5. Implémentation des options (prioritairement, la possibilité d’afficher des informations pour débugger le programme facilement).
+6. Documentation minimale pour lancer le programme.
+7. Optionnel J2 : packagisation poetry ou équivalent + (très optionnel) tests fonctionnels/unitaires.
+     https://github.com/features/actions
+
+------------------------------------------------------------------------------
+1. 9h : prise en main du sujet et gestion de projet (création/répartition des tâches)
+
+2. 9h45 : début du sprint de la journée
+
+3. 16h : livraison au client
+
+------------------------------------------------------------------------------
+RESULTAT:
+
+test
+------------------------------------------------------------------------------
+
+======
+JOUR 3
+======
+
+1. stand-up, 
+
+2. prise en compte des exigences client suite à
+la dernière livraison, 
+
+3. tération de code, 
+
+4. livraison au client
+
+
+
+## Set-up environnement 
+
+**installation uv**
+
+> curl -LsSf https://astral.sh/uv/install.sh | sh  
+> uv self update  
+
+**création environnement**
+
+> mkdir projet_acv_2
+> cd projet_acv_2/  
+> uv init  
+> uv venv --python 3.12  
+> uv add numpy matplotlib plotly jupyter opencv-python mediapipe  
+> uv add tqdm requests pillow scikit-learn
+
+**création repo git si non créé**  
+
+> touch .gitignore  
+> git init  
+> git add .  
+> git commit -m "start repo"  
+> git remote add origin git@github.com:LexouLam/projet-acv-2.git
+> git push --set-upstream origin master  
+> git push  
+
+**clone repo git et initialisation environnement**
+
+> git clone git@github.com:LexouLam/projet-acv-2.git  
+> cd projet-acv-2
+> uv sync  
+
+## Arguments script "classify_video.py"
+
+> classify_video.py arg1
+
+Inputs 
+
+**arg1** : "path/to/video.mp4" ou "live" 
+
+Outputs 
+
+Aucun pour l'instant...
+
+
+
+
+## Modèle informations
+
+**Pose Landmark Model (BlazePose GHUM 3D)**
+https://camo.githubusercontent.com/d3afebfc801ee1a094c28604c7a0eb25f8b9c9925f75b0fff4c8c8b4871c0d28/68747470733a2f2f6d65646961706970652e6465762f696d616765732f6d6f62696c652f706f73655f747261636b696e675f66756c6c5f626f64795f6c616e646d61726b732e706e67
+
+GUIDE: https://github.com/google-ai-edge/mediapipe/blob/master/docs/solutions/pose.md
+
+![alt text](src/image.png)
+
+Left shoulder (landmark 11)
+Right shoulder (landmark 12)
+Left elbow (landmark 13)
+Right elbow (landmark 14)
+Left wrist (landmark 15)
+Right wrist (landmark 16)
+Hips (landmarks 23 and 24)
+
+

README.md.old

@@ -0,0 +1,146 @@
+# Projet ACV-2
+
+Team : Impredalam
+
+INFO GLOBALE:
+
+Gardez en tête que la branche “main” du projet ne doit jamais être bugée, le code qu’elle contient doit
+toujours pouvoir s’exécuter (sauf bug non anticipé qui nécessitera un “hot-fix”).
+
+======
+JOUR 1
+======
+
+Le thème abordé est la détection et la classification de pose humaine dans le cadre d’une application de
+sport à domicile.
+
+------------------------------------------------------------------------------
+TODO JOUR 1:
+
+---DONE--- 1. Trouver un nom pour votre groupe et un nom pour le projet. 
+---DONE--- 2. Mettre en place un dépôt git                                   
+---DONE--- 3. Explorer la base de code déjà existante
+            - algorithme de détection/classification de poses,
+            - algorithme de comptage sur un flux vidéo.
+---DONE--- 4. Constituer une base de données annotées pour « entraîner » l’algorithme avec quelques images de vous faisant des pompes.                 
+---DONE--- 5. Préparer une vidéo démontrant la faisabilité d’un tel projet. 
+---DONE--- 6. Optionnel J1 : une démo live + un repo git structuré sans notebook. 
+
+------------------------------------------------------------------------------
+1. stand-up                  ---DONE---
+
+2. Prise en compte des exigences client suite à
+la dernière livraison,       ---DONE---
+
+3. tération de code          ---DONE---
+
+4. 16h : livraison au client ---DONE---
+
+5. 17h : concours de pompe   ---POSTPONED---
+
+------------------------------------------------------------------------------
+RESULTAT:
+
+    Programme founctionnelle, qui détecte les pompes et les compte, formé avec les images d'Internet, nos propres photos, inversées horizontalement pour rendre l'ensemble de données plus grand et plus riche.
+
+    Acev un logo de notre équipe
+------------------------------------------------------------------------------
+
+======
+JOUR 2
+======
+
+Développer le vrai projet qui pourra être utilisé par la société.
+Sujet: cours de yoga : classification des positions classiques
+
+Le client veut un programme python exécutable en ligne de commande avec une interface simple.
+
+------------------------------------------------------------------------------
+TODO JOUR 2:
+
+---DONE--- 1. Choix d’un sujet parmi les quatres proposés.
+2. Planification et répartition des tâches, structuration du projet git.
+---DONE--- 3. Constitution d’une base de données adaptée au sujet choisi (réalisée vous-même, ou pas ?).
+4. Sortir du notebook, script avec arguments.
+     https://docs.python.org/3/library/argparse.html
+5. Implémentation des options (prioritairement, la possibilité d’afficher des informations pour débugger le programme facilement).
+6. Documentation minimale pour lancer le programme.
+7. Optionnel J2 : packagisation poetry ou équivalent + (très optionnel) tests fonctionnels/unitaires.
+     https://github.com/features/actions
+
+------------------------------------------------------------------------------
+1. 9h : prise en main du sujet et gestion de projet (création/répartition des tâches)
+
+2. 9h45 : début du sprint de la journée
+
+3. 16h : livraison au client
+
+------------------------------------------------------------------------------
+RESULTAT:
+
+test
+------------------------------------------------------------------------------
+
+======
+JOUR 3
+======
+
+1. stand-up, 
+
+2. prise en compte des exigences client suite à
+la dernière livraison, 
+
+3. tération de code, 
+
+4. livraison au client
+
+
+
+## Set-up environnement 
+
+**installation uv**
+
+> curl -LsSf https://astral.sh/uv/install.sh | sh  
+> uv self update  
+
+**création environnement**
+
+> mkdir projet_acv_2
+> cd projet_acv_2/  
+> uv init  
+> uv venv --python 3.12  
+> uv add numpy matplotlib plotly jupyter opencv-python mediapipe  
+> uv add tqdm requests pillow scikit-learn
+
+**création repo git si non créé**  
+
+> touch .gitignore  
+> git init  
+> git add .  
+> git commit -m "start repo"  
+> git remote add origin git@github.com:LexouLam/projet-acv-2.git
+> git push --set-upstream origin master  
+> git push  
+
+**clone repo git et initialisation environnement**
+
+> git clone git@github.com:LexouLam/projet-acv-2.git  
+> cd projet-acv-2
+> uv sync  
+
+
+
+**Pose Landmark Model (BlazePose GHUM 3D)**
+https://camo.githubusercontent.com/d3afebfc801ee1a094c28604c7a0eb25f8b9c9925f75b0fff4c8c8b4871c0d28/68747470733a2f2f6d65646961706970652e6465762f696d616765732f6d6f62696c652f706f73655f747261636b696e675f66756c6c5f626f64795f6c616e646d61726b732e706e67
+
+GUIDE: https://github.com/google-ai-edge/mediapipe/blob/master/docs/solutions/pose.md
+
+![alt text](src/image.png)
+
+Left shoulder (landmark 11)
+Right shoulder (landmark 12)
+Left elbow (landmark 13)
+Right elbow (landmark 14)
+Left wrist (landmark 15)
+Right wrist (landmark 16)
+Hips (landmarks 23 and 24)

app.py

@@ -0,0 +1,95 @@
+import gradio as gr
+from interface_pages.home_page import home_page
+from interface_pages.about_page import about_page
+from interface_pages.yoga_position_from_stream import yoga_position_from_stream
+from interface_pages.yoga_position_from_video import yoga_position_from_video
+
+def main(page):
+    if page == "Home":
+        return home_page()
+    elif page == "About us":
+        return about_page()
+    elif page == "Yoga from stream":
+        return yoga_position_from_stream()
+    elif page == "Yoga from video":
+        return yoga_position_from_video()
+
+def interface():
+    with gr.Blocks(css="static/styles.css") as demo:
+
+        # Layout with a Row to hold buttons and content
+        with gr.Row():
+            with gr.Column(scale=1, elem_classes=["menu-column"]):
+                # Vertical Navigation Buttons
+                home_button = gr.Button("Home", elem_classes=["menu-button"])
+                about_button = gr.Button("About us", elem_classes=["menu-button"])
+                yoga_stream_button = gr.Button("Yoga from stream", elem_classes=["menu-button"])
+                yoga_video_button = gr.Button("Yoga from video", elem_classes=["menu-button"])
+
+        # Create page contents
+        with gr.Column(elem_id="page-content") as page_content:
+            home_page_content = home_page()
+            about_page_content = about_page()
+            yoga_stream_content = yoga_position_from_stream()
+            yoga_video_content = yoga_position_from_video()
+
+        # Set initial visibility
+        home_page_content.visible = True
+        about_page_content.visible = False
+        yoga_stream_content.visible = False
+        yoga_video_content.visible = False
+
+        # Button click handlers
+        def show_page(page):
+            return [
+                gr.update(visible=(content == page))
+                for content in [
+                    home_page_content,
+                    about_page_content,
+                    yoga_stream_content,
+                    yoga_video_content,
+                ]
+            ]
+
+        home_button.click(
+            lambda: show_page(home_page_content),
+            outputs=[
+                home_page_content,
+                about_page_content,
+                yoga_stream_content,
+                yoga_video_content,
+            ],
+        )
+        about_button.click(
+            lambda: show_page(about_page_content),
+            outputs=[
+                home_page_content,
+                about_page_content,
+                yoga_stream_content,
+                yoga_video_content,
+            ],
+        )
+        yoga_stream_button.click(
+            lambda: show_page(yoga_stream_content),
+            outputs=[
+                home_page_content,
+                about_page_content,
+                yoga_stream_content,
+                yoga_video_content,
+            ],
+        )
+        yoga_video_button.click(
+            lambda: show_page(yoga_video_content),
+            outputs=[
+                home_page_content,
+                about_page_content,
+                yoga_stream_content,
+                yoga_video_content,
+            ],
+        )
+
+    return demo
+
+
+if __name__ == "__main__":
+    interface().launch(share=True)

classify_video.py

@@ -0,0 +1,231 @@
+import argparse
+import sys
+import cv2
+import numpy as np
+from rich.console import Console
+from rich.panel import Panel
+from rich.align import Align
+from rich.layout import Layout
+from pyfiglet import Figlet
+import mediapipe as mp
+from PoseClassification.pose_embedding import FullBodyPoseEmbedding
+from PoseClassification.pose_classifier import PoseClassifier
+from PoseClassification.utils import EMADictSmoothing
+from PoseClassification.visualize import PoseClassificationVisualizer
+
+# For cross-platform compatibility
+try:
+    import msvcrt  # Windows
+except ImportError:
+    import termios  # Unix-like
+    import tty
+
+
+def getch():
+    if sys.platform == "win32":
+        return msvcrt.getch().decode("utf-8")
+    else:
+        fd = sys.stdin.fileno()
+        old_settings = termios.tcgetattr(fd)
+        try:
+            tty.setraw(sys.stdin.fileno())
+            ch = sys.stdin.read(1)
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+        return ch
+
+
+def create_ascii_title(text):
+    f = Figlet(font="isometric2")
+    return f.renderText(text)
+
+
+def main(input_source, display=False, output_file=None):
+    console = Console()
+    layout = Layout()
+
+    # Create ASCII title
+    ascii_title = create_ascii_title("YOGAI")
+
+    # Create the layout
+    layout.split(
+        Layout(Panel(Align.center(ascii_title), border_style="bold blue"), size=15),
+        Layout(name="main"),
+    )
+
+    is_live = input_source == "live"
+    if is_live:
+        layout["main"].update(
+            Panel(
+                "Processing live video from camera",
+                title="Video Classification",
+                border_style="bold blue",
+            )
+        )
+    else:
+        layout["main"].update(
+            Panel(
+                f"Processing video: {input_source}",
+                title="Video Classification",
+                border_style="bold blue",
+            )
+        )
+
+    console.print(layout)
+
+    # Initialize pose tracker, embedder, and classifier
+    mp_pose = mp.solutions.pose
+    pose_tracker = mp_pose.Pose()
+    pose_embedder = FullBodyPoseEmbedding()
+    pose_classifier = PoseClassifier(
+        pose_samples_folder="data/yoga_poses_csvs_out",
+        pose_embedder=pose_embedder,
+        top_n_by_max_distance=30,
+        top_n_by_mean_distance=10,
+    )
+    pose_classification_filter = EMADictSmoothing(window_size=10, alpha=0.2)
+
+    # Open the video source
+    if is_live:
+        video = cv2.VideoCapture(0)
+        fps = 30  # Assume 30 fps for live video
+        total_frames = float("inf")  # Infinite frames for live video
+    else:
+        video = cv2.VideoCapture(input_source)
+        fps = video.get(cv2.CAP_PROP_FPS)
+        total_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    # Initialize pose timings (use lowercase for keys)
+    pose_timings = {
+        "chair": 0,
+        "cobra": 0,
+        "dog": 0,
+        "plank": 0,
+        "goddess": 0,
+        "tree": 0,
+        "warrior": 0,
+        "no pose detected": 0,
+        "fallen": 0,
+    }
+
+    frame_count = 0
+    while True:
+        ret, frame = video.read()
+        if not ret:
+            if is_live:
+                console.print(
+                    "[bold red]Error reading from camera. Exiting...[/bold red]"
+                )
+            break
+
+        # Process the frame
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        result = pose_tracker.process(image=frame_rgb)
+
+        if result.pose_landmarks is not None:
+            # Draw landmarks on the frame
+            mp.solutions.drawing_utils.draw_landmarks(
+                frame, result.pose_landmarks, mp_pose.POSE_CONNECTIONS
+            )
+
+            frame_height, frame_width = frame.shape[0], frame.shape[1]
+            pose_landmarks = np.array(
+                [
+                    [lmk.x * frame_width, lmk.y * frame_height, lmk.z * frame_width]
+                    for lmk in result.pose_landmarks.landmark
+                ],
+                dtype=np.float32,
+            )
+
+            # Classify the pose
+            pose_classification = pose_classifier(pose_landmarks)
+            pose_classification_filtered = pose_classification_filter(
+                pose_classification
+            )
+
+            # Update pose timings (only for the pose with highest confidence)
+            max_pose = max(
+                pose_classification_filtered, key=pose_classification_filtered.get
+            ).lower()
+            pose_timings[max_pose] += 1 / fps
+        else:
+            pose_timings["no pose detected"] += 1 / fps
+
+        frame_count += 1
+        if frame_count % 30 == 0:  # Update every 30 frames
+            panel_content = (
+                f"[bold]Chair:[/bold] {pose_timings['chair']:.2f}s\n"
+                f"[bold]Cobra:[/bold] {pose_timings['cobra']:.2f}s\n"
+                f"[bold]Dog:[/bold] {pose_timings['dog']:.2f}s\n"
+                f"[bold]Plank:[/bold] {pose_timings['plank']:.2f}s\n"
+                f"[bold]Goddess:[/bold] {pose_timings['goddess']:.2f}s\n"
+                f"[bold]Tree:[/bold] {pose_timings['tree']:.2f}s\n"
+                f"[bold]Warrior:[/bold] {pose_timings['warrior']:.2f}s\n"
+                f"---\n"
+                f"[bold]No pose detected:[/bold] {pose_timings['no pose detected']:.2f}s\n"
+                f"[bold]Fallen:[/bold] {pose_timings['fallen']:.2f}s"
+            )
+            if not is_live:
+                panel_content += f"\n\nProcessed {frame_count}/{total_frames} frames"
+
+            layout["main"].update(
+                Panel(
+                    panel_content,
+                    title="Classification Results",
+                    border_style="bold green",
+                )
+            )
+            console.print(layout)
+
+        if display:
+            cv2.imshow("Video", frame)
+            if cv2.waitKey(1) & 0xFF == ord("q"):
+                break
+
+    video.release()
+    if display:
+        cv2.destroyAllWindows()
+
+    # Final results
+    final_panel_content = (
+        f"[bold]Chair:[/bold] {pose_timings['chair']:.2f}s\n"
+        f"[bold]Cobra:[/bold] {pose_timings['cobra']:.2f}s\n"
+        f"[bold]Dog:[/bold] {pose_timings['dog']:.2f}s\n"
+        f"[bold]Plank:[/bold] {pose_timings['plank']:.2f}s\n"
+        f"[bold]Goddess:[/bold] {pose_timings['goddess']:.2f}s\n"
+        f"[bold]Tree:[/bold] {pose_timings['tree']:.2f}s\n"
+        f"[bold]Warrior:[/bold] {pose_timings['warrior']:.2f}s\n"
+        f"---\n"
+        f"[bold]No pose detected:[/bold] {pose_timings['no pose detected']:.2f}s\n"
+        f"[bold]Fallen:[/bold] {pose_timings['fallen']:.2f}s"
+    )
+    layout["main"].update(
+        Panel(
+            final_panel_content,
+            title="Final Classification Results",
+            border_style="bold green",
+        )
+    )
+    console.print(layout)
+
+    if output_file:
+        console.print(f"[green]Output saved to: {output_file}[/green]")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Classify poses in a video file or from live camera."
+    )
+    parser.add_argument("input", help="Input video file or 'live' for camera feed")
+    parser.add_argument(
+        "--display", action="store_true", help="Display the video with detected poses"
+    )
+    parser.add_argument("--output", help="Output video file")
+
+    if len(sys.argv) == 1:
+        parser.print_help(sys.stderr)
+        sys.exit(1)
+
+    args = parser.parse_args()
+
+    main(args.input, args.display, args.output)

hello.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from projet-acv-2!")
+
+
+if __name__ == "__main__":
+    main()

interface_pages/about_page.py

@@ -0,0 +1,11 @@
+import gradio as gr
+
+
+def about_page():
+    return gr.Markdown(
+        """
+    # About Us
+
+    WYOGAI — the BEST.
+    """
+    )

interface_pages/home_page.py

@@ -0,0 +1,11 @@
+import gradio as gr
+
+
+def home_page():
+    return gr.Markdown(
+        """
+    # Welcome to YOGAI App!
+    
+    This is your home page where you can explore different yoga practices.
+    """
+    )

interface_pages/yoga_position_from_stream.py

@@ -0,0 +1,31 @@
+import gradio as gr
+
+
+def yoga_position_from_stream():
+    def download_video(video_path):
+        if video_path:
+            return video_path
+        return None
+
+    with gr.Column() as yoga_stream:
+        gr.Markdown("# Yoga from Stream")
+        gr.Markdown(
+            "Stream live yoga sessions and practice along with our expert instructors."
+        )
+        video_feed = gr.Video(source="webcam", streaming=True, interactive=True)
+        download_button = gr.Button("Download Recorded Video")
+        video_output = gr.Video()
+
+        download_button.click(
+            download_video,
+            inputs=[video_feed],  # Changed from video_output to video_feed
+            outputs=[gr.File()],
+        )
+
+    return yoga_stream
+
+
+if __name__ == "__main__":
+    with gr.Blocks() as demo:
+        yoga_position_from_stream()
+    demo.launch()

interface_pages/yoga_position_from_video.py

@@ -0,0 +1,17 @@
+import gradio as gr
+
+
+def yoga_position_from_video():
+    return gr.Markdown(
+        """
+    # Yoga from Video
+
+    Watch pre-recorded yoga sessions and practice at your convenience.
+
+    Select a video below:
+
+    - Beginner Yoga
+    - Advanced Techniques
+    - Restorative Yoga
+    """
+    )

pushups_counter.py

@@ -0,0 +1,162 @@
+import tqdm
+import cv2
+import numpy as np
+from mediapipe.python.solutions import drawing_utils as mp_drawing
+import mediapipe as mp
+from PoseClassification.pose_embedding import FullBodyPoseEmbedding
+from PoseClassification.pose_classifier import PoseClassifier
+from PoseClassification.utils import EMADictSmoothing
+from PoseClassification.utils import RepetitionCounter
+from PoseClassification.visualize import PoseClassificationVisualizer
+
+mp_pose = mp.solutions.pose
+pose_tracker = mp_pose.Pose()
+
+pose_samples_folder = "data/fitness_poses_csvs_out"
+class_name = "pushups_down"
+
+pose_embedder = FullBodyPoseEmbedding()
+
+pose_classifier = PoseClassifier(
+    pose_samples_folder=pose_samples_folder,
+    pose_embedder=pose_embedder,
+    top_n_by_max_distance=30,
+    top_n_by_mean_distance=10,
+)
+
+pose_classification_filter = EMADictSmoothing(window_size=10, alpha=0.2)
+
+repetition_counter = RepetitionCounter(
+    class_name=class_name, enter_threshold=6, exit_threshold=4
+)
+
+pose_classification_visualizer = PoseClassificationVisualizer(
+    class_name=class_name, plot_x_max=1000, plot_y_max=10
+)
+
+video_cap = cv2.VideoCapture(0)
+video_fps = 30
+video_width = 1280
+video_height = 720
+video_cap.set(cv2.CAP_PROP_FRAME_WIDTH, video_width)
+video_cap.set(cv2.CAP_PROP_FRAME_HEIGHT, video_height)
+
+frame_idx = 0
+output_frame = None
+
+try:
+    with tqdm.tqdm(position=0, leave=True) as pbar:
+        while True:
+            success, input_frame = video_cap.read()
+            if not success:
+                print("Unable to read input video frame, breaking!")
+                break
+
+            # Run pose tracker
+            input_frame_rgb = cv2.cvtColor(input_frame, cv2.COLOR_BGR2RGB)
+            result = pose_tracker.process(image=input_frame_rgb)
+            pose_landmarks = result.pose_landmarks
+
+            # Prepare the output frame
+            output_frame = input_frame.copy()
+
+            # Add a white banner on top
+            banner_height = 180
+            output_frame[0:banner_height, :] = (255, 255, 255)  # White color
+
+            # Load the logo image
+            logo = cv2.imread("src/logo_impredalam.jpg")
+            logo_height, logo_width = logo.shape[:2]
+            logo = cv2.resize(
+                logo, (logo_width // 3, logo_height // 3)
+            )  # Resize to 1/3 scale
+
+            # Overlay the logo on the upper right corner
+            output_frame[0 : logo.shape[0], output_frame.shape[1] - logo.shape[1] :] = (
+                logo
+            )
+            if pose_landmarks is not None:
+                mp_drawing.draw_landmarks(
+                    image=output_frame,
+                    landmark_list=pose_landmarks,
+                    connections=mp_pose.POSE_CONNECTIONS,
+                )
+
+                # Get landmarks
+                frame_height, frame_width = output_frame.shape[0], output_frame.shape[1]
+                pose_landmarks = np.array(
+                    [
+                        [lmk.x * frame_width, lmk.y * frame_height, lmk.z * frame_width]
+                        for lmk in pose_landmarks.landmark
+                    ],
+                    dtype=np.float32,
+                )
+                assert pose_landmarks.shape == (
+                    33,
+                    3,
+                ), "Unexpected landmarks shape: {}".format(pose_landmarks.shape)
+
+                # Classify the pose on the current frame
+                pose_classification = pose_classifier(pose_landmarks)
+
+                # Smooth classification using EMA
+                pose_classification_filtered = pose_classification_filter(
+                    pose_classification
+                )
+
+                # Count repetitions
+                repetitions_count = repetition_counter(pose_classification_filtered)
+
+                # Display repetitions count on the frame
+                cv2.putText(
+                    output_frame,
+                    f"Push-Ups: {repetitions_count}",
+                    (10, 30),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    1,
+                    (0, 0, 0),
+                    2,
+                    cv2.LINE_AA,
+                )
+                # Display classified pose on the frame
+                cv2.putText(
+                    output_frame,
+                    f"Pose: {pose_classification}",
+                    (10, 70),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    1.2,  # Smaller font size
+                    (0, 0, 0),
+                    1,  # Thinner line
+                    cv2.LINE_AA,
+                )
+            else:
+                # If no landmarks are detected, still display the last count
+                repetitions_count = repetition_counter.n_repeats
+                cv2.putText(
+                    output_frame,
+                    f"Push-Ups: {repetitions_count}",
+                    (10, 30),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    1,
+                    (0, 255, 0),
+                    2,
+                    cv2.LINE_AA,
+                )
+
+            cv2.imshow("Push-Up Counter", output_frame)
+
+            key = cv2.waitKey(1) & 0xFF
+            if key == ord("q"):
+                break
+            elif key == ord("r"):
+                repetition_counter.reset()
+                print("Counter reset!")
+
+            frame_idx += 1
+            pbar.update()
+
+finally:
+
+    pose_tracker.close()
+    video_cap.release()
+    cv2.destroyAllWindows()

pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "projet-acv-2"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "argparse>=1.4.0",
+    "ffmpeg>=1.4",
+    "gradio>=3.36.1",
+    "jupyter>=1.1.1",
+    "matplotlib>=3.9.2",
+    "mediapipe>=0.10.15",
+    "numpy>=1.26.4",
+    "opencv-python>=4.10.0.84",
+    "pillow>=11.0.0",
+    "plotly>=5.24.1",
+    "pyfiglet>=1.0.2",
+    "requests>=2.32.3",
+    "rich>=13.9.2",
+    "scikit-learn>=1.5.2",
+    "streamlit>=1.9.0",
+    "tqdm>=4.66.5",
+]

requirements.txt

@@ -0,0 +1,16 @@
+argparse>=1.4.0
+ffmpeg>=1.4
+gradio>=3.36.1
+jupyter>=1.1.1
+matplotlib>=3.9.2
+mediapipe>=0.10.15
+numpy>=1.26.4
+opencv-python>=4.10.0.84
+pillow>=11.0.0
+plotly>=5.24.1
+pyfiglet>=1.0.2
+requests>=2.32.3
+rich>=13.9.2
+scikit-learn>=1.5.2
+streamlit>=1.9.0
+tqdm>=4.66.5

static/styles.css

@@ -0,0 +1,24 @@
+.menu-column {
+    background-color: #4CAF50; /* Background color of the menu */
+    padding: 20px; /* Padding around the menu */
+    height: 100vh; /* Full height for the menu */
+}
+
+.menu-button {
+    color: white; /* Text color for the buttons */
+    background-color: transparent; /* Transparent background */
+    border: none; /* No border */
+    padding: 10px 15px; /* Padding for the buttons */
+    width: 100%; /* Full width for buttons */
+    text-align: left; /* Align text to the left */
+    cursor: pointer; /* Pointer cursor on hover */
+    transition: background-color 0.3s; /* Smooth transition */
+}
+
+.menu-button:hover {
+    background-color: rgba(255, 255, 255, 0.2); /* Light hover effect */
+}
+
+.gradio-container {
+    margin-top: 0; /* Remove top margin to allow for full height */
+}

yoga_position.py

@@ -0,0 +1,515 @@
+import tqdm
+import cv2
+import numpy as np
+import re
+import os 
+from mediapipe.python.solutions import drawing_utils as mp_drawing
+import mediapipe as mp
+from PoseClassification.pose_embedding import FullBodyPoseEmbedding
+from PoseClassification.pose_classifier import PoseClassifier
+from PoseClassification.utils import EMADictSmoothing
+# from PoseClassification.utils import RepetitionCounter
+from PoseClassification.visualize import PoseClassificationVisualizer
+import argparse
+from PoseClassification.utils import show_image
+
+def main():
+    #Load arguments
+    parser = argparse.ArgumentParser()
+    parser.add_argument("video_path", help="string video path in")
+    args = parser.parse_args()
+
+    video_path_in = args.video_path
+    direct_video=False
+    if video_path_in=="live":
+        video_path_in='data/live.mp4'
+        direct_video=True
+
+    video_path_out = re.sub(r'.mp4', r'_classified_video.mp4', video_path_in)
+    results_classification_path_out = re.sub(r'.mp4', r'_classified_results.csv', video_path_in)
+
+
+    # Instruction if direct flux video : not for now
+    if direct_video :
+        video_cap = cv2.VideoCapture(0)
+        video_fps = 30
+        video_width = 1280
+        video_height = 720
+
+        class_name='tree'
+
+        # Initialize tracker, classifier and current position.
+        # Initialize tracker.
+        mp_pose = mp.solutions.pose
+        pose_tracker = mp_pose.Pose()
+        # Folder with pose class CSVs. That should be the same folder you used while
+        # building classifier to output CSVs.
+        pose_samples_folder = 'data/yoga_poses_csvs_out'
+        # Initialize embedder.
+        pose_embedder = FullBodyPoseEmbedding()
+        # Initialize classifier.
+        # Check that you are using the same parameters as during bootstrapping.
+        pose_classifier = PoseClassifier(
+            pose_samples_folder=pose_samples_folder,
+            pose_embedder=pose_embedder,
+            top_n_by_max_distance=30,
+            top_n_by_mean_distance=10)
+        
+        # Initialize list of results
+        position_list=[]
+        frame_list=[]
+
+        # Initialize EMA smoothing.
+        pose_classification_filter = EMADictSmoothing(
+            window_size=10,
+            alpha=0.2)
+        
+        # Initialize renderer.
+        pose_classification_visualizer = PoseClassificationVisualizer(
+            class_name=class_name,
+            plot_x_max=1000,
+            # Graphic looks nicer if it's the same as `top_n_by_mean_distance`.
+            plot_y_max=10)
+
+        # Open output video.
+        out_video = cv2.VideoWriter(video_path_out, cv2.VideoWriter_fourcc(*'mp4v'), video_fps, (video_width, video_height))
+
+        # Initialize list of results
+        frame_idx = 0
+        current_position = {"none":10.0}
+
+        output_frame = None
+        try:
+            with tqdm.tqdm(position=0, leave=True) as pbar:
+                while True:
+                    #on rajoute à chaque itération la valeur de current_position et de frame_idx
+                    position_list.append(current_position)
+                    frame_list.append(frame_idx)
+
+                    #on renvoie les deux valeurs au fur et à mesure
+                    with open(results_classification_path_out, 'a') as f:
+                        f.write(f'{frame_idx};{current_position}\n')
+
+                    success, input_frame = video_cap.read()
+                    if not success:
+                        print("Unable to read input video frame, breaking!")
+                        break
+
+                    # Run pose tracker
+                    input_frame_rgb = cv2.cvtColor(input_frame, cv2.COLOR_BGR2RGB)
+                    result = pose_tracker.process(image=input_frame_rgb)
+                    pose_landmarks = result.pose_landmarks
+
+                    # Prepare the output frame
+                    output_frame = input_frame.copy()
+
+                    # Add a white banner on top
+                    banner_height = 180
+                    output_frame[0:banner_height, :] = (255, 255, 255)  # White color
+
+                    # Load the logo image
+                    logo = cv2.imread("src/logo_impredalam.jpg")
+                    logo_height, logo_width = logo.shape[:2]
+                    logo = cv2.resize(
+                        logo, (logo_width // 3, logo_height // 3)
+                    )  # Resize to 1/3 scale
+
+                    # Overlay the logo on the upper right corner
+                    output_frame[0 : logo.shape[0], output_frame.shape[1] - logo.shape[1] :] = (
+                        logo
+                    )
+                    if pose_landmarks is not None:
+                        mp_drawing.draw_landmarks(
+                            image=output_frame,
+                            landmark_list=pose_landmarks,
+                            connections=mp_pose.POSE_CONNECTIONS,
+                        )
+
+                        # Get landmarks
+                        frame_height, frame_width = output_frame.shape[0], output_frame.shape[1]
+                        pose_landmarks = np.array(
+                            [
+                                [lmk.x * frame_width, lmk.y * frame_height, lmk.z * frame_width]
+                                for lmk in pose_landmarks.landmark
+                            ],
+                            dtype=np.float32,
+                        )
+                        assert pose_landmarks.shape == (
+                            33,
+                            3,
+                        ), "Unexpected landmarks shape: {}".format(pose_landmarks.shape)
+
+                        # Classify the pose on the current frame
+                        pose_classification = pose_classifier(pose_landmarks)
+
+                        # Smooth classification using EMA
+                        pose_classification_filtered = pose_classification_filter(pose_classification)
+                        current_position=pose_classification_filtered
+
+                        # Count repetitions
+                        # repetitions_count = repetition_counter(pose_classification_filtered)
+
+                        # Display repetitions count on the frame
+                        # cv2.putText(
+                        #     output_frame,
+                        #     f"Push-Ups: {repetitions_count}",
+                        #     (10, 30),
+                        #     cv2.FONT_HERSHEY_SIMPLEX,
+                        #     1,
+                        #     (0, 0, 0),
+                        #     2,
+                        #     cv2.LINE_AA,
+                        # )
+                        # Display classified pose on the frame
+                        cv2.putText(
+                            output_frame,
+                            f"Pose: {current_position}",
+                            (10, 70),
+                            cv2.FONT_HERSHEY_SIMPLEX,
+                            1.2,  # Smaller font size
+                            (0, 0, 0),
+                            1,  # Thinner line
+                            cv2.LINE_AA,
+                        )
+                    else:
+                        # If no landmarks are detected, still display the last count
+                        # repetitions_count = repetition_counter.n_repeats
+                        # cv2.putText(
+                        #     output_frame,
+                        #     f"Push-Ups: {repetitions_count}",
+                        #     (10, 30),
+                        #     cv2.FONT_HERSHEY_SIMPLEX,
+                        #     1,
+                        #     (0, 255, 0),
+                        #     2,
+                        #     cv2.LINE_AA,
+                        # )
+                        current_position={'None':10.0}
+                        cv2.putText(
+                            output_frame,
+                            f"Pose: {current_position}",
+                            (10, 70),
+                            cv2.FONT_HERSHEY_SIMPLEX,
+                            1.2,  # Smaller font size
+                            (0, 0, 0),
+                            1,  # Thinner line
+                            cv2.LINE_AA,
+                        )
+
+                    cv2.imshow("Yoga position classification", output_frame)
+
+                    key = cv2.waitKey(1) & 0xFF
+                    if key == ord("q"):
+                        break
+                    elif key == ord("r"):
+                        # repetition_counter.reset()
+                        print("Counter reset!")
+
+                    frame_idx += 1
+                    pbar.update()
+
+        finally:
+
+            pose_tracker.close()
+            video_cap.release()
+            cv2.destroyAllWindows()
+        
+    # Instruction if recorded video with video_path_in
+    else:
+        assert type(video_path_in)==str, "Error in video path format, not a string. Abort."
+        # Open video and get video parameters and check if video is OK 
+        video_cap = cv2.VideoCapture(video_path_in)
+        video_n_frames = video_cap.get(cv2.CAP_PROP_FRAME_COUNT)
+        video_fps = video_cap.get(cv2.CAP_PROP_FPS)
+        video_width = int(video_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        video_height = int(video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        assert type(video_n_frames)==float, 'Error in input video frames type. Abort.'
+        assert video_n_frames>0.0, 'Error in input video frames number : no frame. Abort.'
+
+        class_name='tree'
+
+        # Initialize tracker, classifier and current position.
+        # Initialize tracker.
+        mp_pose = mp.solutions.pose
+        pose_tracker = mp_pose.Pose()
+        # Folder with pose class CSVs. That should be the same folder you used while
+        # building classifier to output CSVs.
+        pose_samples_folder = 'data/yoga_poses_csvs_out'
+        # Initialize embedder.
+        pose_embedder = FullBodyPoseEmbedding()
+        # Initialize classifier.
+        # Check that you are using the same parameters as during bootstrapping.
+        pose_classifier = PoseClassifier(
+            pose_samples_folder=pose_samples_folder,
+            pose_embedder=pose_embedder,
+            top_n_by_max_distance=30,
+            top_n_by_mean_distance=10)
+        
+        # Initialize list of results
+        position_list=[]
+        frame_list=[]
+
+        # Initialize EMA smoothing.
+        pose_classification_filter = EMADictSmoothing(
+            window_size=10,
+            alpha=0.2)
+        
+        # Initialize renderer.
+        pose_classification_visualizer = PoseClassificationVisualizer(
+            class_name=class_name,
+            plot_x_max=video_n_frames,
+            # Graphic looks nicer if it's the same as `top_n_by_mean_distance`.
+            plot_y_max=10)
+
+        # Open output video.
+        out_video = cv2.VideoWriter(video_path_out, cv2.VideoWriter_fourcc(*'mp4v'), video_fps, (video_width, video_height))
+
+        # Initialize list of results
+        frame_idx = 0
+        current_position = {"none":10.0}
+
+        output_frame = None
+        with tqdm.tqdm(total=video_n_frames, position=0, leave=True) as pbar:
+            while True:
+                #on rajoute à chaque itération la valeur de current_position et de frame_idx
+                position_list.append(current_position)
+                frame_list.append(frame_idx)
+
+                #on renvoie les deux valeurs au fur et à mesure
+                with open(results_classification_path_out, 'a') as f:
+                    f.write(f'{frame_idx};{current_position}\n')
+
+                # Get next frame of the video.
+                success, input_frame = video_cap.read()
+                if not success:
+                    print("unable to read input video frame, breaking!")
+                    break
+
+                # Run pose tracker.
+                input_frame = cv2.cvtColor(input_frame, cv2.COLOR_BGR2RGB)
+                result = pose_tracker.process(image=input_frame)
+                pose_landmarks = result.pose_landmarks
+
+                # Draw pose prediction.
+                output_frame = input_frame.copy()
+                if pose_landmarks is not None:
+                    mp_drawing.draw_landmarks(
+                        image=output_frame,
+                        landmark_list=pose_landmarks,
+                        connections=mp_pose.POSE_CONNECTIONS)
+                
+                if pose_landmarks is not None:
+                    # Get landmarks.
+                    frame_height, frame_width = output_frame.shape[0], output_frame.shape[1]
+                    pose_landmarks = np.array([[lmk.x * frame_width, lmk.y * frame_height, lmk.z * frame_width]
+                                                for lmk in pose_landmarks.landmark], dtype=np.float32)
+                    assert pose_landmarks.shape == (33, 3), 'Unexpected landmarks shape: {}'.format(pose_landmarks.shape)
+
+                    # Classify the pose on the current frame.
+                    pose_classification = pose_classifier(pose_landmarks)
+
+                    # Smooth classification using EMA.
+                    pose_classification_filtered = pose_classification_filter(pose_classification)
+
+                    current_position=pose_classification_filtered
+                    # Count repetitions.
+                    #   repetitions_count = repetition_counter(pose_classification_filtered)
+                else:
+                    # No pose => no classification on current frame.
+                    pose_classification = None
+
+                    # Still add empty classification to the filter to maintaing correct
+                    # smoothing for future frames.
+                    pose_classification_filtered = pose_classification_filter(dict())
+                    pose_classification_filtered = None
+
+                    current_position='None'
+                    # Don't update the counter presuming that person is 'frozen'. Just
+                    # take the latest repetitions count.
+                    #   repetitions_count = repetition_counter.n_repeats
+
+                # Draw classification plot and repetition counter.
+                output_frame = pose_classification_visualizer(
+                    frame=output_frame,
+                    pose_classification=pose_classification,
+                    pose_classification_filtered=pose_classification_filtered,
+                    repetitions_count='0'
+                    )
+
+                # Save the output frame.
+                out_video.write(cv2.cvtColor(np.array(output_frame), cv2.COLOR_RGB2BGR))
+
+                # Show intermediate frames of the video to track progress.
+                if frame_idx % 50 == 0:
+                    show_image(output_frame)
+
+                frame_idx += 1
+                pbar.update()
+
+        # Close output video.
+        out_video.release()
+
+        # Release MediaPipe resources.
+        pose_tracker.close()
+
+        # Show the last frame of the video.
+        if output_frame is not None:
+            show_image(output_frame)
+
+        video_cap.release()
+
+        
+
+    
+    return current_position #string between ['Chair', 'Cobra', 'Dog', 'Goddess', 'Plank', 'Tree', 'Warrior', 'None' = nonfallen, 'Fall']
+
+# mp_pose = mp.solutions.pose
+# pose_tracker = mp_pose.Pose()
+
+# pose_samples_folder = "data/yoga_poses_csvs_out"
+# class_name = "tree"
+
+# pose_embedder = FullBodyPoseEmbedding()
+
+# pose_classifier = PoseClassifier(
+#     pose_samples_folder=pose_samples_folder,
+#     pose_embedder=pose_embedder,
+#     top_n_by_max_distance=30,
+#     top_n_by_mean_distance=10,
+# )
+
+# pose_classification_filter = EMADictSmoothing(window_size=10, alpha=0.2)
+
+# repetition_counter = RepetitionCounter(
+#     class_name=class_name, enter_threshold=6, exit_threshold=4
+# )
+
+# pose_classification_visualizer = PoseClassificationVisualizer(
+#     class_name=class_name, plot_x_max=1000, plot_y_max=10
+# )
+
+# video_cap = cv2.VideoCapture(0)
+# video_fps = 30
+# video_width = int(video_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+# video_height = int(video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+# frame_idx = 0
+# output_frame = None
+
+# try:
+#     with tqdm.tqdm(position=0, leave=True) as pbar:
+#         while True:
+#             success, input_frame = video_cap.read()
+#             if not success:
+#                 print("Unable to read input video frame, breaking!")
+#                 break
+
+#             # Run pose tracker
+#             input_frame_rgb = cv2.cvtColor(input_frame, cv2.COLOR_BGR2RGB)
+#             result = pose_tracker.process(image=input_frame_rgb)
+#             pose_landmarks = result.pose_landmarks
+
+#             # Prepare the output frame
+#             output_frame = input_frame.copy()
+#             if pose_landmarks is not None:
+#                 mp_drawing.draw_landmarks(
+#                     image=output_frame,
+#                     landmark_list=pose_landmarks,
+#                     connections=mp_pose.POSE_CONNECTIONS,
+#                 )
+
+#                 # Get landmarks
+#                 frame_height, frame_width = output_frame.shape[0], output_frame.shape[1]
+#                 pose_landmarks = np.array(
+#                     [
+#                         [lmk.x * frame_width, lmk.y * frame_height, lmk.z * frame_width]
+#                         for lmk in pose_landmarks.landmark
+#                     ],
+#                     dtype=np.float32,
+#                 )
+#                 assert pose_landmarks.shape == (
+#                     33,
+#                     3,
+#                 ), "Unexpected landmarks shape: {}".format(pose_landmarks.shape)
+
+#                 # Classify the pose on the current frame
+#                 pose_classification = pose_classifier(pose_landmarks)
+
+#                 # Smooth classification using EMA
+#                 pose_classification_filtered = pose_classification_filter(
+#                     pose_classification
+#                 )
+
+#                 # Count repetitions
+#                 # repetitions_count = repetition_counter(pose_classification_filtered)
+
+#                 # Display repetitions count on the frame
+#                 # cv2.putText(
+#                 #     output_frame,
+#                 #     f"Push-Ups: {repetitions_count}",
+#                 #     (10, 30),
+#                 #     cv2.FONT_HERSHEY_SIMPLEX,
+#                 #     1,
+#                 #     (0, 255, 0),
+#                 #     2,
+#                 #     cv2.LINE_AA,
+#                 # )
+
+#                 # Display classified pose on the frame
+#                 cv2.putText(
+#                     output_frame,
+#                     f"Pose: {pose_classification}",
+#                     (10, 70),
+#                     cv2.FONT_HERSHEY_SIMPLEX,
+#                     1,
+#                     (255, 0, 0),
+#                     2,
+#                     cv2.LINE_AA,
+#                 )
+#             else:
+#                 # If no landmarks are detected, still display the last count
+#                 # repetitions_count = repetition_counter.n_repeats
+#                 # cv2.putText(
+#                 #     output_frame,
+#                 #     f"Push-Ups: {repetitions_count}",
+#                 #     (10, 30),
+#                 #     cv2.FONT_HERSHEY_SIMPLEX,
+#                 #     1,
+#                 #     (0, 255, 0),
+#                 #     2,
+#                 #     cv2.LINE_AA,
+#                 # )
+#                 # If no landmarks are detected, still display the last classified pose
+#                 # Display classified pose on the frame
+#                 cv2.putText(
+#                     output_frame,
+#                     f"Pose: {pose_classification}",
+#                     (10, 70),
+#                     cv2.FONT_HERSHEY_SIMPLEX,
+#                     1,
+#                     (255, 0, 0),
+#                     2,
+#                     cv2.LINE_AA,
+#                 )
+
+#             cv2.imshow("Yoga pose classification", output_frame)
+
+#             key = cv2.waitKey(1) & 0xFF
+#             if key == ord("q"):
+#                 break
+#             elif key == ord("r"):
+#                 # repetition_counter.reset()
+#                 print("Counter reset!")
+
+#             frame_idx += 1
+#             pbar.update()
+
+# finally:
+
+#     pose_tracker.close()
+#     video_cap.release()
+#     cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    main()

yoga_position_gradio.py

@@ -0,0 +1,248 @@
+import tqdm
+import cv2
+import numpy as np
+import re
+import os 
+from mediapipe.python.solutions import drawing_utils as mp_drawing
+import mediapipe as mp
+from PoseClassification.pose_embedding import FullBodyPoseEmbedding
+from PoseClassification.pose_classifier import PoseClassifier
+from PoseClassification.utils import EMADictSmoothing
+# from PoseClassification.utils import RepetitionCounter
+from PoseClassification.visualize import PoseClassificationVisualizer
+import argparse
+from PoseClassification.utils import show_image
+
+
+def check_major_current_position(positions_detected:dict, threshold_position) -> str:
+    '''
+    return the major position between those detected in frame, or return none
+
+    INPUTS
+        positions_detected : 
+            dict of positions given by position classifier and pose_classification_filtered
+            {'pose1':8.0, 'pose2':2.0}
+        threshold_position :
+            values strictly below are considered "none" position
+
+    OUTPUT
+        major_position :
+            string with position (classes from classifier and "none")
+    
+    '''
+    if max(positions_detected.values())<float(threshold_position):
+        major_position='none'
+    else:
+        major_position=max(positions_detected, key=positions_detected.get)
+    return major_position
+
+
+def yoga_position_classifier():
+    #Load arguments
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("video_path", help="string video path in")
+    args = parser.parse_args()
+
+    video_path_in = args.video_path
+    direct_video=False
+
+    if video_path_in=="live":
+        video_path_in='data/live.mp4'
+        direct_video=True
+
+    video_path_out = re.sub(r'.mp4', r'_classified_video.mp4', video_path_in)
+    results_classification_path_out = re.sub(r'.mp4', r'_classified_results.csv', video_path_in)
+
+
+    # Initialize tracker, classifier and current position.
+    # Initialize tracker.
+    mp_pose = mp.solutions.pose
+    pose_tracker = mp_pose.Pose()
+    # Folder with pose class CSVs. That should be the same folder you used while
+    # building classifier to output CSVs.
+    pose_samples_folder = 'data/yoga_poses_csvs_out'
+    # Initialize embedder.
+    pose_embedder = FullBodyPoseEmbedding()
+    # Initialize classifier.
+    # Check that you are using the same parameters as during bootstrapping.
+    pose_classifier = PoseClassifier(
+        pose_samples_folder=pose_samples_folder,
+        pose_embedder=pose_embedder,
+        top_n_by_max_distance=30,
+        top_n_by_mean_distance=10)
+    
+
+    # Initialize EMA smoothing.
+    pose_classification_filter = EMADictSmoothing(
+        window_size=10,
+        alpha=0.2)
+    
+
+    # Initialize list of results
+    position_list=[]
+    frame_list=[]
+
+    # Instruction if direct flux video
+    if direct_video :
+        video_cap = cv2.VideoCapture(0) 
+    # Instruction if path video
+    else :
+        assert type(video_path_in)==str, "Error in video path format, not a string. Abort."
+        # Open video and get video parameters and check if video is OK 
+        video_cap = cv2.VideoCapture(video_path_in)
+        video_n_frames = video_cap.get(cv2.CAP_PROP_FRAME_COUNT)
+        assert type(video_n_frames)==float, 'Error in input video frames type. Abort.'
+        assert video_n_frames>0.0, 'Error in input video frames number : no frame. Abort.'
+
+    video_fps = video_cap.get(cv2.CAP_PROP_FPS) 
+    video_width = int(video_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    video_height = int(video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+    class_names=['chair', 'cobra', 'dog', 'goddess', 'plank', 'tree', 'warrior', 'none']
+    position_threshold = 8.0
+
+    # Open output video.
+    out_video = cv2.VideoWriter(video_path_out, cv2.VideoWriter_fourcc(*'mp4v'), video_fps, (video_width, video_height))
+
+    # Initialize results 
+    frame_idx = 0
+    current_position = {"none":10.0}
+    output_frame = None
+
+    position_timer = 0
+    previous_position_major = 'none'
+
+    try:
+        with tqdm.tqdm(position=0, leave=True) as pbar:
+            while True:
+                # Get current time from beggining of video 
+                time_sec = float(frame_idx*(1/video_fps))
+
+                # Get current major position (str)
+                current_position_major = check_major_current_position(current_position, position_threshold)
+
+                success, input_frame = video_cap.read()
+                if not success:
+                    print("Unable to read input video frame, breaking!")
+                    break
+
+                # Run pose tracker
+                input_frame_rgb = cv2.cvtColor(input_frame, cv2.COLOR_BGR2RGB)
+                result = pose_tracker.process(image=input_frame_rgb)
+                pose_landmarks = result.pose_landmarks
+
+                # Prepare the output frame
+                output_frame = input_frame.copy()
+
+                # Add a white banner on top
+                banner_height = int(video_height//10)
+                output_frame[0:banner_height, :] = (255, 255, 255)  # White color
+
+                # Load the logo image
+                logo = cv2.imread("src/logo_impredalam.jpg")
+                logo_height, logo_width = logo.shape[:2]
+                logo_height_rescaled = banner_height
+                logo_width_rescaled = int((logo_width*logo_height_rescaled)// logo_height )
+                logo = cv2.resize(logo, (logo_width_rescaled, logo_height_rescaled))  # Resize to banner scale
+
+                # Overlay the logo on the upper right corner
+                output_frame[0 : logo.shape[0], output_frame.shape[1] - logo.shape[1] :] = (logo)
+
+                # If landmarks are detected 
+                if pose_landmarks is not None:
+                    mp_drawing.draw_landmarks(
+                        image=output_frame,
+                        landmark_list=pose_landmarks,
+                        connections=mp_pose.POSE_CONNECTIONS,)
+
+                    # Get landmarks
+                    frame_height, frame_width = output_frame.shape[0], output_frame.shape[1]
+                    pose_landmarks = np.array(
+                        [
+                            [lmk.x * frame_width, lmk.y * frame_height, lmk.z * frame_width]
+                            for lmk in pose_landmarks.landmark
+                        ],
+                        dtype=np.float32,)
+                    assert pose_landmarks.shape == (33,3,), "Unexpected landmarks shape: {}".format(pose_landmarks.shape)
+
+                    # Classify the pose on the current frame
+                    pose_classification = pose_classifier(pose_landmarks)
+
+                    # Smooth classification using EMA
+                    pose_classification_filtered = pose_classification_filter(pose_classification)
+                    current_position=pose_classification_filtered
+                    current_position_major=check_major_current_position(current_position, position_threshold)
+
+                # If no landmarks are detected
+                else:
+
+                    current_position={'none':10.0}
+                    current_position_major=check_major_current_position(current_position, position_threshold)
+
+                
+                # If landmarks or no landmarks detected : 
+
+                # Compute position timer according to current and previous position
+                if current_position_major==previous_position_major:
+                    #increase position_timer
+                    position_timer+=(1/video_fps)
+                else:
+                    previous_position_major=current_position_major
+                    position_timer=0
+
+                # Display current position on frame
+                cv2.putText(
+                    output_frame,
+                    f"Pose: {current_position_major}",
+                    (int(0+(1//50*video_width)), int(0+banner_height//3)), #coord
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    float(0.9*(video_height/video_width)),  # Font size
+                    (0, 0, 0), #color
+                    1,  # Thinner line
+                    cv2.LINE_AA,)
+
+                # Display current position timer on frame
+                cv2.putText(
+                    output_frame,
+                    f"Duration: {int(position_timer)} seconds",
+                    (int(0+(1//50*video_width)), int(0+(2*banner_height)//3)), #coord
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    float(0.9*(video_height/video_width)),  # Font size
+                    (0, 0, 0), #color
+                    1,  # Thinner line
+                    cv2.LINE_AA,)
+                
+                # Show output frame
+                cv2.imshow("Yoga position", output_frame)
+
+                # Add current_position (dict) and frame index to list (output file for debug)
+                position_list.append(current_position)
+                frame_list.append(frame_idx)
+                # Output file for debug
+                with open(results_classification_path_out, 'a') as f:
+                    f.write(f'{frame_idx},{current_position}\n')
+
+                key = cv2.waitKey(1) & 0xFF
+                if key == ord("q"):
+                    break
+                elif key == ord("r"):
+                    current_position = {'none':10.0}
+                    print("Position reset !")
+
+                frame_idx += 1
+                pbar.update()
+
+    finally:
+        pose_tracker.close()
+        video_cap.release()
+        cv2.destroyAllWindows()
+        # Close output video.
+        out_video.release()
+
+    return frame_list, position_list 
+
+
+
+if __name__ == "__main__":
+    yoga_position_classifier()