openvisionkit 0.4.0__py3-none-any.whl

openvisionkit/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.0"

openvisionkit/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = "0.1.dev13+ga17e5ab6a.d20260610"
+__version_tuple__ = version_tuple = (0, 1, "dev13", "ga17e5ab6a.d20260610")
+
+__commit_id__ = commit_id = None

openvisionkit/capture/draw_object.py

@@ -0,0 +1,296 @@
+import uuid
+
+import cv2
+import numpy as np
+
+
+class DrawingObject:
+    def __init__(
+        self,
+        kind="circle",
+        origin=None,
+        placement="top-left",
+        size=(100, 100),
+        color=(0, 255, 0),
+        margin=20,
+        thickness=-1,
+        label=None,
+    ):
+        self.id = str(uuid.uuid4())
+
+        self.kind = kind
+        self.origin = origin
+        self.placement = placement
+        self.size = size
+        self.color = color
+        self.margin = margin
+        self.thickness = thickness
+        self.label = label
+
+        self.initialized = False
+
+        self.position = None
+        self.initial_position = None
+        self.center_point = None
+        self.bounding_box = None
+
+        # interaction state (useful for gestures)
+        self.is_hovered = False
+        self.is_selected = False
+
+    # ----------------------------
+    # POSITION RESOLUTION
+    # ----------------------------
+    def resolve_position(self, frame_shape):
+        frame_h, frame_w = frame_shape[:2]
+        obj_w, obj_h = self.size
+
+        positions = {
+            "top-left": (self.margin, self.margin),
+            "top": ((frame_w - obj_w) // 2, self.margin),
+            "top-right": (frame_w - obj_w - self.margin, self.margin),
+            "left": (self.margin, (frame_h - obj_h) // 2),
+            "center": ((frame_w - obj_w) // 2, (frame_h - obj_h) // 2),
+            "right": (frame_w - obj_w - self.margin, (frame_h - obj_h) // 2),
+            "bottom-left": (self.margin, frame_h - obj_h - self.margin),
+            "bottom": ((frame_w - obj_w) // 2, frame_h - obj_h - self.margin),
+            "bottom-right": (
+                frame_w - obj_w - self.margin,
+                frame_h - obj_h - self.margin,
+            ),
+        }
+
+        return positions.get(self.placement, positions["top-left"])
+
+    # ----------------------------
+    # UPDATE INTERNAL REFERENCES
+    # ----------------------------
+    def update_reference_points(self):
+        if self.origin is None:
+            return
+
+        x, y = self.origin
+        w, h = self.size
+
+        self.position = {"x": x, "y": y}
+
+        self.center_point = {
+            "x": x + w // 2,
+            "y": y + h // 2,
+        }
+
+        self.bounding_box = {
+            "x1": x,
+            "y1": y,
+            "x2": x + w,
+            "y2": y + h,
+        }
+
+    # ----------------------------
+    # INITIALIZATION
+    # ----------------------------
+    def initialize_position(self, frame_shape):
+        if self.origin is None:
+            self.origin = self.resolve_position(frame_shape)
+
+        self.initial_position = {
+            "x": self.origin[0],
+            "y": self.origin[1],
+        }
+
+        self.update_reference_points()
+        self.initialized = True
+
+    # ----------------------------
+    # MOVE / RESET
+    # ----------------------------
+    def move_to(self, x, y):
+        self.origin = (int(x), int(y))
+        self.update_reference_points()
+
+    def reset_position(self):
+        if self.initial_position:
+            self.origin = (
+                self.initial_position["x"],
+                self.initial_position["y"],
+            )
+            self.update_reference_points()
+
+    # ----------------------------
+    # INTERACTION HELPERS
+    # ----------------------------
+    def contains_point(self, point):
+        if not self.bounding_box:
+            return False
+
+        px, py = point
+        return (
+            self.bounding_box["x1"] <= px <= self.bounding_box["x2"]
+            and self.bounding_box["y1"] <= py <= self.bounding_box["y2"]
+        )
+
+    def set_hover(self, state: bool):
+        self.is_hovered = state
+
+    def set_selected(self, state: bool):
+        self.is_selected = state
+
+    # ----------------------------
+    # GETTERS
+    # ----------------------------
+    def get_position(self):
+        return self.position
+
+    def get_center(self):
+        return self.center_point
+
+    def get_bounds(self):
+        return self.bounding_box
+
+    def get_size(self):
+        return self.size
+
+    def get_id(self):
+        return self.id
+
+    # ----------------------------
+    # SERIALIZATION
+    # ----------------------------
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "kind": self.kind,
+            "origin": self.origin,
+            "placement": self.placement,
+            "size": self.size,
+            "color": self.color,
+            "label": self.label,
+            "initialized": self.initialized,
+        }
+
+    # optional reverse (useful for restoring state)
+    @staticmethod
+    def from_dict(data: dict):
+        obj = DrawingObject(
+            kind=data.get("kind", "circle"),
+            origin=data.get("origin"),
+            placement=data.get("placement", "top-left"),
+            size=tuple(data.get("size", (100, 100))),
+            color=tuple(data.get("color", (0, 255, 0))),
+            label=data.get("label"),
+        )
+        obj.initialized = data.get("initialized", False)
+        obj.update_reference_points()
+        return obj
+
+    # ----------------------------
+    # LAYOUT ENGINE
+    # ----------------------------
+    @staticmethod
+    def distribute_evenly(
+        drawings,
+        frame_shape,
+        row="top",
+        margin=20,
+        padding=10,
+    ):
+        frame_h, frame_w = frame_shape[:2]
+
+        count = len(drawings)
+        if count == 0:
+            return drawings  # IMPORTANT FIX
+
+        total_object_width = sum(d.size[0] for d in drawings)
+
+        available_width = frame_w - (margin * 2) - total_object_width
+
+        gap = max(padding, available_width // max(count - 1, 1))
+
+        current_x = margin
+
+        for drawing in drawings:
+            obj_w, obj_h = drawing.size
+
+            if row == "top":
+                y = margin
+            elif row == "center":
+                y = (frame_h - obj_h) // 2
+            elif row == "bottom":
+                y = frame_h - obj_h - margin
+            else:
+                y = margin
+
+            drawing.origin = (int(current_x), int(y))
+            drawing.initial_position = {"x": int(current_x), "y": int(y)}
+            drawing.update_reference_points()
+            drawing.initialized = True
+
+            current_x += obj_w + gap
+
+        return drawings
+
+    # ----------------------------
+    # DRAWING
+    # ----------------------------
+    def draw(self, frame):
+        if not self.initialized or self.origin is None:
+            self.initialize_position(frame.shape)
+
+        x, y = self.origin
+        w, h = self.size
+
+        frame_h, frame_w = frame.shape[:2]
+
+        # clamp inside frame
+        x = max(0, min(int(x), frame_w - w))
+        y = max(0, min(int(y), frame_h - h))
+
+        self.origin = (x, y)
+        self.update_reference_points()
+
+        # optional highlight when selected/hovered
+        stroke = self.thickness
+        if self.is_selected:
+            stroke = 3
+
+        if self.kind == "circle":
+            center = (x + w // 2, y + h // 2)
+            radius = min(w, h) // 2
+
+            cv2.circle(frame, center, radius, self.color, stroke)
+
+        elif self.kind == "square":
+            side = min(w, h)
+            cv2.rectangle(frame, (x, y), (x + side, y + side), self.color, stroke)
+
+        elif self.kind == "rectangle":
+            cv2.rectangle(frame, (x, y), (x + w, y + h), self.color, stroke)
+
+        elif self.kind == "triangle":
+            points = np.array(
+                [
+                    [x + w // 2, y],
+                    [x, y + h],
+                    [x + w, y + h],
+                ],
+                dtype=np.int32,
+            )
+
+            if stroke == -1:
+                cv2.fillPoly(frame, [points], self.color)
+            else:
+                cv2.polylines(frame, [points], True, self.color, stroke)
+
+        # label
+        if self.label:
+            cv2.putText(
+                frame,
+                self.label,
+                (x, y - 10),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.6,
+                self.color,
+                2,
+            )
+
+        return frame

openvisionkit/capture/image_template.py

@@ -0,0 +1,61 @@
+from collections.abc import Callable
+
+import cv2
+import numpy as np
+import pyautogui
+
+window_centered = False  # Used to center window only once
+
+
+def image_template(
+    image_path: str,
+    custom_logic: Callable[[cv2.typing.MatLike], cv2.typing.MatLike] | None = None,
+    window_name: str = "Demo",
+    center_window: bool = True,
+    show_window: bool = True,
+    resolution: tuple[int, int] = (1280, 720),
+):
+    """
+    REUSABLE TEMPLATE for displaying an image with optional custom processing.
+
+    Parameters:
+        image_path (str): Path to the image file.
+        custom_logic (callable, optional): Function that receives the image and returns the modified image.
+        window_name (str): Name of the OpenCV window.
+        center_window (bool): If True, automatically centers the window on screen. Default = True
+        show_window (bool): If True, displays the image window. Default = True
+        resolution (tuple[int, int]): Desired image resolution (width, height). Default = (1280, 720)
+    """
+
+    image = cv2.imread(image_path)
+    print(image_path)
+    if custom_logic is not None:
+        image = custom_logic(image)
+
+    if image is None:
+        raise ValueError("Image is None. Check file path or loading logic.")
+
+    if not isinstance(image, np.ndarray):
+        raise TypeError(f"Invalid image type: {type(image)}")
+
+    if image.size == 0:
+        raise ValueError("Empty image array")
+
+    # Resize image
+    hWIDTH, hHEIGHT = resolution
+    resized_img = cv2.resize(image, (hWIDTH, hHEIGHT))
+
+    # ======================
+    # NEW: Auto-center window on screen (only once)
+    # ======================
+    if center_window:
+        screen_width, screen_height = pyautogui.size()
+        x = int((screen_width - hWIDTH) / 2)
+        y = int((screen_height - hHEIGHT) / 2)
+        cv2.moveWindow(window_name, x, y)
+    # ======================
+
+    if show_window:
+        cv2.imshow(window_name, resized_img)
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()

openvisionkit/capture/screen_capture.py

@@ -0,0 +1,13 @@
+import cv2
+import mss
+import numpy as np
+
+
+class ScreenCapture:
+    def __init__(self, monitor_index=1):
+        self.sct = mss.mss()
+        self.monitor = self.sct.monitors[monitor_index]
+
+    def grab(self):
+        frame = np.array(self.sct.grab(self.monitor))
+        return cv2.cvtColor(frame, cv2.COLOR_BGRA2BGR)

openvisionkit/capture/video_recorder.py

@@ -0,0 +1,128 @@
+import os
+import time
+from dataclasses import dataclass
+from datetime import datetime
+
+import cv2
+import imageio
+
+
+@dataclass
+class VideoRecorder:
+    """
+    Advanced Video Recorder Engine:
+    - MP4 or GIF export
+    - Pause / Resume
+    - Timer tracking
+    - Multi-source ready (webcam + screen overlay)
+    - Plug & play with video_capture_template
+    """
+
+    output_path: str = "recordings"
+    fps: int = 20
+    codec: str = "mp4v"
+    output_format: str = "mp4"  # "mp4" or "gif"
+
+    def __post_init__(self):
+        os.makedirs(self.output_path, exist_ok=True)
+
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+        self.file_path = os.path.join(
+            self.output_path, f"record_{timestamp}.{self.output_format}"
+        )
+
+        # VideoWriter (MP4 mode)
+        self.writer = None
+
+        # GIF buffer mode
+        self.frames = []
+
+        self.is_recording = False
+        self.is_paused = False
+
+        self.start_time = None
+        self.elapsed_time = 0
+
+    # ----------------------------
+    # START RECORDING
+    # ----------------------------
+    def start(self, frame_shape=None):
+        self.is_recording = True
+        self.is_paused = False
+        self.start_time = time.time()
+
+        self.frames = []
+
+        if self.output_format == "mp4" and frame_shape is not None:
+            h, w = frame_shape[:2]
+            fourcc = cv2.VideoWriter_fourcc(*self.codec)
+            self.writer = cv2.VideoWriter(self.file_path, fourcc, self.fps, (w, h))
+
+        print(f"🔴 Recording started → {self.file_path}")
+
+    # ----------------------------
+    # WRITE FRAME
+    # ----------------------------
+    def write(self, frame):
+        if not self.is_recording or self.is_paused:
+            return
+
+        # -------------------------
+        # Convert BGR → RGB (IMPORTANT)
+        # -------------------------
+        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+        # MP4 mode
+        if self.output_format == "mp4" and self.writer:
+            self.writer.write(frame)  # MP4 expects BGR (OpenCV standard)
+
+        # GIF mode
+        elif self.output_format == "gif":
+            self.frames.append(rgb_frame)
+
+    # ----------------------------
+    # TIMER
+    # ----------------------------
+    def get_elapsed_time(self):
+        if self.start_time:
+            return round(time.time() - self.start_time, 2)
+        return 0
+
+    # ----------------------------
+    # PAUSE / RESUME
+    # ----------------------------
+    def pause(self):
+        self.is_paused = True
+        print("⏸ Recording paused")
+
+    def resume(self):
+        self.is_paused = False
+        print("▶ Recording resumed")
+
+    # ----------------------------
+    # STOP RECORDING
+    # ----------------------------
+    def stop(self):
+        self.is_recording = False
+
+        if self.writer:
+            self.writer.release()
+            print(f"✅ MP4 saved → {self.file_path}")
+
+        if self.output_format == "gif":
+            if not self.frames or len(self.frames) == 0:
+                print("⚠️ No frames recorded. Skipping GIF export.")
+                return
+            safe_fps = self.fps if self.fps and self.fps > 0 else 10
+            imageio.mimsave(self.file_path, self.frames, fps=safe_fps)
+            print(f"✅ GIF saved → {self.file_path}")
+
+    # ----------------------------
+    # AUDIO SYNC (HOOK)
+    # ----------------------------
+    def attach_audio(self, audio_path: str):
+        """
+        Placeholder for ffmpeg-based audio sync.
+        """
+        print(f"🎙 Audio sync not implemented yet: {audio_path}")