ImagePRO-Python 0.1.0__py3-none-any.whl

ImagePRO/human_analysis/face_analysis/head_pose_estimation.py

@@ -0,0 +1,148 @@
+import sys
+from pathlib import Path
+
+import cv2
+import mediapipe as mp
+
+# 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
+
+mp_face_mesh = mp.solutions.face_mesh
+
+
+def estimate_head_pose(
+    max_faces=1,
+    min_confidence=0.7,
+    image_path=None,
+    np_image=None,
+    result_path=None,
+    face_mesh_obj=None
+):
+    """
+    Estimate head pose (yaw, pitch) from facial landmarks.
+
+    Args:
+        max_faces (int): 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): Input image as array.
+        result_path (str, optional): If given, save results as CSV.
+        face_mesh_obj (FaceMesh, optional): Reusable MediaPipe instance.
+
+    Returns:
+        str or list[list]: CSV confirmation if saved, else list of [face_id, yaw, pitch].
+
+    Raises:
+        ValueError: On invalid input or no detected face.
+    """
+    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.")
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+
+    # Important landmark indices (MediaPipe 468 model)
+    indices = [1, 152, 33, 263, 168]  # nose_tip, chin, left_eye, right_eye, nasion
+
+    _, landmarks = analyze_face_mesh(
+        max_faces=max_faces,
+        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.")
+
+    results = []
+    for face in landmarks:
+        points = {lm[1]: lm for lm in face}
+
+        try:
+            nose_x, nose_y = points[1][2:4]
+            chin_y = points[152][3]
+            left_x = points[33][2]
+            right_x = points[263][2]
+            nasion_x, nasion_y = points[168][2:4]
+        except KeyError:
+            continue  # skip this face if any point is missing
+
+        # Simplified proportional estimation
+        yaw = 100 * ((right_x - nasion_x) - (nasion_x - left_x))
+        pitch = 100 * ((chin_y - nose_y) - (nose_y - nasion_y))
+
+        results.append([face[0][0], yaw, pitch])  # face_id, yaw, pitch
+
+    if result_path:
+        return IOHandler.save_csv(results, result_path)
+
+    return results
+
+
+def estimate_head_pose_live(max_faces=1, min_confidence=0.7):
+    """
+    Live head pose estimation using webcam.
+
+    Args:
+        max_faces (int): Number of faces to detect.
+        min_confidence (float): Confidence threshold (0–1).
+
+    Raises:
+        ValueError, RuntimeError: On invalid inputs or camera failure.
+    """
+    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("Failed to access 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:
+            ret, frame = cap.read()
+            if not ret:
+                print("Skipping empty frame.")
+                continue
+
+            try:
+                face_angles = estimate_head_pose(
+                    max_faces=max_faces,
+                    min_confidence=min_confidence,
+                    np_image=frame,
+                    face_mesh_obj=face_mesh
+                )
+            except ValueError:
+                face_angles = []
+
+            for i, face in enumerate(face_angles):
+                face_id, yaw, pitch = face
+                text = f"Face {int(face_id)+1}: Yaw={yaw:.2f}, Pitch={pitch:.2f}"
+                cv2.putText(frame, text, (10, 30 + i * 25),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+
+            cv2.imshow("ImagePRO - Head Pose Estimation", frame)
+
+            if cv2.waitKey(5) & 0xFF == 27:  # ESC
+                break
+    finally:
+        cap.release()
+        cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    estimate_head_pose_live()

ImagePRO/pre_processing/blur.py

@@ -0,0 +1,130 @@
+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
+sys.path.append(str(parent_dir))
+
+from io_handler import IOHandler
+
+
+def apply_average_blur(kernel_size=(5, 5), image_path=None, np_image=None, result_path=None):
+    """
+    Apply average blur (box filter) to an image.
+
+    Args:
+        kernel_size (tuple): (width, height) of the blur kernel.
+        image_path (str, optional): Path to input image.
+        np_image (np.ndarray, optional): Image array.
+        result_path (str, optional): Path to save output.
+
+    Returns:
+        str or np.ndarray: Saved message or blurred image.
+
+    Raises:
+        TypeError, ValueError: On invalid inputs.
+    """
+    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)
+    ):
+        raise ValueError("'kernel_size' must be a tuple of two positive integers.")
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+    blurred = cv2.blur(np_image, kernel_size)
+    return IOHandler.save_image(blurred, result_path)
+
+
+def apply_gaussian_blur(kernel_size=(5, 5), image_path=None, np_image=None, result_path=None):
+    """
+    Apply Gaussian blur to an image.
+
+    Args:
+        kernel_size (tuple): (width, height), both odd positive integers.
+        image_path (str, optional): Path to input image.
+        np_image (np.ndarray, optional): Image array.
+        result_path (str, optional): Path to save output.
+
+    Returns:
+        str or np.ndarray: Saved message or blurred image.
+
+    Raises:
+        TypeError, ValueError: On invalid inputs.
+    """
+    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)
+    ):
+        raise ValueError("'kernel_size' must be a tuple of two odd positive integers.")
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+    blurred = cv2.GaussianBlur(np_image, kernel_size, sigmaX=0)
+    return IOHandler.save_image(blurred, result_path)
+
+
+def apply_median_blur(filter_size=5, image_path=None, np_image=None, result_path=None):
+    """
+    Apply median blur to remove salt-and-pepper noise.
+
+    Args:
+        filter_size (int): Must be an odd integer greater than 1.
+        image_path (str, optional): Path to input image.
+        np_image (np.ndarray, optional): Image array.
+        result_path (str, optional): Path to save output.
+
+    Returns:
+        str or np.ndarray: Saved message or blurred image.
+
+    Raises:
+        TypeError, ValueError: On invalid inputs.
+    """
+    if not isinstance(filter_size, int):
+        raise TypeError("'filter_size' must be an integer.")
+    if filter_size <= 1 or filter_size % 2 == 0:
+        raise ValueError("'filter_size' must be an odd integer greater than 1.")
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+    blurred = cv2.medianBlur(np_image, filter_size)
+    return IOHandler.save_image(blurred, result_path)
+
+
+def apply_bilateral_blur(
+    filter_size=9,
+    sigma_color=75,
+    sigma_space=75,
+    image_path=None,
+    np_image=None,
+    result_path=None,
+):
+    """
+    Apply bilateral filter to smooth while preserving edges.
+
+    Args:
+        filter_size (int): Diameter of pixel neighborhood.
+        sigma_color (float): Color-space standard deviation.
+        sigma_space (float): Coordinate-space standard deviation.
+        image_path (str, optional): Path to input image.
+        np_image (np.ndarray, optional): Image array.
+        result_path (str, optional): Path to save output.
+
+    Returns:
+        str or np.ndarray: Saved message or blurred image.
+
+    Raises:
+        TypeError, ValueError: On invalid inputs.
+    """
+    if not isinstance(filter_size, int) or filter_size < 1:
+        raise ValueError("'filter_size' must be a positive integer.")
+    if 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:
+        raise ValueError("'sigma_space' must be a positive number.")
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+    blurred = cv2.bilateralFilter(np_image, filter_size, sigma_color, sigma_space)
+    return IOHandler.save_image(blurred, result_path)

ImagePRO/pre_processing/contrast.py

@@ -0,0 +1,105 @@
+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
+sys.path.append(str(parent_dir))
+
+from pre_processing.grayscale import convert_to_grayscale
+from io_handler import IOHandler
+
+
+def apply_clahe_contrast(
+    clipLimit=2.0,
+    tileGridSize=(8, 8),
+    image_path=None,
+    np_image=None,
+    result_path=None,
+):
+    """
+    Enhance contrast using CLAHE (adaptive histogram equalization).
+
+    Args:
+        clipLimit (float): Contrast threshold (must be > 0).
+        tileGridSize (tuple): Grid size for local histogram (e.g., (8, 8)).
+        image_path (str, optional): Path to input image.
+        np_image (np.ndarray, optional): Image array.
+        result_path (str, optional): Path to save result.
+
+    Returns:
+        str or np.ndarray: Confirmation if saved, else enhanced image.
+
+    Raises:
+        ValueError, TypeError: On invalid parameter values.
+    """
+    if not isinstance(clipLimit, (int, float)) or clipLimit <= 0:
+        raise ValueError("'clipLimit' must be a positive number.")
+
+    if (
+        not isinstance(tileGridSize, tuple)
+        or len(tileGridSize) != 2
+        or not all(isinstance(i, int) and i > 0 for i in tileGridSize)
+    ):
+        raise TypeError("'tileGridSize' must be a tuple of two positive integers.")
+
+    np_image = convert_to_grayscale(np_image=IOHandler.load_image(image_path=image_path, np_image=np_image))
+
+    clahe = cv2.createCLAHE(clipLimit=clipLimit, tileGridSize=tileGridSize)
+    enhanced = clahe.apply(np_image)
+
+    return IOHandler.save_image(enhanced, result_path)
+
+
+def apply_histogram_equalization(image_path=None, np_image=None, result_path=None):
+    """
+    Enhance contrast using global histogram equalization.
+
+    Args:
+        image_path (str, optional): Path to input image.
+        np_image (np.ndarray, optional): Image array.
+        result_path (str, optional): Path to save result.
+
+    Returns:
+        str or np.ndarray: Confirmation if saved, else enhanced image.
+    """
+    np_image = convert_to_grayscale(np_image=IOHandler.load_image(image_path=image_path, np_image=np_image))
+    enhanced = cv2.equalizeHist(np_image)
+    return IOHandler.save_image(enhanced, result_path)
+
+
+def apply_contrast_stretching(
+    alpha,
+    beta,
+    image_path=None,
+    np_image=None,
+    result_path=None,
+):
+    """
+    Enhance contrast by linear contrast stretching (alpha × pixel + beta).
+
+    Args:
+        alpha (float): Contrast factor (>= 0).
+        beta (int): Brightness offset (0–255).
+        image_path (str, optional): Path to input image.
+        np_image (np.ndarray, optional): Image array.
+        result_path (str, optional): Path to save result.
+
+    Returns:
+        str or np.ndarray: Confirmation if saved, else enhanced image.
+
+    Raises:
+        ValueError: If parameters are out of range.
+    """
+    if 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):
+        raise ValueError("'beta' must be an integer between 0 and 255.")
+
+    np_image = convert_to_grayscale(np_image=IOHandler.load_image(image_path=image_path, np_image=np_image))
+    enhanced = cv2.convertScaleAbs(np_image, alpha=alpha, beta=beta)
+
+    return IOHandler.save_image(enhanced, result_path)

ImagePRO/pre_processing/crop.py

@@ -0,0 +1,51 @@
+import sys
+from pathlib import Path
+
+# Add parent directory to sys.path for importing custom modules
+parent_dir = Path(__file__).resolve().parent.parent
+sys.path.append(str(parent_dir))
+
+from io_handler import IOHandler
+
+
+def crop_image(start_point, end_point, image_path=None, np_image=None, result_path=None):
+    """
+    Crop image using top-left and bottom-right coordinates.
+
+    Args:
+        start_point (tuple): (x1, y1) top-left corner.
+        end_point (tuple): (x2, y2) bottom-right corner.
+        image_path (str, optional): Path to input image. Overrides `np_image` if provided.
+        np_image (np.ndarray, optional): Image array. Used if `image_path` is None.
+        result_path (str, optional): Path to save cropped image.
+
+    Returns:
+        str or np.ndarray: Save message if saved, else cropped image array.
+
+    Raises:
+        TypeError: If inputs are not proper tuples of integers.
+        ValueError: If coordinates are invalid or out of image bounds.
+    """
+    # Validate coordinates
+    if (
+        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)
+    ):
+        raise TypeError("Both 'start_point' and 'end_point' must be (x, y) tuples of integers.")
+
+    x1, y1 = start_point
+    x2, y2 = end_point
+
+    if x1 < 0 or y1 < 0 or x2 <= x1 or y2 <= y1:
+        raise ValueError("Invalid crop coordinates: ensure (x1, y1) is top-left and (x2, y2) is bottom-right.")
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+    height, width = np_image.shape[:2]
+
+    if x2 > width or y2 > height:
+        raise ValueError(f"Crop area exceeds image bounds ({width}x{height}).")
+
+    cropped = np_image[y1:y2, x1:x2]
+    return IOHandler.save_image(cropped, result_path)

ImagePRO/pre_processing/grayscale.py

@@ -0,0 +1,27 @@
+import sys
+from pathlib import Path
+
+import cv2
+
+# Add parent directory to sys.path for importing custom modules
+parent_dir = Path(__file__).resolve().parent.parent
+sys.path.append(str(parent_dir))
+
+from io_handler import IOHandler
+
+
+def convert_to_grayscale(image_path=None, np_image=None, result_path=None):
+    """
+    Convert a BGR image to single-channel grayscale.
+
+    Args:
+        image_path (str, optional): Path to input image file.
+        np_image (np.ndarray, optional): Image array (used if image_path is None).
+        result_path (str, optional): Path to save grayscale image.
+
+    Returns:
+        str or np.ndarray: Confirmation message if saved, else grayscale image.
+    """
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+    grayscale = cv2.cvtColor(np_image, cv2.COLOR_BGR2GRAY)
+    return IOHandler.save_image(grayscale, result_path)

ImagePRO/pre_processing/resize.py

@@ -0,0 +1,43 @@
+import sys
+from pathlib import Path
+
+import cv2
+
+# Add parent directory to sys.path for importing custom modules
+parent_dir = Path(__file__).resolve().parent.parent
+sys.path.append(str(parent_dir))
+
+from io_handler import IOHandler
+
+
+def resize_image(new_size, image_path=None, np_image=None, result_path=None):
+    """
+    Resize image to specified dimensions.
+
+    Args:
+        new_size (tuple): (width, height), both positive integers.
+        image_path (str, optional): Path to input image. Overrides `np_image` if given.
+        np_image (np.ndarray, optional): Image array (used if image_path is None).
+        result_path (str, optional): Save path. If None, returns resized image.
+
+    Returns:
+        str or np.ndarray: Confirmation message if saved, else resized image.
+
+    Raises:
+        TypeError: If new_size is not a tuple of two integers.
+        ValueError: If width or height are not positive.
+    """
+    if (
+        not isinstance(new_size, tuple) or
+        len(new_size) != 2 or
+        not all(isinstance(x, int) for x in new_size)
+    ):
+        raise TypeError("'new_size' must be a tuple of two integers: (width, height).")
+
+    if new_size[0] <= 0 or new_size[1] <= 0:
+        raise ValueError("Both width and height must be positive integers.")
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+    resized = cv2.resize(np_image, dsize=new_size)
+
+    return IOHandler.save_image(resized, result_path)

ImagePRO/pre_processing/rotate.py

@@ -0,0 +1,94 @@
+import sys
+from pathlib import Path
+
+import cv2
+
+# Add parent directory to sys.path for custom imports
+parent_dir = Path(__file__).resolve().parent.parent
+sys.path.append(str(parent_dir))
+
+from io_handler import IOHandler
+
+
+def rotate_image_90(image_path=None, np_image=None, result_path=None):
+    """
+    Rotate image 90 degrees clockwise.
+
+    Args:
+        image_path (str, optional): Path to input image file.
+        np_image (np.ndarray, optional): Image as NumPy array.
+        result_path (str, optional): Path to save rotated image.
+
+    Returns:
+        str or np.ndarray: Save message if result_path is given, else rotated image.
+    """
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+    rotated = cv2.rotate(np_image, cv2.ROTATE_90_CLOCKWISE)
+    return IOHandler.save_image(rotated, result_path)
+
+
+def rotate_image_180(image_path=None, np_image=None, result_path=None):
+    """
+    Rotate image 180 degrees.
+
+    Args:
+        image_path (str, optional): Path to input image file.
+        np_image (np.ndarray, optional): Image as NumPy array.
+        result_path (str, optional): Path to save rotated image.
+
+    Returns:
+        str or np.ndarray: Save message if result_path is given, else rotated image.
+    """
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+    rotated = cv2.rotate(np_image, cv2.ROTATE_180)
+    return IOHandler.save_image(rotated, result_path)
+
+
+def rotate_image_270(image_path=None, np_image=None, result_path=None):
+    """
+    Rotate image 270 degrees clockwise (same as 90 degrees counter-clockwise).
+
+    Args:
+        image_path (str, optional): Path to input image file.
+        np_image (np.ndarray, optional): Image as NumPy array.
+        result_path (str, optional): Path to save rotated image.
+
+    Returns:
+        str or np.ndarray: Save message if result_path is given, else rotated image.
+    """
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+    rotated = cv2.rotate(np_image, cv2.ROTATE_90_COUNTERCLOCKWISE)
+    return IOHandler.save_image(rotated, result_path)
+
+
+def rotate_image_custom(angle, scale=1.0, image_path=None, np_image=None, result_path=None):
+    """
+    Rotate image by custom angle around its center, with optional scaling.
+
+    Args:
+        angle (float): Rotation angle in degrees (positive = counter-clockwise).
+        scale (float): Scale factor (default = 1.0).
+        image_path (str, optional): Path to input image file.
+        np_image (np.ndarray, optional): Image as NumPy array.
+        result_path (str, optional): Path to save rotated image.
+
+    Returns:
+        str or np.ndarray: Save message if result_path is given, else rotated image.
+
+    Raises:
+        TypeError: If angle or scale are of incorrect type.
+        ValueError: If scale is non-positive.
+    """
+    if not isinstance(angle, (int, float)):
+        raise TypeError("'angle' must be a number.")
+    if not isinstance(scale, (int, float)) or scale <= 0:
+        raise ValueError("'scale' must be a positive number.")
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+
+    height, width = np_image.shape[:2]
+    center = (width / 2, height / 2)
+    matrix = cv2.getRotationMatrix2D(center=center, angle=angle, scale=scale)
+    rotated = cv2.warpAffine(np_image, matrix, (width, height))
+
+    return IOHandler.save_image(rotated, result_path)

ImagePRO/pre_processing/sharpen.py

@@ -0,0 +1,74 @@
+import sys
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+# Add parent directory to path for importing local modules
+parent_dir = Path(__file__).resolve().parent.parent
+sys.path.append(str(parent_dir))
+
+from io_handler import IOHandler
+from blur import apply_average_blur
+
+
+def apply_laplacian_sharpening(
+    laplacian_coefficient=3, image_path=None, np_image=None, result_path=None
+):
+    """
+    Apply Laplacian filter to enhance image sharpness.
+
+    Args:
+        laplacian_coefficient (float): Intensity of sharpening effect (>= 0).
+        image_path (str, optional): Path to input image. Overrides `np_image` if given.
+        np_image (np.ndarray, optional): Image as NumPy array.
+        result_path (str, optional): Path to save the result.
+
+    Returns:
+        str or np.ndarray: Message if saved, else the sharpened image array.
+
+    Raises:
+        ValueError: If `laplacian_coefficient` is negative or inputs are invalid.
+    """
+    if not isinstance(laplacian_coefficient, (int, float)) or laplacian_coefficient < 0:
+        raise ValueError("'laplacian_coefficient' must be a non-negative number.")
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+
+    laplacian = cv2.Laplacian(np_image, cv2.CV_64F)
+    laplacian = np.uint8(np.absolute(laplacian))
+
+    sharpened = np_image + laplacian_coefficient * laplacian
+    sharpened = np.uint8(np.clip(sharpened, 0, 255))
+
+    return IOHandler.save_image(sharpened, result_path)
+
+
+def apply_unsharp_masking(
+    coefficient=1, image_path=None, np_image=None, result_path=None
+):
+    """
+    Apply Unsharp Masking to enhance image sharpness.
+
+    Args:
+        coefficient (float): Intensity of sharpening effect (>= 0).
+        image_path (str, optional): Path to input image. Overrides `np_image` if given.
+        np_image (np.ndarray, optional): Image as NumPy array.
+        result_path (str, optional): Path to save the result.
+
+    Returns:
+        str or np.ndarray: Message if saved, else the sharpened image array.
+
+    Raises:
+        ValueError: If `coefficient` is negative or inputs are invalid.
+    """
+    if not isinstance(coefficient, (int, float)) or coefficient < 0:
+        raise ValueError("'coefficient' must be a non-negative number.")
+
+    np_image = IOHandler.load_image(image_path=image_path, np_image=np_image)
+    blurred = apply_average_blur(np_image=np_image)
+
+    mask = cv2.subtract(np_image, blurred)
+    sharpened = cv2.addWeighted(np_image, 1 + coefficient, mask, -coefficient, 0)
+
+    return IOHandler.save_image(sharpened, result_path)

imagepro_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: ImagePRO-Python
+Version: 0.1.0
+Summary: clean, modular, and easy-to-use Python library for image processing tasks.
+Author-email: Parsa Safaie <parsasafaie.2568@proton.me>
+License: MIT
+Keywords: opencv,mediapipe,computer-vision,face,pose
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: ==3.10.*
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<3.0,>=1.24
+Requires-Dist: opencv-python<5.0,>=4.8
+Dynamic: license-file