eye-cv 1.0.0__py3-none-any.whl

eye/utils_eye/geometry.py

@@ -0,0 +1,71 @@
+"""Geometry utilities."""
+
+import numpy as np
+from dataclasses import dataclass
+from typing import Tuple
+
+
+@dataclass
+class Point:
+    """2D point."""
+    x: float
+    y: float
+    
+    def as_tuple(self) -> Tuple[float, float]:
+        return (self.x, self.y)
+    
+    def as_int_tuple(self) -> Tuple[int, int]:
+        return (int(self.x), int(self.y))
+
+
+def get_polygon_center(polygon: np.ndarray) -> Point:
+    """Calculate center of polygon."""
+    center_x = np.mean(polygon[:, 0])
+    center_y = np.mean(polygon[:, 1])
+    return Point(center_x, center_y)
+
+
+def is_point_in_polygon(points: np.ndarray, polygon: np.ndarray) -> np.ndarray:
+    """Check if points are inside polygon.
+    
+    Args:
+        points: (N, 2) array of points
+        polygon: (M, 2) array of polygon vertices
+    
+    Returns:
+        Boolean array of length N
+    """
+    from matplotlib.path import Path
+    path = Path(polygon)
+    return path.contains_points(points)
+
+
+def calculate_iou(box1: np.ndarray, box2: np.ndarray) -> float:
+    """Calculate IoU between two boxes.
+    
+    Args:
+        box1, box2: [x1, y1, x2, y2]
+    """
+    x1_inter = max(box1[0], box2[0])
+    y1_inter = max(box1[1], box2[1])
+    x2_inter = min(box1[2], box2[2])
+    y2_inter = min(box1[3], box2[3])
+    
+    if x2_inter < x1_inter or y2_inter < y1_inter:
+        return 0.0
+    
+    intersection = (x2_inter - x1_inter) * (y2_inter - y1_inter)
+    
+    area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
+    area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])
+    
+    union = area1 + area2 - intersection
+    
+    return intersection / (union + 1e-6)
+
+
+def polygon_area(polygon: np.ndarray) -> float:
+    """Calculate area of polygon using shoelace formula."""
+    x = polygon[:, 0]
+    y = polygon[:, 1]
+    return 0.5 * np.abs(np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))

eye/utils_eye/nms.py

@@ -0,0 +1,55 @@
+"""Non-maximum suppression."""
+
+import numpy as np
+
+
+def non_max_suppression(
+    boxes: np.ndarray,
+    scores: np.ndarray,
+    iou_threshold: float = 0.5
+) -> np.ndarray:
+    """Apply NMS to remove overlapping boxes.
+    
+    Args:
+        boxes: (N, 4) array of boxes [x1, y1, x2, y2]
+        scores: (N,) array of scores
+        iou_threshold: IoU threshold for suppression
+    
+    Returns:
+        Indices of boxes to keep
+    """
+    if len(boxes) == 0:
+        return np.array([], dtype=int)
+    
+    x1 = boxes[:, 0]
+    y1 = boxes[:, 1]
+    x2 = boxes[:, 2]
+    y2 = boxes[:, 3]
+    
+    areas = (x2 - x1) * (y2 - y1)
+    order = scores.argsort()[::-1]
+    
+    keep = []
+    while len(order) > 0:
+        i = order[0]
+        keep.append(i)
+        
+        xx1 = np.maximum(x1[i], x1[order[1:]])
+        yy1 = np.maximum(y1[i], y1[order[1:]])
+        xx2 = np.minimum(x2[i], x2[order[1:]])
+        yy2 = np.minimum(y2[i], y2[order[1:]])
+        
+        w = np.maximum(0, xx2 - xx1)
+        h = np.maximum(0, yy2 - yy1)
+        
+        intersection = w * h
+        iou = intersection / (areas[i] + areas[order[1:]] - intersection + 1e-6)
+        
+        inds = np.where(iou <= iou_threshold)[0]
+        order = order[inds + 1]
+    
+    return np.array(keep, dtype=int)
+
+
+# Alias for simpler name
+nms = non_max_suppression

eye/validators/__init__.py

@@ -0,0 +1,140 @@
+from typing import Any, Dict
+
+import numpy as np
+
+
+def validate_xyxy(xyxy: Any) -> None:
+    expected_shape = "(_, 4)"
+    actual_shape = str(getattr(xyxy, "shape", None))
+    is_valid = isinstance(xyxy, np.ndarray) and xyxy.ndim == 2 and xyxy.shape[1] == 4
+    if not is_valid:
+        raise ValueError(
+            f"xyxy must be a 2D np.ndarray with shape {expected_shape}, but got shape "
+            f"{actual_shape}"
+        )
+
+
+def validate_mask(mask: Any, n: int) -> None:
+    expected_shape = f"({n}, H, W)"
+    actual_shape = str(getattr(mask, "shape", None))
+    is_valid = mask is None or (
+        isinstance(mask, np.ndarray) and len(mask.shape) == 3 and mask.shape[0] == n
+    )
+    if not is_valid:
+        raise ValueError(
+            f"mask must be a 3D np.ndarray with shape {expected_shape}, but got shape "
+            f"{actual_shape}"
+        )
+
+
+def validate_class_id(class_id: Any, n: int) -> None:
+    expected_shape = f"({n},)"
+    actual_shape = str(getattr(class_id, "shape", None))
+    is_valid = class_id is None or (
+        isinstance(class_id, np.ndarray) and class_id.shape == (n,)
+    )
+    if not is_valid:
+        raise ValueError(
+            f"class_id must be a 1D np.ndarray with shape {expected_shape}, but got "
+            f"shape {actual_shape}"
+        )
+
+
+def validate_confidence(confidence: Any, n: int) -> None:
+    expected_shape = f"({n},)"
+    actual_shape = str(getattr(confidence, "shape", None))
+    is_valid = confidence is None or (
+        isinstance(confidence, np.ndarray) and confidence.shape == (n,)
+    )
+    if not is_valid:
+        raise ValueError(
+            f"confidence must be a 1D np.ndarray with shape {expected_shape}, but got "
+            f"shape {actual_shape}"
+        )
+
+
+def validate_keypoint_confidence(confidence: Any, n: int, m: int) -> None:
+    expected_shape = f"({n,m})"
+    actual_shape = str(getattr(confidence, "shape", None))
+
+    if confidence is not None:
+        is_valid = isinstance(confidence, np.ndarray) and confidence.shape == (n, m)
+        if not is_valid:
+            raise ValueError(
+                f"confidence must be a 1D np.ndarray with shape {expected_shape}, but "
+                f"got shape {actual_shape}"
+            )
+
+
+def validate_tracker_id(tracker_id: Any, n: int) -> None:
+    expected_shape = f"({n},)"
+    actual_shape = str(getattr(tracker_id, "shape", None))
+    is_valid = tracker_id is None or (
+        isinstance(tracker_id, np.ndarray) and tracker_id.shape == (n,)
+    )
+    if not is_valid:
+        raise ValueError(
+            f"tracker_id must be a 1D np.ndarray with shape {expected_shape}, but got "
+            f"shape {actual_shape}"
+        )
+
+
+def validate_data(data: Dict[str, Any], n: int) -> None:
+    for key, value in data.items():
+        if isinstance(value, list):
+            if len(value) != n:
+                raise ValueError(f"Length of list for key '{key}' must be {n}")
+        elif isinstance(value, np.ndarray):
+            if value.ndim == 1 and value.shape[0] != n:
+                raise ValueError(f"Shape of np.ndarray for key '{key}' must be ({n},)")
+            elif value.ndim > 1 and value.shape[0] != n:
+                raise ValueError(
+                    f"First dimension of np.ndarray for key '{key}' must have size {n}"
+                )
+        else:
+            raise ValueError(f"Value for key '{key}' must be a list or np.ndarray")
+
+
+def validate_xy(xy: Any, n: int, m: int) -> None:
+    expected_shape = f"({n, m},)"
+    actual_shape = str(getattr(xy, "shape", None))
+
+    is_valid = isinstance(xy, np.ndarray) and (
+        xy.shape == (n, m, 2) or xy.shape == (n, m, 3)
+    )
+    if not is_valid:
+        raise ValueError(
+            f"xy must be a 2D np.ndarray with shape {expected_shape}, but got shape "
+            f"{actual_shape}"
+        )
+
+
+def validate_detections_fields(
+    xyxy: Any,
+    mask: Any,
+    class_id: Any,
+    confidence: Any,
+    tracker_id: Any,
+    data: Dict[str, Any],
+) -> None:
+    validate_xyxy(xyxy)
+    n = len(xyxy)
+    validate_mask(mask, n)
+    validate_class_id(class_id, n)
+    validate_confidence(confidence, n)
+    validate_tracker_id(tracker_id, n)
+    validate_data(data, n)
+
+
+def validate_keypoints_fields(
+    xy: Any,
+    class_id: Any,
+    confidence: Any,
+    data: Dict[str, Any],
+) -> None:
+    n = len(xy)
+    m = len(xy[0]) if len(xy) > 0 else 0
+    validate_xy(xy, n, m)
+    validate_class_id(class_id, n)
+    validate_keypoint_confidence(confidence, n, m)
+    validate_data(data, n)

eye/web.py

@@ -0,0 +1,271 @@
+"""Web-ready API for Flask, FastAPI, Django, etc."""
+
+from typing import Dict, Any, Optional, List
+import base64
+import io
+import numpy as np
+import cv2
+from dataclasses import dataclass, asdict
+import json
+
+
+@dataclass
+class WebDetection:
+    """Web-friendly detection format (JSON serializable)."""
+    bbox: List[float]  # [x1, y1, x2, y2]
+    confidence: float
+    class_id: int
+    class_name: str
+    tracker_id: Optional[int] = None
+    mask: Optional[str] = None  # Base64 encoded
+
+
+@dataclass
+class WebResponse:
+    """Standard web API response."""
+    success: bool
+    detections: List[WebDetection]
+    frame_id: int
+    processing_time_ms: float
+    metadata: Dict[str, Any]
+    error: Optional[str] = None
+
+
+class WebAPI:
+    """Web-ready interface for Eye library.
+    
+    Features:
+    - JSON serializable responses
+    - Base64 image encoding/decoding
+    - CORS-ready
+    - Stateless operation
+    - Fast processing
+    
+    Perfect for: Flask, FastAPI, Django, Node.js bridges, etc.
+    """
+    
+    def __init__(
+        self,
+        model: Any,
+        tracker: Optional[Any] = None,
+        class_names: Optional[Dict[int, str]] = None
+    ):
+        """
+        Args:
+            model: Detection model (YOLO, etc.)
+            tracker: Optional tracker
+            class_names: Dict mapping class IDs to names
+        """
+        self.model = model
+        self.tracker = tracker
+        self.class_names = class_names or {}
+    
+    def process_base64(
+        self,
+        image_b64: str,
+        conf_threshold: float = 0.5,
+        frame_id: int = 0
+    ) -> Dict[str, Any]:
+        """Process base64-encoded image.
+        
+        Args:
+            image_b64: Base64 encoded image
+            conf_threshold: Confidence threshold
+            frame_id: Frame identifier
+        
+        Returns:
+            JSON-serializable dict
+        """
+        import time
+        start = time.time()
+        
+        try:
+            # Decode image
+            image = self.decode_base64_image(image_b64)
+            
+            # Process
+            response = self.process_image(image, conf_threshold, frame_id)
+            response.processing_time_ms = (time.time() - start) * 1000
+            
+            return asdict(response)
+        
+        except Exception as e:
+            return asdict(WebResponse(
+                success=False,
+                detections=[],
+                frame_id=frame_id,
+                processing_time_ms=(time.time() - start) * 1000,
+                metadata={},
+                error=str(e)
+            ))
+    
+    def process_image(
+        self,
+        image: np.ndarray,
+        conf_threshold: float = 0.5,
+        frame_id: int = 0
+    ) -> WebResponse:
+        """Process numpy image.
+        
+        Args:
+            image: Input image (numpy array)
+            conf_threshold: Confidence threshold
+            frame_id: Frame identifier
+        
+        Returns:
+            WebResponse
+        """
+        try:
+            from ..core.auto_detect import auto_convert
+        except ImportError:
+            from eye.core.auto_detect import auto_convert
+        
+        # Detect
+        results = self.model(image, conf=conf_threshold, verbose=False)
+        detections = auto_convert(results)
+        
+        # Track
+        if self.tracker:
+            detections = self.tracker.update(detections)
+        
+        # Convert to web format
+        web_dets = []
+        for i in range(len(detections)):
+            web_det = WebDetection(
+                bbox=detections.xyxy[i].tolist(),
+                confidence=float(detections.confidence[i]) if detections.confidence is not None else 1.0,
+                class_id=int(detections.class_id[i]) if detections.class_id is not None else 0,
+                class_name=self.class_names.get(
+                    int(detections.class_id[i]) if detections.class_id is not None else 0,
+                    'unknown'
+                ),
+                tracker_id=int(detections.tracker_id[i]) if detections.tracker_id is not None else None
+            )
+            web_dets.append(web_det)
+        
+        return WebResponse(
+            success=True,
+            detections=web_dets,
+            frame_id=frame_id,
+            processing_time_ms=0.0,  # Will be set by caller
+            metadata={
+                'image_shape': list(image.shape),
+                'num_detections': len(web_dets)
+            }
+        )
+    
+    @staticmethod
+    def decode_base64_image(image_b64: str) -> np.ndarray:
+        """Decode base64 image to numpy array."""
+        # Remove data URL prefix if present
+        if ',' in image_b64:
+            image_b64 = image_b64.split(',')[1]
+        
+        # Decode
+        img_bytes = base64.b64decode(image_b64)
+        img_array = np.frombuffer(img_bytes, dtype=np.uint8)
+        image = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
+        
+        return image
+    
+    @staticmethod
+    def encode_image_base64(image: np.ndarray, format: str = 'jpg') -> str:
+        """Encode numpy image to base64."""
+        _, buffer = cv2.imencode(f'.{format}', image)
+        img_b64 = base64.b64encode(buffer).decode('utf-8')
+        return f"data:image/{format};base64,{img_b64}"
+
+
+# Flask example
+def create_flask_app(model, tracker=None, class_names=None):
+    """Create Flask app with Eye detection endpoint.
+    
+    Example:
+        >>> from flask import Flask
+        >>> from ultralytics import YOLO
+        >>> import eye
+        >>> 
+        >>> model = YOLO("yolo11n.pt")
+        >>> app = eye.web.create_flask_app(model, class_names=model.names)
+        >>> app.run(host='0.0.0.0', port=5000)
+    """
+    try:
+        from flask import Flask, request, jsonify
+        from flask_cors import CORS
+    except ImportError:
+        raise ImportError("Flask not installed. Run: pip install flask flask-cors")
+    
+    app = Flask(__name__)
+    CORS(app)  # Enable CORS
+    
+    api = WebAPI(model, tracker, class_names)
+    
+    @app.route('/detect', methods=['POST'])
+    def detect():
+        """Detection endpoint."""
+        data = request.json
+        image_b64 = data.get('image')
+        conf_threshold = data.get('confidence', 0.5)
+        frame_id = data.get('frame_id', 0)
+        
+        result = api.process_base64(image_b64, conf_threshold, frame_id)
+        return jsonify(result)
+    
+    @app.route('/health', methods=['GET'])
+    def health():
+        """Health check endpoint."""
+        return jsonify({'status': 'healthy'})
+    
+    return app
+
+
+# FastAPI example
+def create_fastapi_app(model, tracker=None, class_names=None):
+    """Create FastAPI app with Eye detection endpoint.
+    
+    Example:
+        >>> from fastapi import FastAPI
+        >>> from ultralytics import YOLO
+        >>> import eye
+        >>> 
+        >>> model = YOLO("yolo11n.pt")
+        >>> app = eye.web.create_fastapi_app(model, class_names=model.names)
+        >>> # Run with: uvicorn main:app --host 0.0.0.0 --port 8000
+    """
+    try:
+        from fastapi import FastAPI
+        from fastapi.middleware.cors import CORSMiddleware
+        from pydantic import BaseModel
+    except ImportError:
+        raise ImportError("FastAPI not installed. Run: pip install fastapi uvicorn")
+    
+    app = FastAPI(title="Eye Detection API")
+    
+    # Enable CORS
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    
+    api = WebAPI(model, tracker, class_names)
+    
+    class DetectionRequest(BaseModel):
+        image: str
+        confidence: float = 0.5
+        frame_id: int = 0
+    
+    @app.post("/detect")
+    async def detect(request: DetectionRequest):
+        """Detection endpoint."""
+        result = api.process_base64(request.image, request.confidence, request.frame_id)
+        return result
+    
+    @app.get("/health")
+    async def health():
+        """Health check endpoint."""
+        return {"status": "healthy"}
+    
+    return app