ImagePRO-Python 0.5.2__tar.gz → 1.0.1__tar.gz

{imagepro_python-0.5.2/src/ImagePRO_Python.egg-info → imagepro_python-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ImagePRO-Python
-Version: 0.5.2
+Version: 1.0.1
 Summary: Professional & modular image processing library with OpenCV, MediaPipe, and YOLO integration.
 Author-email: Parsa Safaie <parsasafaie.2568@proton.me>
 License: MIT
@@ -27,4 +27,5 @@ Requires-Dist: opencv-python<5.0,>=4.8
 Requires-Dist: ultralytics<9.0,>=8.2.0
 Requires-Dist: mediapipe<1.0,>=0.10.0
 Requires-Dist: insightface<1.0,>=0.7
+Requires-Dist: onnxruntime<2.0,>=1.16
 Dynamic: license-file

{imagepro_python-0.5.2 → imagepro_python-1.0.1}/pyproject.toml

@@ -7,7 +7,7 @@ where = ["src"]
 
 [project]
 name = "ImagePRO-Python"
-version = "0.5.2"
+version = "1.0.1"
 description = "Professional & modular image processing library with OpenCV, MediaPipe, and YOLO integration."
 readme = "README.md"
 requires-python = "==3.10.*"
@@ -33,8 +33,10 @@ dependencies = [
   "ultralytics>=8.2.0,<9.0",
   "mediapipe>=0.10.0,<1.0",
   "insightface>=0.7,<1.0",
+  "onnxruntime>=1.16,<2.0",
 ]
 
+
 [project.urls]
 Homepage = "https://github.com/parsasafaie/ImagePRO"
 Repository = "https://github.com/parsasafaie/ImagePRO.git"

{imagepro_python-0.5.2 → imagepro_python-1.0.1}/src/ImagePRO/__init__.py

@@ -15,7 +15,7 @@ Features:
 - Real-time processing capabilities
 """
 
-__version__ = "0.5.2"
+__version__ = "1.0.0"
 __author__ = "Parsa Safaie"
 __email__ = "parsasafaie.2568@proton.me"
 

imagepro_python-1.0.1/src/ImagePRO/human_analysis/body_analysis/body_pose_estimation.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import cv2
+import mediapipe as mp
+
+from ImagePRO.utils.image import Image
+from ImagePRO.utils.result import Result
+
+# Constants
+mp_pose = mp.solutions.pose
+TOTAL_LANDMARKS = 33
+DEFAULT_CONFIDENCE = 0.7
+LANDMARK_RADIUS = 3
+LANDMARK_COLOR = (0, 0, 255)  # Red color for landmarks
+
+def detect_body_pose(
+    image: Image,
+    *,
+    min_confidence: float = DEFAULT_CONFIDENCE,
+    landmarks_idx: list[int] | None = None,
+    pose_obj: mp.solutions.pose.Pose | None = None
+) -> Result:
+    """Detect body landmarks in an image using MediaPipe Pose.
+
+    Extracts 3D body landmark coordinates and optionally draws them.
+    Can focus on specific landmarks or detect all 33 points.
+
+    Args:
+        image: Input image to process.
+        min_confidence: Detection confidence threshold.
+            Must be between 0 and 1.
+            Default: 0.7
+        landmarks_idx: Specific landmark indices to detect.
+            If None, detects all 33 landmarks.
+            Default: None
+        pose_obj: Pre-initialized pose detector.
+            If None, creates new instance.
+            Default: None
+
+    Returns:
+        Result object with detections and visualization:
+        - image: Input image with landmarks drawn
+        - data: List of [idx, x, y, z] coordinates
+        - meta: Operation info and parameters
+
+    Raises:
+        TypeError: If image is not an Image instance
+        ValueError: If min_confidence not in [0,1]
+        TypeError: If landmarks_idx is not list[int]
+    """
+    if not isinstance(image, Image):
+        raise TypeError("'image' must be an Image instance")
+
+    if not isinstance(min_confidence, (int, float)) or not (0.0 <= min_confidence <= 1.0):
+        raise ValueError("'min_confidence' must be between 0.0 and 1.0")
+
+    if landmarks_idx is not None and (
+        not isinstance(landmarks_idx, list) 
+        or not all(isinstance(i, int) for i in landmarks_idx)
+    ):
+        raise TypeError("'landmarks_idx' must be a list of integers")
+
+    # Initialize detector if needed
+    if pose_obj is None:
+        pose_obj = mp_pose.Pose(
+            min_detection_confidence=min_confidence,
+            static_image_mode=True
+        )
+
+    # Use all landmarks if none specified
+    if landmarks_idx is None:
+        landmarks_idx = list(range(TOTAL_LANDMARKS))
+
+    # Prepare image
+    h, w = image.shape[:2]
+    img_copy = image._data.copy()
+    img_rgb = cv2.cvtColor(img_copy, cv2.COLOR_BGR2RGB)
+
+    # Detect pose
+    result = pose_obj.process(img_rgb)
+    landmarks = []
+
+    if result.pose_landmarks:
+        # Visualize landmarks
+        if len(landmarks_idx) == TOTAL_LANDMARKS:
+            # Draw full skeleton
+            mp.solutions.drawing_utils.draw_landmarks(
+                img_copy,
+                result.pose_landmarks,
+                mp_pose.POSE_CONNECTIONS,
+                landmark_drawing_spec=mp.solutions.drawing_styles.get_default_pose_landmarks_style()
+            )
+        else:
+            # Draw only selected points
+            for idx in landmarks_idx:
+                lm = result.pose_landmarks.landmark[idx]
+                x, y = int(w * lm.x), int(h * lm.y)
+                cv2.circle(img_copy, (x, y), LANDMARK_RADIUS, LANDMARK_COLOR, -1)
+
+        # Extract coordinates
+        for idx in landmarks_idx:
+            lm = result.pose_landmarks.landmark[idx]
+            landmarks.append([idx, lm.x, lm.y, lm.z])
+
+    return Result(
+        image=img_copy,
+        data=landmarks,
+        meta={
+            "source": image,
+            "operation": "detect_body_pose",
+            "min_confidence": min_confidence,
+            "landmarks_idx": landmarks_idx
+        }
+    )
+
+
+def detect_body_pose_live() -> None:
+    """Start live webcam feed with real-time body pose detection.
+
+    Opens the default camera and shows pose landmarks in real-time.
+    Press ESC to exit the application.
+
+    Raises:
+        RuntimeError: If camera cannot be accessed
+    """
+    # Initialize camera
+    cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)
+    if not cap.isOpened():
+        raise RuntimeError("Cannot access webcam")
+
+    # Initialize pose detector in tracking mode
+    pose_obj = mp_pose.Pose(
+        min_detection_confidence=DEFAULT_CONFIDENCE,
+        static_image_mode=False
+    )
+
+    try:
+        while True:
+            # Get frame
+            success, frame = cap.read()
+            if not success:
+                print("Failed to capture frame, skipping...")
+                continue
+
+            # Process frame
+            try:
+                result = detect_body_pose(
+                    image=Image.from_array(frame),
+                    min_confidence=DEFAULT_CONFIDENCE,
+                    pose_obj=pose_obj
+                )
+                display_frame = result.image
+            except (TypeError, ValueError):
+                # Fall back to raw frame if detection fails
+                display_frame = frame
+
+            # Show result
+            cv2.imshow('ImagePRO - Live Body Pose Detection', display_frame)
+
+            # Check for ESC key
+            if cv2.waitKey(5) & 0xFF == 27:
+                break
+    finally:
+        # Clean up resources
+        cap.release()
+        cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    detect_body_pose_live()

imagepro_python-1.0.1/src/ImagePRO/human_analysis/body_analysis/hand_tracking.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import cv2
+import mediapipe as mp
+
+from ImagePRO.utils.image import Image
+from ImagePRO.utils.result import Result
+
+# Constants
+mp_hands = mp.solutions.hands
+DEFAULT_MAX_HANDS = 2
+DEFAULT_MIN_CONFIDENCE = 0.7
+TOTAL_HAND_LANDMARKS = 21
+LANDMARK_RADIUS = 3
+LANDMARK_COLOR = (0, 0, 255)  # Red color for landmarks
+
+
+def detect_hands(
+    image: Image,
+    *,
+    max_hands: int = DEFAULT_MAX_HANDS,
+    min_confidence: float = DEFAULT_MIN_CONFIDENCE,
+    landmarks_idx: list[int] | None = None,
+    hands_obj: mp.solutions.hands.Hands | None = None
+) -> Result:
+    """Detect hand landmarks in an image using MediaPipe Hands.
+
+    Identifies hand positions and extracts 3D coordinates of
+    key points (joints, fingertips, etc.).
+
+    Args:
+        image: Input image to process.
+        max_hands: Maximum number of hands to detect.
+            Must be positive.
+            Default: 2
+        min_confidence: Detection confidence threshold.
+            Must be between 0 and 1.
+            Default: 0.7
+        landmarks_idx: Specific landmark indices to detect.
+            If None, detects all 21 points per hand.
+            Default: None
+        hands_obj: Pre-initialized hand detector.
+            If None, creates new instance.
+            Default: None
+
+    Returns:
+        Result object with detections and visualization:
+        - image: Input image with landmarks drawn
+        - data: List of [hand_id, point_id, x, y, z]
+        - meta: Operation info and parameters
+
+    Raises:
+        TypeError: If image is not an Image instance
+        ValueError: If max_hands is not positive
+        ValueError: If min_confidence not in [0,1]
+        TypeError: If landmarks_idx is not list[int]
+    """
+    if not isinstance(image, Image):
+        raise TypeError("'image' must be an Image instance")
+
+    if not isinstance(max_hands, int) or max_hands <= 0:
+        raise ValueError("'max_hands' must be positive")
+
+    if not isinstance(min_confidence, (int, float)) or not (0.0 <= min_confidence <= 1.0):
+        raise ValueError("'min_confidence' must be between 0.0 and 1.0")
+
+    if landmarks_idx is not None and (
+        not isinstance(landmarks_idx, list) 
+        or not all(isinstance(i, int) for i in landmarks_idx)
+    ):
+        raise TypeError("'landmarks_idx' must be a list of integers")
+
+    # Initialize detector if needed
+    if hands_obj is None:
+        hands_obj = mp_hands.Hands(
+            min_detection_confidence=min_confidence,
+            max_num_hands=max_hands,
+            static_image_mode=True
+        )
+
+    # Use all landmarks if none specified
+    if landmarks_idx is None:
+        landmarks_idx = list(range(TOTAL_HAND_LANDMARKS))
+
+    # Prepare image
+    img_copy = image._data.copy()
+    img_rgb = cv2.cvtColor(img_copy, cv2.COLOR_BGR2RGB)
+
+    # Detect hands
+    results = hands_obj.process(img_rgb)
+    landmarks = []
+
+    # Process detections
+    if results.multi_hand_landmarks:
+        for hand_id, hand_landmarks in enumerate(results.multi_hand_landmarks):
+            # Visualize landmarks
+            if len(landmarks_idx) == TOTAL_HAND_LANDMARKS:
+                # Draw full hand skeleton
+                mp.solutions.drawing_utils.draw_landmarks(
+                    image=img_copy,
+                    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:
+                # Draw only selected points
+                h, w, _ = img_copy.shape
+                for idx in landmarks_idx:
+                    lm = hand_landmarks.landmark[idx]
+                    x, y = int(w * lm.x), int(h * lm.y)
+                    cv2.circle(img_copy, (x, y), LANDMARK_RADIUS, LANDMARK_COLOR, -1)
+
+            # Extract coordinates
+            for idx in landmarks_idx:
+                lm = hand_landmarks.landmark[idx]
+                landmarks.append([hand_id, idx, lm.x, lm.y, lm.z])
+
+    return Result(
+        image=img_copy,
+        data=landmarks,
+        meta={
+            "source": image,
+            "operation": "detect_hands",
+            "max_hands": max_hands,
+            "min_confidence": min_confidence,
+            "landmarks_idx": landmarks_idx
+        }
+    )
+
+
+def detect_hands_live(
+    max_hands: int = DEFAULT_MAX_HANDS,
+    min_confidence: float = DEFAULT_MIN_CONFIDENCE
+) -> None:
+    """Start live webcam feed with real-time hand detection.
+
+    Opens the default camera and shows hand landmarks in real-time.
+    Press ESC to exit.
+
+    Args:
+        max_hands: Maximum number of hands to track.
+            Must be positive.
+            Default: 2
+        min_confidence: Detection confidence threshold.
+            Must be between 0 and 1.
+            Default: 0.7
+
+    Raises:
+        ValueError: If parameters are invalid
+        RuntimeError: If camera cannot be accessed
+    """
+    # Validate parameters
+    if not isinstance(max_hands, int) or max_hands <= 0:
+        raise ValueError("'max_hands' must be positive")
+
+    if not isinstance(min_confidence, (int, float)) or not (0.0 <= min_confidence <= 1.0):
+        raise ValueError("'min_confidence' must be between 0.0 and 1.0")
+
+    # Initialize camera
+    cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)
+    if not cap.isOpened():
+        raise RuntimeError("Cannot access webcam")
+
+    # Initialize hand detector in tracking mode
+    hands_obj = mp_hands.Hands(
+        min_detection_confidence=min_confidence,
+        max_num_hands=max_hands,
+        static_image_mode=False
+    )
+
+    try:
+        while True:
+            # Get frame
+            success, frame = cap.read()
+            if not success:
+                print("Failed to capture frame, skipping...")
+                continue
+
+            # Process frame
+            result = detect_hands(
+                image=Image.from_array(frame),
+                max_hands=max_hands,
+                min_confidence=min_confidence,
+                hands_obj=hands_obj
+            )
+            display_frame = result.image if result.image is not None else frame
+
+            # Show result
+            cv2.imshow('ImagePRO - Live Hand Detection', display_frame)
+
+            # Check for ESC key
+            if cv2.waitKey(5) & 0xFF == 27:
+                break
+    finally:
+        # Clean up resources
+        cap.release()
+        cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    detect_hands_live()

imagepro_python-1.0.1/src/ImagePRO/human_analysis/face_analysis/eye_status_analysis.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+import cv2
+import mediapipe as mp
+
+from ImagePRO.human_analysis.face_analysis.face_mesh_analysis import analyze_face_mesh
+from ImagePRO.utils.image import Image
+from ImagePRO.utils.result import Result
+
+# Constants
+mp_face_mesh = mp.solutions.face_mesh
+DEFAULT_MIN_CONFIDENCE = 0.7
+DEFAULT_THRESHOLD = 0.2
+RIGHT_EYE_INDICES = [386, 374, 263, 362]  # MediaPipe right eye landmarks
+
+
+def analyze_eye_status(
+    image: Image,
+    *,
+    min_confidence: float = DEFAULT_MIN_CONFIDENCE,
+    threshold: float = DEFAULT_THRESHOLD,
+    face_mesh_obj: mp.solutions.face_mesh.FaceMesh | None = None,
+) -> Result:
+    """Analyze if the right eye is open using Eye Aspect Ratio (EAR).
+
+    Calculates eye openness by comparing vertical to horizontal distance
+    between key eye landmarks. Uses FaceMesh landmark detection.
+
+    Args:
+        image: Input image to process.
+        min_confidence: Detection confidence threshold.
+            Must be between 0 and 1.
+            Default: 0.7
+        threshold: EAR threshold for open vs closed.
+            Eye considered open if EAR > threshold.
+            Default: 0.2
+        face_mesh_obj: Pre-initialized face mesh detector.
+            If None, creates new instance in static mode.
+            Default: None
+
+    Returns:
+        Result object with eye status:
+        - data: True if eye is open, False if closed
+            None if detection fails
+        - meta: Operation info and error details if failed
+
+    Raises:
+        TypeError: If image is not an Image instance
+        ValueError: If min_confidence not in [0,1]
+    """
+    if not isinstance(image, Image):
+        raise TypeError("'image' must be an Image instance")
+
+    if not isinstance(min_confidence, (int, float)):
+        raise TypeError("'min_confidence' must be a number")
+    if not 0 <= min_confidence <= 1:
+        raise ValueError("'min_confidence' must be between 0 and 1")
+
+    # Get image dimensions
+    h, w = image.shape[:2]
+
+    # Initialize detector if needed
+    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
+        )
+
+    # Get face landmarks
+    mesh_result = analyze_face_mesh(
+        image=image,
+        max_faces=1,
+        min_confidence=min_confidence,
+        landmarks_idx=RIGHT_EYE_INDICES,
+        face_mesh_obj=face_mesh_obj
+    )
+    landmarks = mesh_result.data
+
+    # Handle no detections
+    if not landmarks:
+        return Result(
+            image=None,
+            data=None,
+            meta={
+                "source": image,
+                "operation": "analyze_eye_status",
+                "min_confidence": min_confidence,
+                "threshold": threshold,
+                "error": "No face landmarks detected"
+            }
+        )
+
+    # Map landmarks by index
+    eye_points = {lm[1]: lm for lm in landmarks[0]}
+
+    try:
+        # Extract key points (scale to image dimensions)
+        top_y = eye_points[386][3] * h       # Top of eye
+        bottom_y = eye_points[374][3] * h    # Bottom of eye
+        left_x = eye_points[263][2] * w      # Left corner
+        right_x = eye_points[362][2] * w     # Right corner
+    except KeyError as e:
+        return Result(
+            image=None,
+            data=None,
+            meta={
+                "source": image,
+                "operation": "analyze_eye_status",
+                "min_confidence": min_confidence,
+                "threshold": threshold,
+                "error": f"Missing landmark: {e}"
+            }
+        )
+
+    # Calculate Eye Aspect Ratio (EAR)
+    vertical_dist = abs(bottom_y - top_y)
+    horizontal_dist = abs(right_x - left_x)
+
+    # Determine eye state
+    is_open = False
+    if horizontal_dist > 0:  # Avoid division by zero
+        ear = vertical_dist / horizontal_dist
+        is_open = ear > threshold
+
+    return Result(
+        image=None,
+        data=is_open,
+        meta={
+            "source": image,
+            "operation": "analyze_eye_status",
+            "min_confidence": min_confidence,
+            "threshold": threshold
+        }
+    )
+
+
+def analyze_eye_status_live(
+    *,
+    min_confidence: float = DEFAULT_MIN_CONFIDENCE,
+    threshold: float = DEFAULT_THRESHOLD
+) -> None:
+    """Run live eye status detection using webcam feed.
+
+    Opens a window displaying webcam feed with overlaid eye status.
+    Press ESC to exit.
+
+    Args:
+        min_confidence: Detection confidence threshold.
+            Must be between 0 and 1.
+            Default: 0.7
+        threshold: EAR threshold for open vs closed.
+            Eye considered open if EAR > threshold.
+            Default: 0.2
+
+    Raises:
+        TypeError: If min_confidence is not a number
+        ValueError: If min_confidence not in [0,1]
+        RuntimeError: If webcam cannot be accessed
+    """
+    # Validate inputs
+    if not isinstance(min_confidence, (int, float)):
+        raise TypeError("'min_confidence' must be a number")
+    if not 0 <= min_confidence <= 1:
+        raise ValueError("'min_confidence' must be between 0 and 1")
+
+    # Initialize webcam
+    cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)
+    if not cap.isOpened():
+        raise RuntimeError("Failed to access webcam")
+
+    # Initialize face mesh detector for video
+    face_mesh = mp_face_mesh.FaceMesh(
+        max_num_faces=1,
+        min_detection_confidence=min_confidence,
+        refine_landmarks=True,
+        static_image_mode=False  # Optimize for video
+    )
+
+    try:
+        while True:
+            # Read frame
+            ret, frame = cap.read()
+            if not ret:
+                print("Warning: Failed to read frame, skipping...")
+                continue
+
+            # Process frame
+            try:
+                img = Image.from_array(frame)
+                result = analyze_eye_status(
+                    image=img,
+                    min_confidence=min_confidence,
+                    face_mesh_obj=face_mesh,
+                    threshold=threshold
+                )
+                status = "Open" if result.data else "Closed"
+            except (TypeError, ValueError):
+                status = "No face"
+
+            # Draw results
+            color = (0, 255, 0) if status == "Open" else (0, 0, 255)
+            cv2.putText(
+                frame,
+                f"Eye: {status}",
+                (10, 40),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.7,
+                color,
+                2
+            )
+
+            # Display frame
+            cv2.imshow("ImagePRO - Eye Status", frame)
+
+            # Check for ESC key
+            if cv2.waitKey(5) & 0xFF == 27:
+                break
+
+    finally:
+        cap.release()
+        cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    analyze_eye_status_live()