ImagePRO-Python 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

ImagePRO/__init__.py

@@ -16,7 +16,7 @@ Features:
 - Real-time processing capabilities
 """
 
-__version__ = "1.4.0"
+__version__ = "1.5.0"
 __author__ = "Parsa Safaie"
 __email__ = "parsasafaie.2568@proton.me"
 

ImagePRO/human_analysis/body_analysis/body_pose_estimation.py

@@ -23,6 +23,11 @@ TOTAL_LANDMARKS = 33
 DEFAULT_CONFIDENCE = 0.7
 LANDMARK_RADIUS = 3
 LANDMARK_COLOR = (0, 0, 255)  # Red color for landmarks
+# Backend-agnostic capture: the DSHOW backend only exists on Windows, so
+# the default leaves the choice to OpenCV. Tests inject a fake through
+# this hook.
+DEFAULT_CAMERA_BACKEND = None
+
 
 def detect_body_pose(
     image: Image,
@@ -62,12 +67,13 @@ def detect_body_pose(
     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):
+    if isinstance(min_confidence, bool) or 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)
+        or not all(isinstance(i, int) and not isinstance(i, bool) for i in landmarks_idx)
     ):
         raise TypeError("'landmarks_idx' must be a list of integers")
 
@@ -153,8 +159,8 @@ def detect_body_pose_live() -> None:
             'detection. Install it with: pip install "ImagePRO-Python[mediapipe]"'
         ) from err
 
-    # Initialize camera
-    cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)
+    # Initialize camera (backend-agnostic; see DEFAULT_CAMERA_BACKEND)
+    cap = cv2.VideoCapture(0, DEFAULT_CAMERA_BACKEND)
     if not cap.isOpened():
         raise RuntimeError("Cannot access webcam")
 

ImagePRO/human_analysis/body_analysis/hand_tracking.py

@@ -24,6 +24,10 @@ DEFAULT_MIN_CONFIDENCE = 0.7
 TOTAL_HAND_LANDMARKS = 21
 LANDMARK_RADIUS = 3
 LANDMARK_COLOR = (0, 0, 255)  # Red color for landmarks
+# Backend-agnostic capture: the DSHOW backend only exists on Windows, so
+# the default leaves the choice to OpenCV. Tests inject a fake through
+# this hook.
+DEFAULT_CAMERA_BACKEND = None
 
 
 def detect_hands(
@@ -69,15 +73,16 @@ def detect_hands(
     if not isinstance(image, Image):
         raise TypeError("'image' must be an Image instance")
 
-    if not isinstance(max_hands, int) or max_hands <= 0:
+    if not isinstance(max_hands, int) or isinstance(max_hands, bool) 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):
+    if isinstance(min_confidence, bool) or 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)
+        or not all(isinstance(i, int) and not isinstance(i, bool) for i in landmarks_idx)
     ):
         raise TypeError("'landmarks_idx' must be a list of integers")
 
@@ -174,10 +179,11 @@ def detect_hands_live(
         RuntimeError: If camera cannot be accessed
     """
     # Validate parameters
-    if not isinstance(max_hands, int) or max_hands <= 0:
+    if not isinstance(max_hands, int) or isinstance(max_hands, bool) 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):
+    if isinstance(min_confidence, bool) or 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")
 
     try:
@@ -188,8 +194,8 @@ def detect_hands_live(
             'tracking. Install it with: pip install "ImagePRO-Python[mediapipe]"'
         ) from err
 
-    # Initialize camera
-    cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)
+    # Initialize camera (backend-agnostic; see DEFAULT_CAMERA_BACKEND)
+    cap = cv2.VideoCapture(0, DEFAULT_CAMERA_BACKEND)
     if not cap.isOpened():
         raise RuntimeError("Cannot access webcam")
 

ImagePRO/human_analysis/face_analysis/eye_status_analysis.py

@@ -23,6 +23,10 @@ if TYPE_CHECKING:  # mediapipe is imported lazily inside the functions
 DEFAULT_MIN_CONFIDENCE = 0.7
 DEFAULT_THRESHOLD = 0.2
 RIGHT_EYE_INDICES = [386, 374, 263, 362]  # MediaPipe right eye landmarks
+# Backend-agnostic capture: the DSHOW backend only exists on Windows, so
+# the default leaves the choice to OpenCV. Tests inject a fake through
+# this hook.
+DEFAULT_CAMERA_BACKEND = None
 
 
 def analyze_eye_status(
@@ -62,7 +66,7 @@ def analyze_eye_status(
     if not isinstance(image, Image):
         raise TypeError("'image' must be an Image instance")
 
-    if not isinstance(min_confidence, (int, float)):
+    if isinstance(min_confidence, bool) or 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")
@@ -178,7 +182,7 @@ def analyze_eye_status_live(
         RuntimeError: If webcam cannot be accessed
     """
     # Validate inputs
-    if not isinstance(min_confidence, (int, float)):
+    if isinstance(min_confidence, bool) or 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")
@@ -191,8 +195,8 @@ def analyze_eye_status_live(
             'analysis. Install it with: pip install "ImagePRO-Python[mediapipe]"'
         ) from err
 
-    # Initialize webcam
-    cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)
+    # Initialize webcam (backend-agnostic; see DEFAULT_CAMERA_BACKEND)
+    cap = cv2.VideoCapture(0, DEFAULT_CAMERA_BACKEND)
     if not cap.isOpened():
         raise RuntimeError("Failed to access webcam")
 
@@ -221,7 +225,8 @@ def analyze_eye_status_live(
                     face_mesh_obj=face_mesh,
                     threshold=threshold
                 )
-                status = "Open" if result.data else "Closed"
+                status = "No face" if result.data is None else \
+                    ("Open" if result.data else "Closed")
             except (TypeError, ValueError):
                 status = "No face"
 

ImagePRO/human_analysis/face_analysis/face_comparison.py

@@ -10,8 +10,6 @@ _src_path = _file_path.parents[3]  # Go up to src directory
 if str(_src_path) not in sys.path:
     sys.path.insert(0, str(_src_path))
 
-import os
-
 import cv2
 import numpy as np
 
@@ -36,7 +34,9 @@ def compare_faces(
     """Compare two face images to determine if they are the same person.
 
     Uses InsightFace's FaceAnalysis model to extract facial embeddings
-    and compares them using cosine similarity.
+    and compares them using cosine similarity. Arrays are passed to the
+    model in memory; only path-based images are read from disk, so no
+    temporary files are written.
 
     Args:
         image_1: First image to compare.
@@ -57,7 +57,7 @@ def compare_faces(
 
     Raises:
         TypeError: If either image is not an Image instance
-        FileNotFoundError: If image data cannot be loaded
+        FileNotFoundError: If a path-based image cannot be loaded
     """
     # Validate inputs
     if not isinstance(image_1, Image):
@@ -82,69 +82,62 @@ def compare_faces(
         )
         app.prepare(ctx_id=0)  # Use CPU
 
-    def save_temp_image(image: Image, temp_name: str) -> str:
-        """Save image data to temporary file if needed."""
+    def load_rgb_image(image: Image) -> np.ndarray:
+        """Return the image as an RGB array, via disk only if required."""
         if image.source_type == 'path':
-            return image.path
-        temp_path = os.path.join(os.getcwd(), temp_name)
-        cv2.imwrite(temp_path, image._data)
-        return temp_path
-
-    def load_rgb_image(path: str) -> np.ndarray | None:
-        """Load image file and convert to RGB."""
-        img = cv2.imread(str(path))
-        return cv2.cvtColor(img, cv2.COLOR_BGR2RGB) if img is not None else None
-
-    try:
-        # Save images to disk if needed
-        path_1 = save_temp_image(image_1, 'tmp1.jpg')
-        path_2 = save_temp_image(image_2, 'tmp2.jpg')
-
-        # Load and preprocess images
-        img1 = load_rgb_image(path_1)
-        img2 = load_rgb_image(path_2)
-
-        if img1 is None or img2 is None:
-            raise FileNotFoundError("Failed to load one or both images")
-
-        # Detect faces
-        faces1 = app.get(img1)
-        faces2 = app.get(img2)
-
-        # Validate detections
-        if not faces1 or not faces2:
-            return Result(
-                image=None,
-                data=None,
-                meta={
-                    "source": (image_1, image_2),
-                    "operation": "compare_faces",
-                    "error": "No face detected in one or both images"
-                }
-            )
-
-        # Extract embeddings
-        emb1 = faces1[0].embedding
-        emb2 = faces2[0].embedding
-
-        # Calculate similarity
-        similarity = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
-        is_match = similarity > DEFAULT_SIMILARITY_THRESHOLD
-
+            # honor the declared colorspace when reading from disk
+            img = cv2.imread(str(image.path))
+            if img is None:
+                raise FileNotFoundError(f"Failed to load image from {image.path}")
+            if image.colorspace == "RGB":
+                return img
+            if image.colorspace == "GRAY":
+                return cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
+            return cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+        # InsightFace accepts in-memory arrays; no temp file is written.
+        if image.colorspace == "RGB":
+            return image._data
+        if image.colorspace == "GRAY":
+            return cv2.cvtColor(image._data, cv2.COLOR_GRAY2RGB)
+        return cv2.cvtColor(image._data, cv2.COLOR_BGR2RGB)
+
+    img1 = load_rgb_image(image_1)
+    img2 = load_rgb_image(image_2)
+
+    # Detect faces
+    faces1 = app.get(img1)
+    faces2 = app.get(img2)
+
+    # Validate detections
+    if not faces1 or not faces2:
         return Result(
             image=None,
-            data=is_match,
+            data=None,
             meta={
                 "source": (image_1, image_2),
                 "operation": "compare_faces",
-                "similarity": float(similarity),
-                "threshold": DEFAULT_SIMILARITY_THRESHOLD
+                "error": "No face detected in one or both images"
             }
         )
 
-    finally:
-        # Cleanup temporary files
-        if image_1.source_type != 'path' and os.path.exists('tmp1.jpg'):
-            os.remove('tmp1.jpg')
-        if image_2.source_type != 'path' and os.path.exists('tmp2.jpg'):
-            os.remove('tmp2.jpg')
+    # Extract embeddings
+    emb1 = faces1[0].embedding
+    emb2 = faces2[0].embedding
+
+    # Calculate similarity
+    similarity = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
+    # Cast to a plain bool: np.dot yields np.bool_, which fails `is True`
+    # checks and serializes oddly in CSV/JSON output.
+    is_match = bool(similarity > DEFAULT_SIMILARITY_THRESHOLD)
+
+    return Result(
+        image=None,
+        data=is_match,
+        meta={
+            "source": (image_1, image_2),
+            "operation": "compare_faces",
+            "similarity": float(similarity),
+            "threshold": DEFAULT_SIMILARITY_THRESHOLD
+        }
+    )

ImagePRO/human_analysis/face_analysis/face_detection.py

@@ -72,10 +72,11 @@ def detect_faces(
     if not isinstance(image, Image):
         raise TypeError("'image' must be an Image instance")
 
-    if not isinstance(max_faces, int) or max_faces <= 0:
+    if not isinstance(max_faces, int) or isinstance(max_faces, bool) or max_faces <= 0:
         raise ValueError("'max_faces' must be positive")
 
-    if not isinstance(min_confidence, (int, float)) or not (0 <= min_confidence <= 1):
+    if isinstance(min_confidence, bool) or not isinstance(min_confidence, (int, float)) \
+            or not (0 <= min_confidence <= 1):
         raise ValueError("'min_confidence' must be between 0 and 1")
 
     # Get image dimensions

ImagePRO/human_analysis/face_analysis/face_mesh_analysis.py

@@ -22,6 +22,10 @@ if TYPE_CHECKING:  # mediapipe is imported lazily inside the functions
 DEFAULT_MAX_FACES = 1
 DEFAULT_MIN_CONFIDENCE = 0.7
 TOTAL_FACE_LANDMARKS = 468
+# Backend-agnostic capture: the DSHOW backend only exists on Windows, so
+# the default leaves the choice to OpenCV. Tests inject a fake through
+# this hook.
+DEFAULT_CAMERA_BACKEND = None
 
 
 def analyze_face_mesh(
@@ -38,7 +42,7 @@ def analyze_face_mesh(
     Can focus on specific landmarks or detect full 468-point mesh.
 
     Args:
-        image: Input image to process.
+        image: Input image to process (BGR, RGB, or grayscale).
         max_faces: Maximum number of faces to detect.
             Must be positive.
             Default: 1
@@ -75,15 +79,16 @@ def analyze_face_mesh(
     if not isinstance(image, Image):
         raise TypeError("'image' must be an Image instance")
 
-    if not isinstance(max_faces, int) or max_faces <= 0:
+    if not isinstance(max_faces, int) or isinstance(max_faces, bool) or max_faces <= 0:
         raise ValueError("'max_faces' must be positive")
 
-    if not isinstance(min_confidence, (int, float)) or not (0 <= min_confidence <= 1):
+    if isinstance(min_confidence, bool) or not isinstance(min_confidence, (int, float)) \
+            or not (0 <= min_confidence <= 1):
         raise ValueError("'min_confidence' must be between 0 and 1")
 
     if landmarks_idx is not None and (
         not isinstance(landmarks_idx, list)
-        or not all(isinstance(i, int) for i in landmarks_idx)
+        or not all(isinstance(i, int) and not isinstance(i, bool) for i in landmarks_idx)
     ):
         raise TypeError("'landmarks_idx' must be a list of integers")
 
@@ -110,9 +115,14 @@ def analyze_face_mesh(
     else:
         face_mesh = face_mesh_obj
 
-    # Detect facial landmarks (cvtColor allocates a new RGB array)
-    img_rgb = cv2.cvtColor(image._data, cv2.COLOR_BGR2RGB)
-    results = face_mesh.process(img_rgb)
+    # MediaPipe expects RGB; grayscale input needs channels added back.
+    if image.colorspace == "GRAY":
+        model_input = cv2.cvtColor(image._data, cv2.COLOR_GRAY2RGB)
+    elif image.colorspace == "RGB":
+        model_input = image._data
+    else:  # BGR is the default
+        model_input = cv2.cvtColor(image._data, cv2.COLOR_BGR2RGB)
+    results = face_mesh.process(model_input)
 
     # Handle no detections
     if not results.multi_face_landmarks:
@@ -214,8 +224,9 @@ def analyze_face_mesh_live(
             'analysis. Install it with: pip install "ImagePRO-Python[mediapipe]"'
         ) from err
 
-    # Initialize camera
-    cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)
+    # Initialize camera (backend-agnostic; DEFAULT_CAMERA_BACKEND is a
+    # module-level hook tests can monkeypatch)
+    cap = cv2.VideoCapture(0, DEFAULT_CAMERA_BACKEND)
     if not cap.isOpened():
         raise RuntimeError("Cannot access webcam")
 

ImagePRO/human_analysis/face_analysis/head_pose_estimation.py

@@ -23,6 +23,10 @@ if TYPE_CHECKING:  # mediapipe is imported lazily inside the functions
 DEFAULT_MAX_FACES = 1
 DEFAULT_MIN_CONFIDENCE = 0.7
 HEAD_POSE_INDICES = [1, 152, 33, 263, 168]  # nose_tip, chin, left_eye, right_eye, nasion
+# Backend-agnostic capture: the DSHOW backend only exists on Windows, so
+# the default leaves the choice to OpenCV. Tests inject a fake through
+# this hook.
+DEFAULT_CAMERA_BACKEND = None
 
 
 def estimate_head_pose(
@@ -37,6 +41,12 @@ def estimate_head_pose(
     Calculates approximate yaw and pitch angles based on relative
     positions of key facial landmarks (nose, eyes, chin).
 
+    The values are unscaled proportional scores, not degrees: each is the
+    normalized landmark asymmetry multiplied by an arbitrary constant of
+    100. They are useful for thresholds and trends (e.g. detecting when a
+    face turns away), not for measuring absolute angles. Mirror-image
+    webcam feeds flip the sign of yaw.
+
     Args:
         image: Input image to process.
         max_faces: Maximum number of faces to analyze.
@@ -55,6 +65,7 @@ def estimate_head_pose(
             None if no faces detected
         - meta: Operation info and parameters
             Includes error info if detection fails
+        - image: None
 
     Raises:
         TypeError: If image is not an Image instance
@@ -64,10 +75,11 @@ def estimate_head_pose(
     if not isinstance(image, Image):
         raise TypeError("'image' must be an Image instance")
 
-    if not isinstance(max_faces, int) or max_faces <= 0:
+    if not isinstance(max_faces, int) or isinstance(max_faces, bool) or max_faces <= 0:
         raise ValueError("'max_faces' must be positive")
 
-    if not isinstance(min_confidence, (int, float)) or not (0 <= min_confidence <= 1):
+    if isinstance(min_confidence, bool) or not isinstance(min_confidence, (int, float)) \
+            or not (0 <= min_confidence <= 1):
         raise ValueError("'min_confidence' must be between 0 and 1")
 
     # Get face landmarks
@@ -120,7 +132,8 @@ def estimate_head_pose(
                 }
             )
 
-        # Calculate angles
+        # Calculate angles. The ×100 constant is arbitrary; the values are
+        # proportional scores for thresholding, not degrees.
         yaw = 100 * ((right_x - nasion_x) - (nasion_x - left_x))    # Horizontal rotation
         pitch = 100 * ((chin_y - nose_y) - (nose_y - nasion_y))     # Vertical rotation
         pose_data.append([face[0][0], yaw, pitch])
@@ -162,11 +175,11 @@ def estimate_head_pose_live(
         RuntimeError: If webcam cannot be accessed
     """
     # Validate inputs
-    if not isinstance(max_faces, int):
+    if not isinstance(max_faces, int) or isinstance(max_faces, bool):
         raise TypeError("'max_faces' must be an integer")
     if max_faces <= 0:
         raise ValueError("'max_faces' must be positive")
-    if not isinstance(min_confidence, (int, float)):
+    if isinstance(min_confidence, bool) or 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")
@@ -179,8 +192,8 @@ def estimate_head_pose_live(
             'estimation. Install it with: pip install "ImagePRO-Python[mediapipe]"'
         ) from err
 
-    # Initialize webcam
-    cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)
+    # Initialize webcam (backend-agnostic; see DEFAULT_CAMERA_BACKEND)
+    cap = cv2.VideoCapture(0, DEFAULT_CAMERA_BACKEND)
     if not cap.isOpened():
         raise RuntimeError("Failed to access webcam")
 

ImagePRO/object_analysis/object_detection.py

@@ -18,6 +18,7 @@ if TYPE_CHECKING:  # ultralytics is imported lazily inside the function
 
 # Constants
 DEFAULT_ACCURACY_LEVEL = 1
+DEFAULT_DEVICE = "cpu"  # CUDA builds fail on older GPUs (sm_50 and lower)
 MODEL_MAPPING = {
     1: "yolo11n.pt",
     2: "yolo11s.pt",
@@ -32,7 +33,8 @@ def detect_objects(
     *,
     model: YOLO | None = None,
     accuracy_level: int = DEFAULT_ACCURACY_LEVEL,
-    show_result: bool = False
+    show_result: bool = False,
+    device: str = DEFAULT_DEVICE
 ) -> Result:
     """Detect objects in an image using YOLO models.
 
@@ -52,6 +54,12 @@ def detect_objects(
             Default: 1
         show_result: Show detection visualization window.
             Default: False
+        device: Torch device for inference ("cpu", "cuda", "0", ...).
+            Defaults to "cpu" because CUDA wheels no longer support older
+            GPUs (compute capability below 5.0 is unsupported by cu12/cu13
+            builds) and fail with cudaErrorNoKernelImageForDevice; pass
+            "cuda" explicitly to use the GPU.
+            Default: "cpu"
 
     Returns:
         Result object with detections and metadata:
@@ -89,7 +97,7 @@ def detect_objects(
         model = YOLO(model=model_name)
 
     # Run inference (ultralytics does not mutate the input array)
-    result = model(image._data)[0]
+    result = model(image._data, device=device)[0]
     boxes = result.boxes
 
     # Process detections
@@ -110,6 +118,7 @@ def detect_objects(
         meta={
             "source": image,
             "operation": "detect_objects",
-            "model": model_name or "custom"
+            "model": model_name or "custom",
+            "device": device
         }
     )

ImagePRO/pipeline/pipeline.py

@@ -136,7 +136,9 @@ class Pipeline:
 
         Operations can be passed as separate arguments or as a single
         list/tuple. Passing another Pipeline as an operation nests it: the
-        inner pipeline runs as a single step.
+        inner pipeline runs as a single step. An empty pipeline is accepted
+        at construction time but `run()` raises ValueError until at least
+        one operation is added with `apply()`.
 
         Args:
             *operations (Callable | Step | list | tuple):

ImagePRO/pre_processing/blur.py

@@ -56,7 +56,10 @@ def apply_average_blur(
     if (
         not isinstance(kernel_size, tuple)
         or len(kernel_size) != 2
-        or not all(isinstance(k, int) and k > 0 for k in kernel_size)
+        or not all(
+            isinstance(k, int) and not isinstance(k, bool) and k > 0
+            for k in kernel_size
+        )
     ):
         raise ValueError("'kernel_size' must be a tuple of two positive integers.")
 
@@ -107,7 +110,10 @@ def apply_gaussian_blur(
     if (
         not isinstance(kernel_size, tuple)
         or len(kernel_size) != 2
-        or not all(isinstance(k, int) and k > 0 and k % 2 == 1 for k in kernel_size)
+        or not all(
+            isinstance(k, int) and not isinstance(k, bool) and k > 0 and k % 2 == 1
+            for k in kernel_size
+        )
     ):
         raise ValueError("'kernel_size' must be a tuple of two odd positive integers.")
 
@@ -156,7 +162,8 @@ def apply_median_blur(
     if not isinstance(image, Image):
         raise TypeError("'image' must be an Image instance.")
 
-    if not isinstance(filter_size, int) or filter_size <= 1 or filter_size % 2 == 0:
+    if not isinstance(filter_size, int) or isinstance(filter_size, bool) \
+            or filter_size <= 1 or filter_size % 2 == 0:
         raise ValueError("'filter_size' must be an odd integer greater than 1.")
 
     # Apply median filtering
@@ -212,11 +219,11 @@ def apply_bilateral_blur(
     if not isinstance(image, Image):
         raise TypeError("'image' must be an Image instance.")
 
-    if not isinstance(filter_size, int) or filter_size <= 0:
+    if not isinstance(filter_size, int) or isinstance(filter_size, bool) or filter_size <= 0:
         raise ValueError("'filter_size' must be a positive integer.")
-    if not isinstance(sigma_color, (int, float)) or sigma_color <= 0:
+    if isinstance(sigma_color, bool) or not isinstance(sigma_color, (int, float)) or sigma_color <= 0:
         raise ValueError("'sigma_color' must be a positive number.")
-    if not isinstance(sigma_space, (int, float)) or sigma_space <= 0:
+    if isinstance(sigma_space, bool) or not isinstance(sigma_space, (int, float)) or sigma_space <= 0:
         raise ValueError("'sigma_space' must be a positive number.")
 
     # Apply bilateral filter

ImagePRO/pre_processing/contrast.py

@@ -29,7 +29,8 @@ def apply_clahe_contrast(
     """Enhance image contrast using CLAHE (adaptive histogram equalization).
 
     CLAHE applies histogram equalization on small regions for better local contrast.
-    Works well for images with varying lighting conditions.
+    Works well for images with varying lighting conditions. Color images are
+    converted to grayscale first; the output is always single-channel.
 
     Args:
         image: Input image to enhance.
@@ -52,18 +53,23 @@ def apply_clahe_contrast(
     if not isinstance(image, Image):
         raise TypeError("'image' must be an Image instance")
 
-    if not isinstance(clip_limit, (int, float)) or clip_limit <= 0:
+    if isinstance(clip_limit, bool) or not isinstance(clip_limit, (int, float)) \
+            or clip_limit <= 0:
         raise ValueError("'clip_limit' must be a positive number")
 
     if (
         not isinstance(tile_grid_size, tuple)
         or len(tile_grid_size) != 2
-        or not all(isinstance(i, int) and i > 0 for i in tile_grid_size)
+        or not all(isinstance(i, int) and not isinstance(i, bool) and i > 0 for i in tile_grid_size)
     ):
         raise TypeError("'tile_grid_size' must be a tuple of two positive integers")
 
-    # Convert and apply CLAHE (cvtColor returns a new array; input untouched)
-    grayscale = cv2.cvtColor(image._data, cv2.COLOR_BGR2GRAY)
+    # CLAHE works on a single channel: grayscale BGR/RGB inputs, luma of
+    # color ones (channel weights are identical for BGR and RGB).
+    if image.colorspace == "GRAY":
+        grayscale = image._data
+    else:
+        grayscale = cv2.cvtColor(image._data, cv2.COLOR_BGR2GRAY)
     clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=tile_grid_size)
     enhanced = clahe.apply(grayscale)
 
@@ -84,7 +90,8 @@ def apply_histogram_equalization(
     """Global histogram equalization for contrast enhancement.
 
     Normalizes image intensity for better overall contrast.
-    Simple but may overamplify noise in some cases.
+    Simple but may overamplify noise in some cases. Color images are
+    converted to grayscale first; the output is always single-channel.
 
     Args:
         image: Input image to enhance.
@@ -101,8 +108,13 @@ def apply_histogram_equalization(
     if not isinstance(image, Image):
         raise TypeError("'image' must be an Image instance")
 
-    # Convert and apply global histogram equalization
-    grayscale = cv2.cvtColor(image._data, cv2.COLOR_BGR2GRAY)
+    # Global equalization works on a single channel: grayscale inputs pass
+    # through, color ones are converted first (luma weights are identical
+    # for BGR and RGB).
+    if image.colorspace == "GRAY":
+        grayscale = image._data
+    else:
+        grayscale = cv2.cvtColor(image._data, cv2.COLOR_BGR2GRAY)
     enhanced = cv2.equalizeHist(grayscale)
 
     return Result(
@@ -123,7 +135,8 @@ def apply_contrast_stretching(
     """Linear contrast stretching using alpha and beta.
 
     Applies the formula: new_pixel = alpha × pixel + beta
-    Simple but effective for basic contrast adjustment.
+    Simple but effective for basic contrast adjustment. Color images are
+    converted to grayscale first; the output is always single-channel.
 
     Args:
         image: Input image to enhance.
@@ -146,14 +159,19 @@ def apply_contrast_stretching(
     if not isinstance(image, Image):
         raise TypeError("'image' must be an Image instance")
 
-    if not isinstance(alpha, (int, float)) or alpha < 0:
+    if isinstance(alpha, bool) or not isinstance(alpha, (int, float)) or alpha < 0:
         raise ValueError("'alpha' must be a non-negative number")
 
-    if not isinstance(beta, int) or not (0 <= beta <= 255):
+    if not isinstance(beta, int) or isinstance(beta, bool) or not (0 <= beta <= 255):
         raise ValueError("'beta' must be an integer between 0 and 255")
 
-    # Convert and apply linear stretching
-    grayscale = cv2.cvtColor(image._data, cv2.COLOR_BGR2GRAY)
+    # Linear stretching on a single channel: grayscale inputs pass through,
+    # color ones are converted first (luma weights are identical for BGR
+    # and RGB).
+    if image.colorspace == "GRAY":
+        grayscale = image._data
+    else:
+        grayscale = cv2.cvtColor(image._data, cv2.COLOR_BGR2GRAY)
     enhanced = cv2.convertScaleAbs(grayscale, alpha=alpha, beta=beta)
 
     return Result(

ImagePRO/pre_processing/crop.py

@@ -23,6 +23,7 @@ def crop_image(
 
     Extracts a rectangular region from the image using the specified coordinates.
     The cropped area must be within image bounds and have valid dimensions.
+    The crop is an independent copy; editing it never affects the source image.
 
     Args:
         image: Input image to crop.
@@ -47,7 +48,8 @@ def crop_image(
         not isinstance(start_point, tuple) or
         not isinstance(end_point, tuple) or
         len(start_point) != 2 or len(end_point) != 2 or
-        not all(isinstance(c, int) for c in start_point + end_point)
+        not all(isinstance(c, int) and not isinstance(c, bool)
+                for c in start_point + end_point)
     ):
         raise TypeError("'start_point' and 'end_point' must be (x, y) tuples of integers")
 
@@ -65,8 +67,9 @@ def crop_image(
     if x2 > width or y2 > height:
         raise ValueError(f"Crop area exceeds image bounds ({width}x{height})")
 
-    # Extract the region
-    cropped = image._data[y1:y2, x1:x2]
+    # Extract the region as a copy so later in-place edits of the crop can
+    # never touch the source image (non-destructive contract)
+    cropped = image._data[y1:y2, x1:x2].copy()
 
     return Result(
         image=cropped,

ImagePRO/pre_processing/dataset_generator.py

@@ -24,6 +24,45 @@ DEFAULT_MIN_CONFIDENCE = 0.7
 DEFAULT_CAMERA_INDEX = 0
 DEFAULT_DELAY = 0.1
 DEFAULT_FACE_ID = "unknown"
+MAX_EMPTY_FRAMES = 250  # Abandon capture after this many frames without a face
+
+
+def _validate_parameters(
+    *,
+    num_images: int,
+    start_index: int,
+    min_confidence: float,
+    camera_index: int,
+    apply_resize: tuple[int, int] | bool,
+    delay: float
+) -> None:
+    """Validate all user-supplied parameters up front, before touching the camera."""
+    if not isinstance(num_images, int) or isinstance(num_images, bool) or num_images <= 0:
+        raise ValueError("'num_images' must be a positive integer")
+
+    if not isinstance(start_index, int) or isinstance(start_index, bool) or start_index < 0:
+        raise ValueError("'start_index' must be a non-negative integer")
+
+    if isinstance(min_confidence, bool) or not isinstance(min_confidence, (int, float)) \
+            or not (0 <= min_confidence <= 1):
+        raise ValueError("'min_confidence' must be between 0 and 1")
+
+    if not isinstance(camera_index, int) or isinstance(camera_index, bool) or camera_index < 0:
+        raise ValueError("'camera_index' must be a non-negative integer")
+
+    if apply_resize is not False and (
+        not isinstance(apply_resize, tuple)
+        or len(apply_resize) != 2
+        or not all(
+            isinstance(dim, int) and not isinstance(dim, bool) and dim > 0
+            for dim in apply_resize
+        )
+    ):
+        raise ValueError("'apply_resize' must be False or a (width, height) tuple "
+                         "of two positive integers")
+
+    if isinstance(delay, bool) or not isinstance(delay, (int, float)) or delay < 0:
+        raise ValueError("'delay' must be a non-negative number")
 
 
 def capture_bulk_pictures(
@@ -43,12 +82,17 @@ def capture_bulk_pictures(
 ) -> None:
     """Generate a dataset by capturing faces from webcam.
 
-    Captures frames from the webcam, detects faces, applies optional preprocessing,
-    and saves cropped face images to disk. This function is useful for creating
-    face recognition datasets with data augmentation.
+    Captures frames from the webcam, detects faces, applies optional
+    preprocessing, and saves cropped face images to disk. This function is
+    useful for creating face recognition datasets with data augmentation.
+
+    Saved crops go through this pipeline (each step optional):
+    median blur → laplacian sharpen → resize → grayscale → random rotate
 
-    Processing pipeline (if enabled):
-    median blur → laplacian sharpen → grayscale → resize → random rotate
+    Face detection always runs on the raw camera frame, so the capture loop
+    keeps working no matter which preprocessing flags are enabled. The loop
+    gives up after MAX_EMPTY_FRAMES consecutive frames without a usable
+    capture, instead of blocking forever when no face is in view.
 
     Args:
         folder_path: Base directory for dataset.
@@ -64,7 +108,7 @@ def capture_bulk_pictures(
             Default: 0
         apply_blur: Apply median blur (size=3).
             Default: False
-        apply_grayscale: Convert to single-channel.
+        apply_grayscale: Convert crops to single-channel.
             Default: False
         apply_sharpen: Apply Laplacian (coef=1.0).
             Default: False
@@ -81,18 +125,19 @@ def capture_bulk_pictures(
         FileExistsError: If output folder exists
         RuntimeError: If camera access fails
     """
-    # Validate numeric parameters to ensure safe operation
-    if not isinstance(num_images, int) or num_images <= 0:
-        raise ValueError("'num_images' must be a positive integer")
-
-    if not isinstance(start_index, int) or start_index < 0:
-        raise ValueError("'start_index' must be a non-negative integer")
-
-    if not isinstance(min_confidence, (int, float)) or not (0 <= min_confidence <= 1):
-        raise ValueError("'min_confidence' must be between 0 and 1")
+    # Validate everything up front, before creating folders or opening the
+    # camera, so an invalid argument never leaves partial state behind.
+    _validate_parameters(
+        num_images=num_images,
+        start_index=start_index,
+        min_confidence=min_confidence,
+        camera_index=camera_index,
+        apply_resize=apply_resize,
+        delay=delay
+    )
 
-    if not isinstance(delay, (int, float)) or delay < 0:
-        raise ValueError("'delay' must be a non-negative number")
+    if apply_rotate is not None and not isinstance(apply_rotate, bool):
+        raise TypeError("'apply_rotate' must be a boolean")
 
     try:
         import mediapipe as mp
@@ -127,12 +172,20 @@ def capture_bulk_pictures(
     )
 
     saved_count = 0
+    frames_without_face = 0
     try:
         while saved_count < num_images:
             # Capture frame
             success, frame = cap.read()
             if not success:
                 print("Failed to capture frame, skipping...")
+                frames_without_face += 1
+                if frames_without_face >= MAX_EMPTY_FRAMES:
+                    raise RuntimeError(
+                        f"Camera stopped delivering frames after "
+                        f"{frames_without_face} consecutive failures; "
+                        f"saved {saved_count}/{num_images} images so far."
+                    )
                 continue
 
             # Apply preprocessing pipeline in sequence
@@ -153,12 +206,6 @@ def capture_bulk_pictures(
                     coefficient=1.0
                 ).image
 
-            if apply_grayscale:
-                # Convert to single-channel for reduced storage and faster processing
-                processed = grayscale.convert_to_grayscale(
-                    image=Image.from_array(processed)
-                ).image
-
             if apply_resize is not False:
                 # Resize to consistent dimensions (e.g., 224x224 for ML models)
                 processed = resize.resize_image(
@@ -166,6 +213,14 @@ def capture_bulk_pictures(
                     new_size=apply_resize
                 ).image
 
+            if apply_grayscale:
+                # Convert to single-channel for reduced storage and faster
+                # processing. Rotation then tags the intermediate as GRAY so
+                # the face detector can convert back to RGB correctly.
+                processed = grayscale.convert_to_grayscale(
+                    image=Image.from_array(processed)
+                ).image
+
             if apply_rotate:
                 # Apply random rotation with scaling for data augmentation
                 # Rotation range: -45° to +45° with random scale factors
@@ -182,9 +237,12 @@ def capture_bulk_pictures(
             output_path = face_folder / filename
 
             try:
-                # Detect face and crop to face region only
+                # Detect face and crop to face region only. The detector
+                # needs a color image, so pass the untouched camera frame
+                # (preprocessing here is augmentation for the saved crop,
+                # not a requirement of the detector).
                 result = detect_faces(
-                    image=Image.from_array(processed),
+                    image=Image.from_array(frame),
                     max_faces=1,
                     min_confidence=min_confidence,
                     face_mesh_obj=face_mesh
@@ -193,13 +251,22 @@ def capture_bulk_pictures(
                 # Save cropped face image
                 result.save_as_img(str(output_path))
                 saved_count += 1
+                frames_without_face = 0
 
                 # Add delay between captures to allow subject movement
                 if delay > 0:
                     time.sleep(delay)
 
             except ValueError:
-                # Skip frames with no detected faces (silent failure)
+                # Skip frames with no detected faces
+                frames_without_face += 1
+                if frames_without_face >= MAX_EMPTY_FRAMES:
+                    print(
+                        f"No face detected in {frames_without_face} consecutive "
+                        f"frames; giving up with {saved_count}/{num_images} "
+                        "images saved."
+                    )
+                    break
                 continue
 
     finally:

ImagePRO/pre_processing/histogram.py

@@ -23,9 +23,13 @@ def show_histogram(image: Image) -> Result:
     This function creates the histogram plot of the intensity distribution of
     an image. It handles both grayscale and color images, with automatic
     detection of image type. For color images, it plots a histogram for each
-    color channel (BGR or RGB) with appropriate colors. The pyplot module is
-    returned in ``data``; call ``matplotlib.pyplot.show()`` to display the
-    figure.
+    color channel (BGR or RGB) with appropriate colors.
+
+    The figure is closed before returning, so batch calls do not accumulate
+    figures in memory. To display the plot interactively, call this function
+    with ``matplotlib.interactive(True)`` or re-create the figure with
+    ``plt.figure(1)`` right before ``plt.show()``: pyplot re-opens the most
+    recently closed figure number with its contents intact.
 
     Args:
         image (Image):
@@ -54,7 +58,7 @@ def show_histogram(image: Image) -> Result:
         channels = list(enumerate(colors))
     elif image.colorspace == "GRAY":
         channels = [(0, "black")]
-        labels = None
+        labels = ("Intensity",)
     else:
         raise ValueError(f"Unknown colorspace: {image.colorspace}")
 
@@ -63,15 +67,13 @@ def show_histogram(image: Image) -> Result:
         hist = cv2.calcHist([image._data], [channel], None, [256], [0, 256])
         plt.plot(hist, color=color)
 
-    if labels is not None:
-        plt.title(f"Histogram of {image.colorspace} Channels")
-        plt.legend(labels)
-        plt.xlabel("Pixel Intensity")
-        plt.ylabel("Frequency")
-
+    plt.title(f"Histogram of {image.colorspace} Channels")
+    plt.legend(labels)
+    plt.xlabel("Pixel Intensity")
+    plt.ylabel("Frequency")
     plt.xlim([0, 256])
 
-    return Result(
+    result = Result(
         image=None,
         data=plt,
         meta={
@@ -79,3 +81,6 @@ def show_histogram(image: Image) -> Result:
             "operation": "show_histogram"
         }
     )
+    # Close the figure so repeated calls in batch jobs do not leak figures.
+    plt.close()
+    return result

ImagePRO/pre_processing/resize.py

@@ -46,7 +46,10 @@ def resize_image(
     if (
         not isinstance(new_size, tuple)
         or len(new_size) != 2
-        or not all(isinstance(dim, int) and dim > 0 for dim in new_size)
+        or not all(
+            isinstance(dim, int) and not isinstance(dim, bool) and dim > 0
+            for dim in new_size
+        )
     ):
         raise ValueError("'new_size' must be a tuple of two positive integers")
 

ImagePRO/pre_processing/rotate.py

@@ -136,9 +136,9 @@ def rotate_image_custom(
     """
     if not isinstance(image, Image):
         raise TypeError("'image' must be an Image instance")
-    if not isinstance(angle, (int, float)):
+    if isinstance(angle, bool) or not isinstance(angle, (int, float)):
         raise TypeError("'angle' must be a number")
-    if not isinstance(scale, (int, float)) or scale <= 0:
+    if isinstance(scale, bool) or not isinstance(scale, (int, float)) or scale <= 0:
         raise ValueError("'scale' must be a positive number")
 
     h, w = image.shape[:2]

ImagePRO/pre_processing/sharpen.py

@@ -38,7 +38,7 @@ def apply_laplacian_sharpening(
 
     Returns:
         Result object with sharpened image and metadata:
-        - image: Sharpened image array
+        - image: Sharpened image array (same dtype as the input)
         - data: None
         - meta: Operation info and coefficient used
 
@@ -49,19 +49,19 @@ def apply_laplacian_sharpening(
     if not isinstance(image, Image):
         raise TypeError("'image' must be an Image instance")
 
-    if not isinstance(coefficient, (int, float)) or coefficient < 0:
+    if isinstance(coefficient, bool) or not isinstance(coefficient, (int, float)) \
+            or coefficient < 0:
         raise ValueError("'coefficient' must be a non-negative number")
 
-    # Apply Laplacian edge detection, then enhance edges while keeping
-    # float arithmetic identical to: image + coefficient * |laplacian|
+    # Sharpen in float space: image + coefficient * |laplacian|, clipped
+    # once at the end. Casting the Laplacian to uint8 before combining
+    # would truncate edge responses above 255 and corrupt the output.
     laplacian = cv2.Laplacian(image._data, cv2.CV_64F)
     np.absolute(laplacian, out=laplacian)
-    laplacian = laplacian.astype(np.uint8)
 
-    sharpened = laplacian * coefficient
-    sharpened += image._data
+    sharpened = image._data.astype(np.float64) + coefficient * laplacian
     np.clip(sharpened, 0, 255, out=sharpened)
-    sharpened = sharpened.astype(np.uint8)
+    sharpened = sharpened.astype(image._data.dtype)
 
     return Result(
         image=sharpened,
@@ -90,7 +90,7 @@ def apply_unsharp_masking(
 
     Returns:
         Result object with sharpened image and metadata:
-        - image: Sharpened image array
+        - image: Sharpened image array (same dtype as the input)
         - data: None
         - meta: Operation info and coefficient used
 
@@ -101,21 +101,20 @@ def apply_unsharp_masking(
     if not isinstance(image, Image):
         raise TypeError("'image' must be an Image instance")
 
-    if not isinstance(coefficient, (int, float)) or coefficient < 0:
+    if isinstance(coefficient, bool) or not isinstance(coefficient, (int, float)) \
+            or coefficient < 0:
         raise ValueError("'coefficient' must be a non-negative number")
 
-    # Create the mask from original vs blurred difference
+    # Unsharp masking: original + coefficient * (original - blurred),
+    # computed in float space and clipped once at the end. cv2.subtract
+    # saturates negative mask values and addWeighted on the saturated mask
+    # brightens flat regions instead of sharpening, so both are avoided.
     blurred = cv2.blur(image._data, DEFAULT_KERNEL_SIZE)
-    mask = cv2.subtract(image._data, blurred)
-
-    # Apply unsharp masking
-    sharpened = cv2.addWeighted(
-        image._data,
-        1 + coefficient,
-        mask,
-        -coefficient,
-        0
-    )
+    mask = image._data.astype(np.float64) - blurred.astype(np.float64)
+
+    sharpened = image._data.astype(np.float64) + coefficient * mask
+    np.clip(sharpened, 0, 255, out=sharpened)
+    sharpened = sharpened.astype(image._data.dtype)
 
     return Result(
         image=sharpened,

ImagePRO/utils/image.py

@@ -13,7 +13,7 @@ Colorspace = Literal["BGR", "RGB", "GRAY"]
 SourceType = Literal["path", "array"]
 
 
-@dataclass
+@dataclass(frozen=True)
 class Image:
     """
     Lightweight, immutable image wrapper for ImagePRO.
@@ -72,11 +72,18 @@ class Image:
         """
         if not isinstance(path, (str, Path)):
             raise TypeError("'path' must be a string or pathlib.Path.")
-        np_image = cv2.imread(str(path))
-        if np_image is None:
-            raise ValueError(f"Failed to load image from {path}")
         if colorspace not in ("BGR", "RGB", "GRAY"):
             raise ValueError("'colorspace' must be one of 'BGR', 'RGB', 'GRAY'.")
+
+        # cv2.imread always returns BGR; grayscale output requires the
+        # IMREAD_GRAYSCALE flag up front (post-hoc conversion of the BGR
+        # result would work numerically but this loads 1 channel directly).
+        imread_flag = cv2.IMREAD_GRAYSCALE if colorspace == "GRAY" else cv2.IMREAD_COLOR
+        np_image = cv2.imread(str(path), imread_flag)
+        if np_image is None:
+            raise ValueError(f"Failed to load image from {path}")
+        if colorspace == "RGB":
+            np_image = cv2.cvtColor(np_image, cv2.COLOR_BGR2RGB)
         return cls(_data=np_image, path=Path(path), colorspace=colorspace, source_type="path")
 
     @classmethod

ImagePRO/utils/result.py

@@ -77,26 +77,28 @@ class Result:
 
         # Save single image
         if isinstance(self.image, np.ndarray):
+            if not out_path.suffix:
+                # OpenCV picks its writer from the file extension, so an
+                # extensionless path would fail in imwrite; default to .png.
+                out_path = out_path.with_name(f"{out_path.name}.png")
             ok = cv2.imwrite(str(out_path), self.image)
             if not ok:
                 raise IOError(f"Failed to save image: {out_path}")
             return self
 
         # Save list of images with auto-suffixes
-        base = str(out_path)
+        base = Path(out_path)
+        stem, suffix = base.stem, base.suffix
+        if not suffix:
+            # cv2.imwrite needs an extension to choose a writer.
+            suffix = ".png"
+            base = base.with_name(f"{stem}.png")
         for idx, img in enumerate(self.image):
             if idx == 0:
-                path_i = base
+                path_i = str(base)
             else:
-                # Suffix logic: .jpg → _{idx}.jpg, else _{idx} before extension
-                if base.endswith(".jpg"):
-                    path_i = base.replace(".jpg", f"_{idx}.jpg")
-                else:
-                    p = Path(base)
-                    if p.suffix:
-                        path_i = str(p.with_name(f"{p.stem}_{idx}{p.suffix}"))
-                    else:
-                        path_i = f"{base}_{idx}"
+                # Suffix logic: out.jpg -> out_1.jpg, out_2.jpg, ...
+                path_i = str(base.with_name(f"{stem}_{idx}{suffix}"))
             ok = cv2.imwrite(path_i, img)
             if not ok:
                 raise IOError(f"Failed to save image: {path_i}")
@@ -115,7 +117,9 @@ class Result:
             path (str | Path):
                 Output CSV file path.
             rows (Optional[list[list[Any]]], optional):
-                Data to write as rows. If None, uses self.data. Defaults to None.
+                Data to write as rows. If None, uses self.data.
+                A 2D numpy.ndarray is also accepted (one CSV row per array
+                row). Defaults to None.
 
         Returns:
             Result: Self, for method chaining.
@@ -135,7 +139,10 @@ class Result:
         try:
             with out_path.open("w", newline="", encoding="utf-8") as f:
                 writer = csv.writer(f)
-                if isinstance(payload, (list, tuple)):
+                if isinstance(payload, np.ndarray):
+                    # Write one CSV row per array row
+                    writer.writerows(payload.tolist())
+                elif isinstance(payload, (list, tuple)):
                     writer.writerows(flatten_rows(payload))
                 else:
                     writer.writerow([payload])

{imagepro_python-1.4.0.dist-info → imagepro_python-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ImagePRO-Python
-Version: 1.4.0
+Version: 1.5.0
 Summary: Professional & modular image processing library with OpenCV, MediaPipe, and YOLO integration.
 Author-email: Parsa Safaie <parsasafaie.2568@proton.me>
 License: MIT
@@ -207,7 +207,7 @@ ImagePRO is built with a modular architecture designed for extensibility and mai
 - **Documentation**: Google-style docstrings for all functions
 
 ### Key Design Principles
-- **Non-Destructive Operations**: Operations never write into the input image; they return results in new `Result` objects (note: `crop_image` returns a view into the source array)
+- **Non-Destructive Operations**: Operations never write into the input image; they return results in new `Result` objects
 - **Functional Style**: Stateless functions that can be easily composed
 - **Result Objects**: Unified return type containing image, data, and metadata
 - **Keyword Arguments**: All optional parameters use keyword-only syntax

imagepro_python-1.5.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+ImagePRO/__init__.py,sha256=Rv5QiWX7e-OlR3DoLBaV5394xw6jwmarJrr2d0_RN50,1081
+ImagePRO/human_analysis/__init__.py,sha256=uSU0lM1p1HM6TNGv6u0nPHWy9QY505v43lqTkhClddM,190
+ImagePRO/human_analysis/body_analysis/__init__.py,sha256=uUWG5eOxLQjZoYddmNkRlF66l6vSVyJpUFz1wDddXkk,374
+ImagePRO/human_analysis/body_analysis/body_pose_estimation.py,sha256=gLWM5N2cMUNxyRX-7_z_52MnE8J9JM_UgAPoUWPCFpY,6567
+ImagePRO/human_analysis/body_analysis/hand_tracking.py,sha256=g9rRf2dXA8eaepa0DB7qY01rA2POlpMjtyl3iFXhfck,8011
+ImagePRO/human_analysis/face_analysis/__init__.py,sha256=297IQuoO2Wb_PyigS_2NOuVnM7FpNPceu5jhJp6YdG0,604
+ImagePRO/human_analysis/face_analysis/eye_status_analysis.py,sha256=0bfzRuD6qpdANS33s-2XY5udDXVvoV2mGCwQbT0x0Zc,8150
+ImagePRO/human_analysis/face_analysis/face_comparison.py,sha256=MbQ91LNlA7ySepR2IGUGrkNjTp-L-lj2NZw3HZ4WO84,4671
+ImagePRO/human_analysis/face_analysis/face_detection.py,sha256=kBZfHD79ls6tMZr6avVIXv8NpPyd1Dyq4iXpEeNwFM8,4090
+ImagePRO/human_analysis/face_analysis/face_mesh_analysis.py,sha256=09tkJlzA2aSPDKEgf68O5OLEStP55W9JRb0M8z_P4mA,9369
+ImagePRO/human_analysis/face_analysis/head_pose_estimation.py,sha256=wJryUR4B-uf6aMIdbZxe5894HcPmHmG-THyH376jG-Q,8542
+ImagePRO/object_analysis/__init__.py,sha256=eVQpYlHO89RYKT0CHjPfJjjif5X_Jx3AtAUpR5m0Yms,292
+ImagePRO/object_analysis/object_detection.py,sha256=X7LCJdKMBpBqA4gXDq3W_5AQnf_CA83jTww0Vdqtypo,3903
+ImagePRO/pipeline/__init__.py,sha256=-32hbR492qwxutXau7EfnysXbhW8fKKMywkV0ejIMFE,301
+ImagePRO/pipeline/pipeline.py,sha256=n-Y-FtQbIiXiYsP-RekmCZg4cKlylU_quWyrEGsnSQw,13953
+ImagePRO/pre_processing/__init__.py,sha256=pw6-J5sdbkdBG4RlTxOzQKaspGnlPIGo3m_NXH2bVCE,559
+ImagePRO/pre_processing/blur.py,sha256=RO4na6x3cm80nduFR91WEOasIN5RtiPCfqwwuorLivo,8220
+ImagePRO/pre_processing/contrast.py,sha256=B0BweCI0NnDwd2JcVL6GPUVjF7NX_MKWhiovYsC47h4,6001
+ImagePRO/pre_processing/crop.py,sha256=ByIe2whvqoaEZVRzCMW8HBP7fsoaQDPLQIHPT4NB3Lo,2649
+ImagePRO/pre_processing/dataset_generator.py,sha256=w1CImp1dP0RWwblUP3pcD6v0MG0nr4-a3MWZu_7oPOE,10922
+ImagePRO/pre_processing/grayscale.py,sha256=MRCsFRIaL45sYVHzhuNyZBXsP7PF-yorn0Wt7xONvpY,1781
+ImagePRO/pre_processing/histogram.py,sha256=1Xr7pEL-3UvpiPEpaenPCO4ZSK6gOxmOUFuDcxWmtx4,2927
+ImagePRO/pre_processing/resize.py,sha256=lHLA69cBUN25UNblmSJTk3iG6nKNF_51vQguCbPwxt4,1824
+ImagePRO/pre_processing/rotate.py,sha256=HtbMCh7p_BY5n3tl974Iboyv1XRMhfORPlEBGjjGpCs,4228
+ImagePRO/pre_processing/sharpen.py,sha256=y2dzaesjsKyonvobXCPOiFtD1H5y3_Hdi7GpX1v6jO4,4134
+ImagePRO/utils/__init__.py,sha256=McVd-o9KtKOpAVYbLi19KxsatPPFFF-Qbt0gdgY3Ln8,170
+ImagePRO/utils/image.py,sha256=_q34vEcP2-iJdJkiYFbc2obxyK5EPue-pJlrfV50Arc,4458
+ImagePRO/utils/result.py,sha256=UnOLI8MSJIMCNrvMmhvJgxDXbGAMHmu9hgJ2gw64buQ,6577
+imagepro_python-1.5.0.dist-info/licenses/LICENSE,sha256=sehkHN7dbe5umrINZJyJjIf9VTemZSgTfJlq6iIsbJQ,1069
+imagepro_python-1.5.0.dist-info/METADATA,sha256=WUGiP3SF3DjQ0-Jl8unZDHx1yBonAdujVl3y_UTT5TE,11063
+imagepro_python-1.5.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+imagepro_python-1.5.0.dist-info/top_level.txt,sha256=UOuPzsoWrVKXgUupOSI96shJ6wE8Fhz-8bm8oMlLC3s,9
+imagepro_python-1.5.0.dist-info/RECORD,,

imagepro_python-1.4.0.dist-info/RECORD

@@ -1,33 +0,0 @@
-ImagePRO/__init__.py,sha256=3B8cQH4zhV6EEAvVMKYMsJHok_hpGLTgu4QfP33DV08,1081
-ImagePRO/human_analysis/__init__.py,sha256=uSU0lM1p1HM6TNGv6u0nPHWy9QY505v43lqTkhClddM,190
-ImagePRO/human_analysis/body_analysis/__init__.py,sha256=uUWG5eOxLQjZoYddmNkRlF66l6vSVyJpUFz1wDddXkk,374
-ImagePRO/human_analysis/body_analysis/body_pose_estimation.py,sha256=yqEV18ZEZwV__Oqt1Hi72EGmbTNes-mrY068SBT9RbU,6245
-ImagePRO/human_analysis/body_analysis/hand_tracking.py,sha256=SpdIZNgvaHzINpWu7rgNawSHvuuawzFtQ7JiHHQ0fqA,7578
-ImagePRO/human_analysis/face_analysis/__init__.py,sha256=297IQuoO2Wb_PyigS_2NOuVnM7FpNPceu5jhJp6YdG0,604
-ImagePRO/human_analysis/face_analysis/eye_status_analysis.py,sha256=Q_EUNPpXoF7Vi-Kd0gURNxs9X3U5J4Yi3coL_6lkeb8,7773
-ImagePRO/human_analysis/face_analysis/face_comparison.py,sha256=lIr490PAf8R6C_Zhv-zBN1Un1EPiwxi4W7ahgkqXAVc,4724
-ImagePRO/human_analysis/face_analysis/face_detection.py,sha256=F3Bq_0rAcQklmNAu-JvxGBIxUnWmyM-SHuZawHXJeac,4009
-ImagePRO/human_analysis/face_analysis/face_mesh_analysis.py,sha256=rv08Mx_IBB-hjTh09bFaaPjaOm0tFbBs0brc4mE66mg,8723
-ImagePRO/human_analysis/face_analysis/head_pose_estimation.py,sha256=2_ZVpwavyIzCIH4x3d2bvCPvv-X5gpmSYxtk5jlgCYw,7688
-ImagePRO/object_analysis/__init__.py,sha256=eVQpYlHO89RYKT0CHjPfJjjif5X_Jx3AtAUpR5m0Yms,292
-ImagePRO/object_analysis/object_detection.py,sha256=1qPd3Xfo2Vi4JnBs5wD8-k3WR6ZkYNdT9tco2Ze1ICQ,3385
-ImagePRO/pipeline/__init__.py,sha256=-32hbR492qwxutXau7EfnysXbhW8fKKMywkV0ejIMFE,301
-ImagePRO/pipeline/pipeline.py,sha256=-CRWfWXB_lFdjrqg3gdyYFFvq0vZAednrJnod6b4WYA,13802
-ImagePRO/pre_processing/__init__.py,sha256=pw6-J5sdbkdBG4RlTxOzQKaspGnlPIGo3m_NXH2bVCE,559
-ImagePRO/pre_processing/blur.py,sha256=3zNTNpvLZPdrtRtBziB6X8ys8M7cIvyPDhojTqR63jo,7950
-ImagePRO/pre_processing/contrast.py,sha256=4UT78ggW1rh_iaEI8FObDB4kpEmRRFWjdJES60SnHDM,5064
-ImagePRO/pre_processing/crop.py,sha256=3Nwerzo57kx1sZPr9m355P-qf1NuZSZEA5iUn2Q1704,2406
-ImagePRO/pre_processing/dataset_generator.py,sha256=i7UM4o8hznFUfUgbYI6H01EkQJOqt4IsI9IrjzzN8gQ,7921
-ImagePRO/pre_processing/grayscale.py,sha256=MRCsFRIaL45sYVHzhuNyZBXsP7PF-yorn0Wt7xONvpY,1781
-ImagePRO/pre_processing/histogram.py,sha256=sNTWWZXr5VLpOrF_PTTJ6TD8yv1zR1l9cMyXHe7JFIM,2596
-ImagePRO/pre_processing/resize.py,sha256=Rnde8l_PXck5OWQBEMOHgLeW2YkTz9Xfr6fGmz0sdm8,1760
-ImagePRO/pre_processing/rotate.py,sha256=wQj3nQpN-ilM0HHwovN--UdGEJkPCY0BJ0zAdyBxv-o,4174
-ImagePRO/pre_processing/sharpen.py,sha256=hOkY7QhzgMp9LXQwt56AP4enn24ntXlmFLe57Bxssvw,3682
-ImagePRO/utils/__init__.py,sha256=McVd-o9KtKOpAVYbLi19KxsatPPFFF-Qbt0gdgY3Ln8,170
-ImagePRO/utils/image.py,sha256=Y64mD97rTiJb8_uNYlyG227VZodeb4U1aGezMkj7MnM,4025
-ImagePRO/utils/result.py,sha256=ToQaOmUlTtobJkC65BG0YO_6BkBleMBn-0Qydko7cZc,6138
-imagepro_python-1.4.0.dist-info/licenses/LICENSE,sha256=sehkHN7dbe5umrINZJyJjIf9VTemZSgTfJlq6iIsbJQ,1069
-imagepro_python-1.4.0.dist-info/METADATA,sha256=POgVUYD-3fKBCKxkjSgKTZqCt5BWjvtfDBqlrn7Qg9I,11121
-imagepro_python-1.4.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-imagepro_python-1.4.0.dist-info/top_level.txt,sha256=UOuPzsoWrVKXgUupOSI96shJ6wE8Fhz-8bm8oMlLC3s,9
-imagepro_python-1.4.0.dist-info/RECORD,,