ImagePRO-Python 0.1.0__py3-none-any.whl

ImagePRO/human_analysis/body_analysis/body_pose_estimation.py

@@ -0,0 +1,129 @@
+import sys
+from pathlib import Path
+
+import cv2
+import mediapipe as mp
+
+# Add parent directory to import custom modules
+parent_dir = Path(__file__).resolve().parent.parent.parent
+sys.path.append(str(parent_dir))
+
+from io_handler import IOHandler
+
+mp_pose = mp.solutions.pose
+
+def detect_body_pose(
+    model_accuracy=0.7,
+    landmarks_idx=None,
+    image_path=None,
+    np_image=None,
+    result_path=None,
+    pose_obj=None
+):
+    """
+    Detects body landmarks from an image using MediaPipe Pose.
+
+    Args:
+        model_accuracy (float): Confidence threshold (0.0 to 1.0).
+        landmarks_idx (list[int] | None): Indices to extract (default: all 33).
+        image_path (str | None): Path to image file.
+        np_image (np.ndarray | None): Already loaded image (used if image_path is None).
+        result_path (str | None): Path to save image (.jpg) or coordinates (.csv).
+        pose_obj (mp.solutions.pose.Pose | None): Optional pre-initialized pose model.
+
+    Returns:
+        str | tuple[np.ndarray, list]: Output message or annotated image and landmark list.
+    """
+    if landmarks_idx is not None and not isinstance(landmarks_idx, list):
+        raise TypeError("'landmarks_idx' must be a list or None.")
+
+    if result_path:
+        if not isinstance(result_path, str):
+            raise TypeError("'result_path' must be a string.")
+        if not (result_path.endswith('.jpg') or result_path.endswith('.csv')):
+            raise ValueError("Supported extensions: '.jpg', '.csv'.")
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+
+    if landmarks_idx is None:
+        landmarks_idx = list(range(33))
+
+    if pose_obj is None:
+        pose_obj = mp_pose.Pose(
+            min_detection_confidence=model_accuracy,
+            static_image_mode=True
+        )
+
+    image_rgb = cv2.cvtColor(np_image, cv2.COLOR_BGR2RGB)
+    result = pose_obj.process(image_rgb)
+
+    annotated_image = np_image.copy()
+    all_landmarks = []
+
+    if result.pose_landmarks:
+        if result_path is None or result_path.endswith('.jpg'):
+            if len(landmarks_idx) == 33:
+                mp.solutions.drawing_utils.draw_landmarks(
+                    annotated_image,
+                    result.pose_landmarks,
+                    mp_pose.POSE_CONNECTIONS,
+                    landmark_drawing_spec=mp.solutions.drawing_styles.get_default_pose_landmarks_style()
+                )
+            else:
+                h, w, _ = annotated_image.shape
+                for idx in landmarks_idx:
+                    lm = result.pose_landmarks.landmark[idx]
+                    x, y = int(w * lm.x), int(h * lm.y)
+                    cv2.circle(annotated_image, (x, y), 3, (0, 0, 255), -1)
+
+        if result_path is None or result_path.endswith('.csv'):
+            for idx in landmarks_idx:
+                lm = result.pose_landmarks.landmark[idx]
+                all_landmarks.append([idx, lm.x, lm.y, lm.z])
+
+    if result_path:
+        if result_path.endswith('.jpg'):
+            return IOHandler.save_image(annotated_image, result_path)
+        elif result_path.endswith('.csv'):
+            return IOHandler.save_csv(all_landmarks, result_path)
+    else:
+        return annotated_image, all_landmarks
+
+
+def detect_body_pose_live():
+    """
+    Starts webcam and shows real-time body pose detection.
+    Press ESC to exit.
+    """
+    cap = cv2.VideoCapture(0)
+    if not cap.isOpened():
+        raise RuntimeError("Failed to open webcam.")
+
+    pose_obj = mp_pose.Pose(
+        min_detection_confidence=0.7,
+        static_image_mode=True
+    )
+
+    try:
+        while True:
+            success, frame = cap.read()
+            if not success:
+                print("Ignoring empty camera frame.")
+                continue
+
+            try:
+                annotated_img, _ = detect_body_pose(np_image=frame, pose_obj=pose_obj)
+            except ValueError:
+                annotated_img = frame
+
+            cv2.imshow('ImagePRO - Live Body Pose Detection', annotated_img)
+
+            if cv2.waitKey(5) & 0xFF == 27:
+                break
+    finally:
+        cap.release()
+        cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    detect_body_pose_live()

ImagePRO/human_analysis/body_analysis/hand_tracking.py

@@ -0,0 +1,157 @@
+import sys
+from pathlib import Path
+
+import cv2
+import mediapipe as mp
+
+# Add parent directory to import custom modules
+parent_dir = Path(__file__).resolve().parent.parent.parent
+sys.path.append(str(parent_dir))
+
+from io_handler import IOHandler
+
+mp_hands = mp.solutions.hands
+
+
+def detect_hands(
+    max_hands=2,
+    min_confidence=0.7,
+    landmarks_idx=None,
+    image_path=None,
+    np_image=None,
+    result_path=None,
+    hands_obj=None
+):
+    """
+    Detects hand landmarks in an image using MediaPipe.
+
+    Args:
+        max_hands (int): Max number of hands to detect.
+        min_confidence (float): Minimum confidence for detection.
+        landmarks_idx (list[int] | None): Landmark indices to extract (default: all 21).
+        image_path (str | None): Image file path.
+        np_image (np.ndarray | None): Preloaded image array.
+        result_path (str | None): Path to save output image (.jpg) or landmarks (.csv).
+        hands_obj (mp.solutions.hands.Hands | None): Optional pre-initialized model.
+
+    Returns:
+        np.ndarray | list: Annotated image and landmarks list, or saved file confirmation.
+    """
+    if not isinstance(max_hands, int) or max_hands <= 0:
+        raise ValueError("'max_hands' must be a positive integer.")
+
+    if not isinstance(min_confidence, (int, float)) or not (0.0 <= min_confidence <= 1.0):
+        raise ValueError("'min_confidence' must be a float between 0.0 and 1.0.")
+
+    if landmarks_idx is not None and not isinstance(landmarks_idx, list):
+        raise TypeError("'landmarks_idx' must be a list or None.")
+
+    if result_path:
+        if not isinstance(result_path, str):
+            raise TypeError("'result_path' must be a string.")
+        if not (result_path.endswith('.jpg') or result_path.endswith('.csv')):
+            raise ValueError("Only '.jpg' and '.csv' extensions are supported.")
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+
+    if hands_obj is None:
+        hands_obj = mp_hands.Hands(
+            min_detection_confidence=min_confidence,
+            max_num_hands=max_hands,
+            static_image_mode=True
+        )
+
+    if landmarks_idx is None:
+        landmarks_idx = list(range(21))
+
+    rgb_image = cv2.cvtColor(np_image, cv2.COLOR_BGR2RGB)
+    results = hands_obj.process(rgb_image)
+
+    annotated_image = np_image.copy()
+    all_landmarks = []
+
+    if results.multi_hand_landmarks:
+        for hand_id, hand_landmarks in enumerate(results.multi_hand_landmarks):
+            if result_path is None or result_path.endswith('.jpg'):
+                if len(landmarks_idx) == 21:
+                    mp.solutions.drawing_utils.draw_landmarks(
+                        image=annotated_image,
+                        landmark_list=hand_landmarks,
+                        connections=mp_hands.HAND_CONNECTIONS,
+                        landmark_drawing_spec=mp.solutions.drawing_styles.get_default_hand_landmarks_style(),
+                        connection_drawing_spec=mp.solutions.drawing_styles.get_default_hand_connections_style()
+                    )
+                else:
+                    h, w, _ = annotated_image.shape
+                    for idx in landmarks_idx:
+                        lm = hand_landmarks.landmark[idx]
+                        x, y = int(w * lm.x), int(h * lm.y)
+                        cv2.circle(annotated_image, (x, y), 3, (0, 0, 255), -1)
+
+            if result_path is None or result_path.endswith('.csv'):
+                hand_data = []
+                for idx in landmarks_idx:
+                    lm = hand_landmarks.landmark[idx]
+                    hand_data.append([hand_id, idx, lm.x, lm.y, lm.z])
+                all_landmarks.append(hand_data)
+    else:
+        return np_image, []
+
+    if result_path:
+        if result_path.endswith('.jpg'):
+            return IOHandler.save_image(annotated_image, result_path)
+        elif result_path.endswith('.csv'):
+            flat_landmarks = [item for sublist in all_landmarks for item in sublist]
+            return IOHandler.save_csv(flat_landmarks, result_path)
+    else:
+        return annotated_image, all_landmarks
+
+
+def detect_hands_live(max_hands=2, min_confidence=0.7):
+    """
+    Real-time hand detection via webcam.
+
+    Args:
+        max_hands (int): Maximum hands to detect.
+        min_confidence (float): Detection confidence threshold.
+    """
+    if not isinstance(max_hands, int) or max_hands <= 0:
+        raise ValueError("'max_hands' must be a positive integer.")
+    if not isinstance(min_confidence, (int, float)) or not (0.0 <= min_confidence <= 1.0):
+        raise ValueError("'min_confidence' must be a float between 0.0 and 1.0.")
+
+    cap = cv2.VideoCapture(0)
+    if not cap.isOpened():
+        raise RuntimeError("Failed to open webcam.")
+
+    hands_obj = mp_hands.Hands(
+        min_detection_confidence=min_confidence,
+        max_num_hands=max_hands,
+        static_image_mode=True
+    )
+
+    try:
+        while True:
+            success, frame = cap.read()
+            if not success:
+                print("Ignoring empty camera frame.")
+                continue
+
+            annotated_img, _ = detect_hands(
+                max_hands=max_hands,
+                min_confidence=min_confidence,
+                np_image=frame,
+                hands_obj=hands_obj
+            )
+
+            cv2.imshow('Live hand detector - ImagePRO', annotated_img)
+
+            if cv2.waitKey(5) & 0xFF == 27:
+                break
+    finally:
+        cap.release()
+        cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    detect_hands_live(max_hands=2)

ImagePRO/human_analysis/face_analysis/eye_status_analysis.py

@@ -0,0 +1,152 @@
+import sys
+from pathlib import Path
+
+import cv2
+import mediapipe as mp
+
+# Add parent directory to sys.path
+parent_dir = Path(__file__).resolve().parent.parent.parent
+sys.path.append(str(parent_dir))
+
+from io_handler import IOHandler
+from human_analysis.face_analysis.face_mesh_analysis import analyze_face_mesh
+
+mp_face_mesh = mp.solutions.face_mesh
+
+
+def analyze_eye_status(
+    min_confidence=0.7,
+    image_path=None,
+    np_image=None,
+    face_mesh_obj=None,
+    threshold=0.2
+):
+    """
+    Analyze eye open/closed status using Eye Aspect Ratio (EAR).
+
+    Args:
+        min_confidence (float): Minimum confidence for FaceMesh detection.
+        image_path (str, optional): Path to input image.
+        np_image (np.ndarray, optional): Image array.
+        face_mesh_obj (FaceMesh, optional): Reusable instance of FaceMesh.
+        threshold (float): EAR threshold below which eye is considered closed.
+
+    Returns:
+        bool: True if eye is open, False if closed.
+
+    Raises:
+        ValueError: If landmarks are not detected or inputs are invalid.
+    """
+    if not isinstance(min_confidence, (int, float)) or not (0 <= min_confidence <= 1):
+        raise ValueError("'min_confidence' must be between 0 and 1.")
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+    h, w = np_image.shape[:2]
+
+    if face_mesh_obj is None:
+        face_mesh_obj = mp_face_mesh.FaceMesh(
+            min_detection_confidence=min_confidence,
+            refine_landmarks=True,
+            static_image_mode=True
+        )
+
+    # Landmark indices for right eye (from MediaPipe's model)
+    # 386 (top eyelid), 374 (bottom eyelid), 263 (outer corner), 362 (inner corner)
+    indices = [386, 374, 263, 362]
+
+    _, landmarks = analyze_face_mesh(
+        max_faces=1,
+        min_confidence=min_confidence,
+        landmarks_idx=indices,
+        np_image=np_image,
+        face_mesh_obj=face_mesh_obj
+    )
+
+    if not landmarks:
+        raise ValueError("No face landmarks detected.")
+
+    eye_points = {lm[1]: lm for lm in landmarks[0]}
+
+    try:
+        top_y = eye_points[386][3] * h
+        bottom_y = eye_points[374][3] * h
+        left_x = eye_points[263][2] * w
+        right_x = eye_points[362][2] * w
+    except KeyError:
+        raise ValueError("Missing necessary eye landmarks.")
+
+    vertical_dist = abs(bottom_y - top_y)
+    horizontal_dist = abs(right_x - left_x)
+
+    if horizontal_dist == 0:
+        return False  # avoid division by zero
+
+    ear = vertical_dist / horizontal_dist
+    return ear > threshold
+
+
+def analyze_eye_status_live(min_confidence=0.7, threshold=0.2):
+    """
+    Perform live eye open/closed detection using webcam input.
+
+    Args:
+        min_confidence (float): Minimum confidence for detection.
+        threshold (float): EAR threshold to consider eyes open.
+
+    Raises:
+        ValueError: If confidence value is invalid.
+        RuntimeError: If webcam cannot be accessed.
+    """
+    if not isinstance(min_confidence, (int, float)) or not (0 <= min_confidence <= 1):
+        raise ValueError("'min_confidence' must be between 0 and 1.")
+
+    cap = cv2.VideoCapture(0)
+    if not cap.isOpened():
+        raise RuntimeError("Cannot access webcam.")
+
+    face_mesh = mp_face_mesh.FaceMesh(
+        max_num_faces=1,
+        min_detection_confidence=min_confidence,
+        refine_landmarks=True,
+        static_image_mode=True
+    )
+
+    try:
+        while True:
+            success, frame = cap.read()
+            if not success:
+                print("Skipping empty frame.")
+                continue
+
+            try:
+                is_open = analyze_eye_status(
+                    min_confidence=min_confidence,
+                    np_image=frame,
+                    face_mesh_obj=face_mesh,
+                    threshold=threshold
+                )
+                status = "Open" if is_open else "Closed"
+            except ValueError:
+                status = "No face"
+
+            cv2.putText(
+                frame,
+                f"Eye: {status}",
+                (10, 40),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.7,
+                (0, 255, 0) if status == "Open" else (0, 0, 255),
+                2
+            )
+
+            cv2.imshow("ImagePRO - Eye Status (ESC to Exit)", frame)
+            if cv2.waitKey(5) & 0xFF == 27:
+                break
+
+    finally:
+        cap.release()
+        cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    analyze_eye_status_live()

ImagePRO/human_analysis/face_analysis/face_detection.py

@@ -0,0 +1,84 @@
+import sys
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+# Add parent directory to sys.path for custom module imports
+parent_dir = Path(__file__).resolve().parent.parent.parent
+sys.path.append(str(parent_dir))
+
+from io_handler import IOHandler
+from human_analysis.face_analysis.face_mesh_analysis import analyze_face_mesh
+
+
+def detect_faces(
+    max_faces=1,
+    min_confidence=0.7,
+    image_path=None,
+    np_image=None,
+    result_path=None,
+    face_mesh_obj=None
+):
+    """
+    Detect and crop face regions using MediaPipe face landmarks.
+
+    Args:
+        max_faces (int): Maximum number of faces to detect.
+        min_confidence (float): Confidence threshold (0–1).
+        image_path (str, optional): Path to input image.
+        np_image (np.ndarray, optional): Image array.
+        result_path (str, optional): Save path for cropped face(s).
+        face_mesh_obj (FaceMesh, optional): Reusable MediaPipe instance.
+
+    Returns:
+        str or list[np.ndarray]: Confirmation message if saved, else list of cropped face images.
+
+    Raises:
+        TypeError, ValueError: On invalid inputs or if no faces detected.
+    """
+    if not isinstance(max_faces, int) or max_faces <= 0:
+        raise ValueError("'max_faces' must be a positive integer.")
+
+    if not isinstance(min_confidence, (int, float)) or not (0 <= min_confidence <= 1):
+        raise ValueError("'min_confidence' must be a float between 0 and 1.")
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+    height, width = np_image.shape[:2]
+
+    # Selected face outline landmark indices (based on MediaPipe's 468-point model)
+    face_outline_indices = [
+        10, 338, 297, 332, 284, 251, 389, 356, 454, 323,
+        361, 288, 397, 365, 379, 378, 400, 377, 152, 148,
+        176, 149, 150, 136, 164, 163, 153, 157
+    ]
+
+    # Run face mesh analysis
+    _, raw_landmarks = analyze_face_mesh(
+        max_faces=max_faces,
+        min_confidence=min_confidence,
+        landmarks_idx=face_outline_indices,
+        np_image=np_image,
+        face_mesh_obj=face_mesh_obj
+    )
+
+    if not raw_landmarks:
+        raise ValueError("No face landmarks detected in the input image.")
+
+    # Convert normalized landmark coordinates to pixel positions
+    all_polygons = []
+    for face in raw_landmarks:
+        polygon = [
+            (int(x * width), int(y * height))
+            for _, _, x, y, _ in face
+        ]
+        all_polygons.append(np.array(polygon, dtype=np.int32))
+
+    # Crop faces using boundingRect
+    cropped_faces = []
+    for polygon in all_polygons:
+        x, y, w, h = cv2.boundingRect(polygon)
+        cropped = np_image[y:y + h, x:x + w]
+        cropped_faces.append(cropped)
+
+    return IOHandler.save_image(cropped_faces, result_path)

ImagePRO/human_analysis/face_analysis/face_mesh_analysis.py

@@ -0,0 +1,172 @@
+import sys
+from pathlib import Path
+
+import cv2
+import mediapipe as mp
+
+# Add parent directory to path for custom module imports
+parent_dir = Path(__file__).resolve().parent.parent.parent
+sys.path.append(str(parent_dir))
+
+from io_handler import IOHandler
+
+mp_face_mesh = mp.solutions.face_mesh
+mp_drawing_utils = mp.solutions.drawing_utils
+mp_drawing_styles = mp.solutions.drawing_styles
+
+
+def analyze_face_mesh(
+    max_faces=1,
+    min_confidence=0.7,
+    landmarks_idx=None,
+    image_path=None,
+    np_image=None,
+    result_path=None,
+    face_mesh_obj=None
+):
+    """
+    Detect facial landmarks using MediaPipe FaceMesh.
+
+    Args:
+        max_faces (int): Maximum number of faces to detect.
+        min_confidence (float): Detection confidence threshold.
+        landmarks_idx (list, optional): Indices of landmarks to extract or draw.
+        image_path (str, optional): Path to input image file.
+        np_image (np.ndarray, optional): Image array.
+        result_path (str, optional): Save path (supports .jpg or .csv).
+        face_mesh_obj (FaceMesh, optional): External instance to reuse.
+
+    Returns:
+        str or tuple or np.ndarray or list:
+            - If `result_path` ends with `.jpg`: save/return annotated image.
+            - If `result_path` ends with `.csv`: save/return coordinates.
+            - If no result_path: returns (image, landmarks list).
+    """
+    if not isinstance(max_faces, int) or max_faces <= 0:
+        raise ValueError("'max_faces' must be a positive integer.")
+
+    if not isinstance(min_confidence, (int, float)) or not (0 <= min_confidence <= 1):
+        raise ValueError("'min_confidence' must be a float between 0 and 1.")
+
+    if landmarks_idx is not None and not isinstance(landmarks_idx, list):
+        raise TypeError("'landmarks_idx' must be a list of integers or None.")
+
+    if result_path and not isinstance(result_path, str):
+        raise TypeError("'result_path' must be a string or None.")
+
+    if result_path and not result_path.endswith(('.jpg', '.csv')):
+        raise ValueError("Only '.jpg' or '.csv' formats are supported.")
+
+    if face_mesh_obj is None:
+        face_Mesh = mp_face_mesh.FaceMesh(
+            max_num_faces=max_faces,
+            min_detection_confidence=min_confidence,
+            refine_landmarks=True,
+            static_image_mode=True
+        )
+    else:
+        face_Mesh = face_mesh_obj
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+    rgb_image = cv2.cvtColor(np_image, cv2.COLOR_BGR2RGB)
+    results = face_Mesh.process(rgb_image)
+
+    if not results.multi_face_landmarks:
+        raise ValueError("No face landmarks detected.")
+
+    landmarks_idx = landmarks_idx or list(range(468))
+    annotated = np_image.copy()
+    all_landmarks = []
+
+    for face_id, face_landmarks in enumerate(results.multi_face_landmarks):
+        if result_path is None or result_path.endswith('.jpg'):
+            if len(landmarks_idx) == 468:
+                mp_drawing_utils.draw_landmarks(
+                    image=annotated,
+                    landmark_list=face_landmarks,
+                    connections=mp_face_mesh.FACEMESH_TESSELATION,
+                    landmark_drawing_spec=None,
+                    connection_drawing_spec=mp_drawing_styles.get_default_face_mesh_tesselation_style()
+                )
+            else:
+                h, w = annotated.shape[:2]
+                for idx in landmarks_idx:
+                    lm = face_landmarks.landmark[idx]
+                    cx, cy = int(w * lm.x), int(h * lm.y)
+                    cv2.circle(annotated, (cx, cy), 3, (0, 0, 255), -1)
+
+        if result_path is None or result_path.endswith('.csv'):
+            face_data = [
+                [face_id, idx, lm.x, lm.y, lm.z]
+                for idx in landmarks_idx
+                for lm in [face_landmarks.landmark[idx]]
+            ]
+            all_landmarks.append(face_data)
+
+    # Output handling
+    if result_path:
+        if result_path.endswith('.jpg'):
+            return IOHandler.save_image(annotated, result_path)
+        elif result_path.endswith('.csv'):
+            flat_data = [row for face in all_landmarks for row in face]
+            return IOHandler.save_csv(flat_data, result_path)
+
+    return annotated, all_landmarks
+
+
+def analyze_face_mesh_live(max_faces=1, min_confidence=0.7):
+    """
+    Launch webcam with real-time face landmark overlay.
+
+    Args:
+        max_faces (int): Max faces to detect.
+        min_confidence (float): Detection confidence threshold.
+
+    Raises:
+        RuntimeError: If webcam can't be opened.
+    """
+    if not isinstance(max_faces, int) or max_faces <= 0:
+        raise ValueError("'max_faces' must be a positive integer.")
+
+    if not isinstance(min_confidence, (int, float)) or not (0 <= min_confidence <= 1):
+        raise ValueError("'min_confidence' must be between 0 and 1.")
+
+    cap = cv2.VideoCapture(0)
+    if not cap.isOpened():
+        raise RuntimeError("Unable to open webcam.")
+
+    face_Mesh = mp_face_mesh.FaceMesh(
+        max_num_faces=max_faces,
+        min_detection_confidence=min_confidence,
+        refine_landmarks=True,
+        static_image_mode=True
+    )
+
+    try:
+        while True:
+            success, frame = cap.read()
+            if not success:
+                print("Skipping empty frame.")
+                continue
+
+            try:
+                result_image, _ = analyze_face_mesh(
+                    max_faces=max_faces,
+                    min_confidence=min_confidence,
+                    np_image=frame,
+                    face_mesh_obj=face_Mesh
+                )
+            except ValueError:
+                result_image = frame
+
+            cv2.imshow("ImagePRO - Face Mesh", result_image)
+
+            if cv2.waitKey(1) & 0xFF == 27:  # ESC key
+                break
+    finally:
+        cap.release()
+        cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    analyze_face_mesh_live(max_faces=1)