eye-cv 1.0.0__py3-none-any.whl

eye/__init__.py

@@ -0,0 +1,115 @@
+"""Public API surface for Eye.
+
+This module intentionally avoids importing optional dependencies at import-time.
+Most symbols are provided via lazy attribute loading (PEP 562) so that `import eye`
+works with only the core dependencies installed.
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.metadata as importlib_metadata
+from typing import Any
+
+try:
+    __version__ = importlib_metadata.version(__package__ or __name__)
+except importlib_metadata.PackageNotFoundError:  # pragma: no cover
+    __version__ = "development"
+
+
+_EXPORTS: dict[str, tuple[str, str]] = {
+    # Detection conversion
+    "auto_convert": ("eye.detection.auto_convert", "auto_convert"),
+    "from_yolo": ("eye.detection.auto_convert", "from_yolo"),
+    "from_pytorch": ("eye.detection.auto_convert", "from_pytorch"),
+    "from_tensorflow": ("eye.detection.auto_convert", "from_tensorflow"),
+    "from_opencv": ("eye.detection.auto_convert", "from_opencv"),
+
+    # Core data structures
+    "Detections": ("eye.detection.core", "Detections"),
+    "Classifications": ("eye.classification.core", "Classifications"),
+
+    # Tracking
+    "Tracker": ("eye.core.tracking", "Tracker"),
+    "TrackerType": ("eye.core.tracking", "TrackerType"),
+    "ByteTrack": ("eye.tracker.byte_tracker.core", "ByteTrack"),
+
+    # Smoothing
+    "KalmanSmoothing": ("eye.detection.tools.smoothing", "KalmanSmoothing"),
+    "ExponentialSmoothing": ("eye.detection.tools.smoothing", "ExponentialSmoothing"),
+    "smooth_detections": ("eye.detection.tools.smoothing", "smooth_detections"),
+    "SmoothingConfig": ("eye.detection.tools.smoothing_config", "SmoothingConfig"),
+    "SmoothingPreset": ("eye.detection.tools.smoothing_config", "SmoothingPreset"),
+    "get_smoothing_guide": ("eye.detection.tools.smoothing_config", "get_smoothing_guide"),
+
+    # Zones / tools
+    "PolygonZone": ("eye.detection.tools.polygon_zone", "PolygonZone"),
+    "PolygonZoneAnnotator": ("eye.detection.tools.polygon_zone", "PolygonZoneAnnotator"),
+    "LineZone": ("eye.detection.line_zone", "LineZone"),
+    "LineZoneAnnotator": ("eye.detection.line_zone", "LineZoneAnnotator"),
+    "LineZoneAnnotatorMulticlass": ("eye.detection.line_zone", "LineZoneAnnotatorMulticlass"),
+
+    # Video
+    "VideoInfo": ("eye.utils.video", "VideoInfo"),
+    "VideoWriter": ("eye.utils.video", "VideoWriter"),
+    "VideoSink": ("eye.utils.video", "VideoSink"),
+    "FPSMonitor": ("eye.utils.video", "FPSMonitor"),
+    "get_video_frames_generator": ("eye.utils.video", "get_video_frames_generator"),
+    "process_video": ("eye.utils.video", "process_video"),
+
+    # Common annotators
+    "BoxAnnotator": ("eye.annotators.core", "BoxAnnotator"),
+    "TraceAnnotator": ("eye.annotators.core", "TraceAnnotator"),
+    "BoxCornerAnnotator": ("eye.annotators.core", "BoxCornerAnnotator"),
+    "BoundingBoxAnnotator": ("eye.annotators.core", "BoundingBoxAnnotator"),
+    "LabelAnnotator": ("eye.annotators.core", "LabelAnnotator"),
+    "MaskAnnotator": ("eye.annotators.core", "MaskAnnotator"),
+    "HeatMapAnnotator": ("eye.annotators.core", "HeatMapAnnotator"),
+    "ColorLookup": ("eye.annotators.utils", "ColorLookup"),
+}
+
+
+_MODERN_EXPORTS = {
+    "GradientBoxAnnotator",
+    "NeonTraceAnnotator",
+    "ShadowBoxAnnotator",
+    "CornerBoxAnnotator",
+    "FPSAnnotator",
+    "InfoAnnotator",
+}
+
+
+__all__ = sorted({"__version__", *_EXPORTS.keys(), *_MODERN_EXPORTS})
+
+
+def __getattr__(name: str) -> Any:  # PEP 562
+    if name in _EXPORTS:
+        module_name, attr_name = _EXPORTS[name]
+        module = importlib.import_module(module_name)
+        value = getattr(module, attr_name)
+        globals()[name] = value
+        return value
+
+    if name in _MODERN_EXPORTS:
+        try:
+            module = importlib.import_module("eye.annotators.modern")
+            value = getattr(module, name)
+        except Exception:
+            # Keep the same behavior as the old eager-import version.
+            if name == "GradientBoxAnnotator":
+                value = __getattr__("BoxAnnotator")
+            elif name == "NeonTraceAnnotator":
+                value = __getattr__("TraceAnnotator")
+            elif name == "ShadowBoxAnnotator":
+                value = __getattr__("BoxAnnotator")
+            elif name == "CornerBoxAnnotator":
+                value = __getattr__("BoxCornerAnnotator")
+            elif name in {"FPSAnnotator", "InfoAnnotator"}:
+                value = None
+            else:
+                raise
+
+        globals()[name] = value
+        return value
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

eye/__init___supervision_original.py

@@ -0,0 +1,120 @@
+import importlib.metadata as importlib_metadata
+
+try:
+    # This will read version from pyproject.toml
+    __version__ = importlib_metadata.version(__package__ or __name__)
+except importlib_metadata.PackageNotFoundError:
+    __version__ = "development"
+
+from eye.annotators.core import (
+    BackgroundOverlayAnnotator,
+    BlurAnnotator,
+    BoundingBoxAnnotator,
+    BoxAnnotator,
+    BoxCornerAnnotator,
+    CircleAnnotator,
+    ColorAnnotator,
+    CropAnnotator,
+    DotAnnotator,
+    EllipseAnnotator,
+    HaloAnnotator,
+    HeatMapAnnotator,
+    IconAnnotator,
+    LabelAnnotator,
+    MaskAnnotator,
+    OrientedBoxAnnotator,
+    PercentageBarAnnotator,
+    PixelateAnnotator,
+    PolygonAnnotator,
+    RichLabelAnnotator,
+    RoundBoxAnnotator,
+    TraceAnnotator,
+    TriangleAnnotator,
+)
+from eye.annotators.utils import ColorLookup
+from eye.classification.core import Classifications
+from eye.dataset.core import (
+    BaseDataset,
+    ClassificationDataset,
+    DetectionDataset,
+)
+from eye.dataset.utils import mask_to_rle, rle_to_mask
+from eye.detection.core import Detections
+from eye.detection.line_zone import (
+    LineZone,
+    LineZoneAnnotator,
+    LineZoneAnnotatorMulticlass,
+)
+from eye.detection.lmm import LMM
+from eye.detection.overlap_filter import (
+    OverlapFilter,
+    box_non_max_merge,
+    box_non_max_suppression,
+    mask_non_max_suppression,
+)
+from eye.detection.tools.csv_sink import CSVSink
+from eye.detection.tools.inference_slicer import InferenceSlicer
+from eye.detection.tools.json_sink import JSONSink
+from eye.detection.tools.polygon_zone import PolygonZone, PolygonZoneAnnotator
+from eye.detection.tools.smoother import DetectionsSmoother
+from eye.detection.utils import (
+    box_iou_batch,
+    calculate_masks_centroids,
+    clip_boxes,
+    contains_holes,
+    contains_multiple_segments,
+    filter_polygons_by_area,
+    mask_iou_batch,
+    mask_to_polygons,
+    mask_to_xyxy,
+    move_boxes,
+    move_masks,
+    oriented_box_iou_batch,
+    pad_boxes,
+    polygon_to_mask,
+    polygon_to_xyxy,
+    scale_boxes,
+    xcycwh_to_xyxy,
+    xywh_to_xyxy,
+)
+from eye.draw.color import Color, ColorPalette
+from eye.draw.utils import (
+    calculate_optimal_line_thickness,
+    calculate_optimal_text_scale,
+    draw_filled_polygon,
+    draw_filled_rectangle,
+    draw_image,
+    draw_line,
+    draw_polygon,
+    draw_rectangle,
+    draw_text,
+)
+from eye.geometry.core import Point, Position, Rect
+from eye.geometry.utils import get_polygon_center
+from eye.keypoint.annotators import (
+    EdgeAnnotator,
+    VertexAnnotator,
+    VertexLabelAnnotator,
+)
+from eye.keypoint.core import KeyPoints
+from eye.metrics.detection import ConfusionMatrix, MeanAveragePrecision
+from eye.tracker.byte_tracker.core import ByteTrack
+from eye.utils.conversion import cv2_to_pillow, pillow_to_cv2
+from eye.utils.file import list_files_with_extensions
+from eye.utils.image import (
+    ImageSink,
+    create_tiles,
+    crop_image,
+    letterbox_image,
+    overlay_image,
+    resize_image,
+    scale_image,
+)
+from eye.utils.notebook import plot_image, plot_images_grid
+from eye.utils.video import (
+    FPSMonitor,
+    VideoInfo,
+    VideoSink,
+    get_video_frames_generator,
+    process_video,
+)

eye/annotators/base.py

@@ -0,0 +1,22 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar
+
+import numpy as np
+from PIL import Image
+
+from eye.detection.core import Detections
+
+ImageType = TypeVar("ImageType", np.ndarray, Image.Image)
+"""
+An image of type `np.ndarray` or `PIL.Image.Image`.
+
+Unlike a `Union`, ensures the type remains consistent. If a function
+takes an `ImageType` argument and returns an `ImageType`, when you
+pass an `np.ndarray`, you will get an `np.ndarray` back.
+"""
+
+
+class BaseAnnotator(ABC):
+    @abstractmethod
+    def annotate(self, scene: ImageType, detections: Detections) -> ImageType:
+        pass