vidformer 0.11.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

vidformer/cv2/__init__.py

@@ -19,10 +19,10 @@ except Exception:
     _opencv2 = None
 
 import re
-import uuid
 import zlib
 from bisect import bisect_right
 from fractions import Fraction
+import os
 
 import numpy as np
 
@@ -80,21 +80,36 @@ _global_cv2_server = None
 def _server():
     global _global_cv2_server
     if _global_cv2_server is None:
-        _global_cv2_server = vf.YrdenServer()
+        if "VF_IGNI_ENDPOINT" in os.environ:
+            server_endpoint = os.environ["VF_IGNI_ENDPOINT"]
+            if "VF_IGNI_API_KEY" not in os.environ:
+                raise Exception("VF_IGNI_API_KEY must be set")
+            api_key = os.environ["VF_IGNI_API_KEY"]
+            _global_cv2_server = vf.Server(server_endpoint, api_key)
+        else:
+            raise Exception(
+                "No server set for the cv2 frontend. Set VF_IGNI_ENDPOINT and VF_IGNI_API_KEY environment variables or use cv2.set_server() before use."
+            )
     return _global_cv2_server
 
 
 def set_server(server):
     """Set the server to use for the cv2 frontend."""
     global _global_cv2_server
-    assert isinstance(server, vf.YrdenServer) or isinstance(server, vf.IgniServer)
+    assert isinstance(server, vf.Server)
     _global_cv2_server = server
 
 
+def get_server():
+    """Get the server used by the cv2 frontend."""
+    return _server()
+
+
 _PIX_FMT_MAP = {
     "rgb24": "rgb24",
     "yuv420p": "rgb24",
     "yuv422p": "rgb24",
+    "yuv422p10le": "rgb24",
     "yuv444p": "rgb24",
     "yuvj420p": "rgb24",
     "yuvj422p": "rgb24",
@@ -149,28 +164,16 @@ class Frame:
 
         self._mut()
         server = _server()
-        if type(server) is vf.YrdenServer:
-            spec = vf.YrdenSpec([Fraction(0, 1)], lambda t, i: self._f, self._fmt)
-            loader = spec.load(_server())
-
-            frame_raster_rgb24 = loader[0]
-            assert type(frame_raster_rgb24) is bytes
-            assert len(frame_raster_rgb24) == self.shape[0] * self.shape[1] * 3
-            raw_data_array = np.frombuffer(frame_raster_rgb24, dtype=np.uint8)
-            frame = raw_data_array.reshape(self.shape)
+        frame = server.frame(
+            self.shape[1], self.shape[0], self._fmt["pix_fmt"], self._f
+        )
+        assert type(frame) is bytes
+        assert len(frame) == self.shape[0] * self.shape[1] * self.shape[2]
+        raw_data_array = np.frombuffer(frame, dtype=np.uint8)
+        frame = raw_data_array.reshape(self.shape)
+        if self.shape[2] == 3:
             frame = frame[:, :, ::-1]  # convert RGB to BGR
-            return frame
-        else:
-            frame = server.frame(
-                self.shape[1], self.shape[0], self._fmt["pix_fmt"], self._f
-            )
-            assert type(frame) is bytes
-            assert len(frame) == self.shape[0] * self.shape[1] * self.shape[2]
-            raw_data_array = np.frombuffer(frame, dtype=np.uint8)
-            frame = raw_data_array.reshape(self.shape)
-            if self.shape[2] == 3:
-                frame = frame[:, :, ::-1]  # convert RGB to BGR
-            return frame
+        return frame
 
     def __getitem__(self, key):
         if not isinstance(key, tuple):
@@ -265,8 +268,12 @@ class Frame:
                 raise NotImplementedError("Only 1-channel mask frames are supported")
 
             # Value should be a bgr or bgra color
-            if type(value) is not list or len(value) not in [3, 4]:
-                raise NotImplementedError("Value should be a 3 or 4 element list")
+            if (type(value) is not list and type(value) is not tuple) or len(
+                value
+            ) not in [3, 4]:
+                raise NotImplementedError(
+                    "Value should be a 3 or 4 element list or tuple"
+                )
             value = [float(x) for x in value]
             if len(value) == 3:
                 value.append(255.0)
@@ -312,27 +319,19 @@ class VideoCapture:
     def __init__(self, path: str):
         server = _server()
         if type(path) is str:
-            if isinstance(server, vf.YrdenServer):
+            match = re.match(r"(http|https)://([^/]+)(.*)", path)
+            if match is not None:
+                endpoint = f"{match.group(1)}://{match.group(2)}"
+                path = match.group(3)
+                if path.startswith("/"):
+                    path = path[1:]
                 self._path = path
-                self._source = vf.YrdenSource(server, str(uuid.uuid4()), path, 0)
+                self._source = server.source(path, 0, "http", {"endpoint": endpoint})
             else:
-                assert isinstance(server, vf.IgniServer)
-                match = re.match(r"(http|https)://([^/]+)(.*)", path)
-                if match is not None:
-                    endpoint = f"{match.group(1)}://{match.group(2)}"
-                    path = match.group(3)
-                    if path.startswith("/"):
-                        path = path[1:]
-                    self._path = path
-                    self._source = server.source(
-                        path, 0, "http", {"endpoint": endpoint}
-                    )
-                else:
-                    raise Exception(
-                        "Using a VideoCapture source by name only works with http(s) URLs. You need to pass an IgniSource instead."
-                    )
-        elif isinstance(path, vf.IgniSource):
-            assert isinstance(server, vf.IgniServer)
+                self._path = path
+                self._source = server.source(path, 0, "fs", {"root": "."})
+        elif isinstance(path, vf.Source):
+            assert isinstance(server, vf.Server)
             self._path = path._name
             self._source = path
         self._next_frame_idx = 0
@@ -348,7 +347,7 @@ class VideoCapture:
         elif prop == CAP_PROP_FRAME_HEIGHT:
             return self._source.fmt()["height"]
         elif prop == CAP_PROP_FRAME_COUNT:
-            return len(self._source.ts())
+            return len(self._source)
         elif prop == CAP_PROP_POS_FRAMES:
             return self._next_frame_idx
 
@@ -374,31 +373,25 @@ class VideoCapture:
         frame = Frame(frame, self._source.fmt())
         return True, frame
 
+    def __getitem__(self, key):
+        if not isinstance(key, int):
+            raise NotImplementedError("Only integer indexing is supported")
+        if key < 0:
+            key = len(self._source) + key
+        if key < 0 or key >= len(self._source):
+            raise IndexError("Index out of bounds")
+        frame = self._source.iloc[key]
+        frame = Frame(frame, self._source.fmt())
+        return frame
+
+    def __len__(self):
+        return len(self._source)
+
     def release(self):
         pass
 
 
 class VideoWriter:
-    def __init__(self, *args, **kwargs):
-        server = _server()
-        if isinstance(server, vf.YrdenServer):
-            self._writer = _YrdenVideoWriter(*args, **kwargs)
-        elif isinstance(server, vf.IgniServer):
-            self._writer = _IgniVideoWriter(*args, **kwargs)
-        else:
-            raise Exception("Unsupported server type")
-
-    def write(self, *args, **kwargs):
-        return self._writer.write(*args, **kwargs)
-
-    def release(self, *args, **kwargs):
-        return self._writer.release(*args, **kwargs)
-
-    def spec(self, *args, **kwargs):
-        return self._writer.spec(*args, **kwargs)
-
-
-class _IgniVideoWriter:
     def __init__(
         self,
         path,
@@ -408,14 +401,13 @@ class _IgniVideoWriter:
         batch_size=1024,
         compression="gzip",
         ttl=3600,
+        pix_fmt="yuv420p",
         vod_segment_length=Fraction(2, 1),
     ):
         server = _server()
-        assert isinstance(server, vf.IgniServer)
-        if path is not None:
-            raise Exception(
-                "Igni does not support writing to a file. VideoWriter path must be None"
-            )
+        assert isinstance(server, vf.Server)
+        assert path is None or type(path) is str
+        self._path = path
         if isinstance(fps, int):
             self._f_time = Fraction(1, fps)
         elif isinstance(fps, Fraction):
@@ -425,10 +417,10 @@ class _IgniVideoWriter:
 
         assert isinstance(size, tuple) or isinstance(size, list)
         assert len(size) == 2
-        height, width = size
+        width, height = size
         assert ttl is None or isinstance(ttl, int)
         self._spec = server.create_spec(
-            width, height, "yuv420p", vod_segment_length, 1 / self._f_time, ttl=ttl
+            width, height, pix_fmt, vod_segment_length, 1 / self._f_time, ttl=ttl
         )
         self._batch_size = batch_size
         assert compression is None or compression in ["gzip"]
@@ -480,47 +472,9 @@ class _IgniVideoWriter:
 
     def release(self):
         self._flush(True)
-
-
-class _YrdenVideoWriter:
-    def __init__(self, path, fourcc, fps, size):
-        assert isinstance(fourcc, VideoWriter_fourcc)
-        if path is not None and not isinstance(path, str):
-            raise Exception("path must be a string or None")
-        self._path = path
-        self._fourcc = fourcc
-        self._fps = fps
-        self._size = size
-
-        self._frames = []
-        self._pix_fmt = "yuv420p"
-
-    def write(self, frame):
-        frame = frameify(frame, "frame")
-
-        if frame._fmt["pix_fmt"] != self._pix_fmt:
-            f_obj = _filter_scale(frame._f, pix_fmt=self._pix_fmt)
-            self._frames.append(f_obj)
-        else:
-            self._frames.append(frame._f)
-
-    def release(self):
-        if self._path is None:
-            return
-
-        spec = self.spec()
-        server = _server()
-        spec.save(server, self._path)
-
-    def spec(self) -> vf.YrdenSpec:
-        fmt = {
-            "width": self._size[1],
-            "height": self._size[0],
-            "pix_fmt": self._pix_fmt,
-        }
-        domain = _fps_to_ts(self._fps, len(self._frames))
-        spec = vf.YrdenSpec(domain, lambda t, i: self._frames[i], fmt)
-        return spec
+        if self._path is not None:
+            server = _server()
+            server.export_spec(self._spec.id(), self._path)
 
 
 class VideoWriter_fourcc:
@@ -552,82 +506,57 @@ def imread(path, *args):
     assert path.lower().endswith((".jpg", ".jpeg", ".png"))
     server = _server()
 
-    if type(server) is vf.YrdenServer:
-        source = vf.YrdenSource(server, str(uuid.uuid4()), path, 0)
-        frame = Frame(source.iloc[0], source.fmt())
-        return frame
-    else:
-        cap = VideoCapture(path)
-        assert cap.isOpened()
-        assert len(cap._source) == 1
-        ret, frame = cap.read()
-        assert ret
-        cap.release()
-        return frame
+    cap = VideoCapture(path)
+    assert cap.isOpened()
+    assert len(cap._source) == 1
+    ret, frame = cap.read()
+    assert ret
+    cap.release()
+    return frame
 
 
 def imwrite(path, img, *args):
     if len(args) > 0:
         raise NotImplementedError("imwrite does not support additional arguments")
 
-    server = _server()
-    if type(server) is vf.IgniServer:
-        raise NotImplementedError(
-            "imwrite is only supported with YrdenServer, not IgniServer"
-        )
-
     img = frameify(img)
-
     fmt = img._fmt.copy()
     width = fmt["width"]
     height = fmt["height"]
-    f = img._f
-
-    domain = [Fraction(0, 1)]
 
     if path.lower().endswith(".png"):
-        img._mut()  # Make sure it's in rgb24
-        spec = vf.YrdenSpec(
-            domain,
-            lambda t, i: img._f,
-            {"width": width, "height": height, "pix_fmt": "rgb24"},
-        )
-        spec.save(_server(), path, encoder="png")
+        out_pix_fmt = "rgb24"
+        encoder = "png"
     elif path.lower().endswith((".jpg", ".jpeg")):
-        if img._modified:
-            # it's rgb24, we need to convert to something jpeg can handle
-            f = _filter_scale(img._f, pix_fmt="yuv420p")
-            fmt["pix_fmt"] = "yuv420p"
+        encoder = "mjpeg"
+        if img._fmt["pix_fmt"] not in ["yuvj420p", "yuvj422p", "yuvj444p"]:
+            out_pix_fmt = "yuvj420p"
         else:
-            if fmt["pix_fmt"] not in ["yuvj420p", "yuvj422p", "yuvj444p"]:
-                f = _filter_scale(img._f, pix_fmt="yuvj420p")
-                fmt["pix_fmt"] = "yuvj420p"
-
-        spec = vf.YrdenSpec(domain, lambda t, i: f, fmt)
-        spec.save(server, path, encoder="mjpeg")
+            out_pix_fmt = img._fmt["pix_fmt"]
     else:
         raise Exception("Unsupported image format")
 
+    if img._fmt["pix_fmt"] != out_pix_fmt:
+        f = _filter_scale(img._f, pix_fmt=out_pix_fmt)
+        img = Frame(f, {"width": width, "height": height, "pix_fmt": out_pix_fmt})
+
+    writer = VideoWriter(None, None, 1, (width, height), pix_fmt=out_pix_fmt)
+    writer.write(img)
+    writer.release()
+
+    spec = writer.spec()
+    server = _server()
+    server.export_spec(spec.id(), path, encoder=encoder)
+
 
-def vidplay(video, *args, **kwargs):
+def vidplay(video, method=None):
     """
     Play a vidformer video specification.
-
-    Args:
-        video: one of [vidformer.Spec, vidformer.Source, vidformer.cv2.VideoWriter]
     """
-    if isinstance(video, vf.YrdenSpec):
-        return video.play(_server(), *args, **kwargs)
-    elif isinstance(video, vf.YrdenSource):
-        return video.play(_server(), *args, **kwargs)
-    elif isinstance(video, VideoWriter):
-        return vidplay(video._writer, *args, **kwargs)
-    elif isinstance(video, _YrdenVideoWriter):
-        return video.spec().play(_server(), *args, **kwargs)
-    elif isinstance(video, _IgniVideoWriter):
-        return video._spec.play(*args, **kwargs)
-    elif isinstance(video, vf.IgniSpec):
-        return video.play(*args, **kwargs)
+    if isinstance(video, VideoWriter):
+        return video.spec().play(method=method)
+    elif isinstance(video, vf.Spec):
+        return video.play(method=method)
     else:
         raise Exception("Unsupported video type to vidplay")
 
@@ -658,7 +587,7 @@ def resize(src, dsize):
 
     assert isinstance(dsize, tuple) or isinstance(dsize, list)
     assert len(dsize) == 2
-    height, width = dsize
+    width, height = dsize
 
     f = _filter_scale(src._f, width=width, height=height)
     fmt = {"width": width, "height": height, "pix_fmt": src._fmt["pix_fmt"]}

vidformer/supervision/__init__.py

@@ -14,6 +14,11 @@ from supervision.geometry.core import Position
 
 import vidformer.cv2 as vf_cv2
 
+try:
+    import cv2 as ocv_cv2
+except ImportError:
+    ocv_cv2 = None
+
 CV2_FONT = vf_cv2.FONT_HERSHEY_SIMPLEX
 
 
@@ -272,7 +277,6 @@ class DotAnnotator:
         outline_thickness: int = 0,
         outline_color=Color.BLACK,
     ):
-
         self.color = color
         self.radius: int = radius
         self.position: Position = position
@@ -537,3 +541,89 @@ class LabelAnnotator:
                     thickness=-1,
                 )
         return scene
+
+
+class MaskAnnotator:
+    def __init__(
+        self,
+        color=ColorPalette.DEFAULT,
+        opacity: float = 0.5,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+    ):
+        self.color = color
+        self.opacity = opacity
+        self.color_lookup: ColorLookup = color_lookup
+
+    def annotate(
+        self,
+        scene,
+        detections: Detections,
+        custom_color_lookup=None,
+    ):
+        if detections.mask is None:
+            return scene
+
+        colored_mask = scene.copy()
+
+        for detection_idx in np.flip(np.argsort(detections.box_area)):
+            color = resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=detection_idx,
+                color_lookup=(
+                    self.color_lookup
+                    if custom_color_lookup is None
+                    else custom_color_lookup
+                ),
+            )
+            mask = detections.mask[detection_idx]
+            colored_mask[mask] = color.as_bgr()
+
+        vf_cv2.addWeighted(
+            colored_mask, self.opacity, scene, 1 - self.opacity, 0, dst=scene
+        )
+        return scene
+
+
+class MaskStreamWriter:
+    def __init__(self, path: str, shape: tuple):
+        # Shape should be (width, height)
+        assert ocv_cv2 is not None, "OpenCV cv2 is required for ExternDetectionsBuilder"
+        assert type(shape) is tuple, "shape must be a tuple"
+        assert len(shape) == 2, "shape must be a tuple of length 2"
+        self._shape = (shape[1], shape[0])
+        self._writer = ocv_cv2.VideoWriter(
+            path, ocv_cv2.VideoWriter_fourcc(*"FFV1"), 1, shape, isColor=False
+        )
+        assert self._writer.isOpened(), f"Failed to open video writer at {path}"
+        self._i = 0
+
+    def write_detections(self, detections: Detections):
+        if len(detections) == 0:
+            return self._i
+
+        mask = detections.mask
+        assert (
+            mask.shape[1:] == self._shape
+        ), f"mask shape ({mask.shape[:1]}) must match the shape of the video ({self._shape})"
+        for i in range(mask.shape[0]):
+            frame_uint8 = detections.mask[i].astype(np.uint8)
+            self._writer.write(frame_uint8)
+            self._i += 1
+        return self._i
+
+    def release(self):
+        self._writer.release()
+
+
+def populate_mask(
+    detections: Detections, mask_stream: vf_cv2.VideoCapture, frame_idx: int
+):
+    assert type(detections) is Detections
+    assert detections.mask is None
+    detections.mask = []
+    assert len(detections) + frame_idx <= len(mask_stream)
+    for i in range(len(detections)):
+        mask = mask_stream[frame_idx + i]
+        assert mask.shape[2] == 1, "mask must be a single channel image"
+        detections.mask.append(mask)

{vidformer-0.11.0.dist-info → vidformer-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: vidformer
-Version: 0.11.0
+Version: 1.0.0
 Summary: vidformer-py is a Python 🐍 interface for [vidformer](https://github.com/ixlab/vidformer).
 Author-email: Dominik Winecki <dominikwinecki@gmail.com>
 Requires-Python: >=3.8
@@ -8,7 +8,6 @@ Description-Content-Type: text/markdown
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Dist: requests
-Requires-Dist: msgpack
 Requires-Dist: numpy
 Project-URL: Documentation, https://ixlab.github.io/vidformer/vidformer-py/
 Project-URL: Homepage, https://ixlab.github.io/vidformer/

vidformer-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+vidformer/__init__.py,sha256=kL_qU6iIV-XOrw4yk2SwCYA2YJIck3fS6Nqonnj55uA,29972
+vidformer/cv2/__init__.py,sha256=yBlWAQpbIbL4RgIDN6T_p-7JLERuKOs_m_8mqC55jak,26827
+vidformer/supervision/__init__.py,sha256=dRHAcHiZN68gUH_2m3o7Ohsv3NBGxF4XGPeI0pn2_K4,20346
+vidformer-1.0.0.dist-info/WHEEL,sha256=_2ozNFCLWc93bK4WKHCO-eDUENDlo-dgc9cU3qokYO4,82
+vidformer-1.0.0.dist-info/METADATA,sha256=zSQ1w9B6S4cToRYM3cpVQ3MG8dY7oop09YtS9aI-Z2E,1776
+vidformer-1.0.0.dist-info/RECORD,,

{vidformer-0.11.0.dist-info → vidformer-1.0.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: flit 3.10.1
+Generator: flit 3.11.0
 Root-Is-Purelib: true
 Tag: py3-none-any

vidformer-0.11.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-vidformer/__init__.py,sha256=lbbyaiV57QsaXmvHfrz_RXLaRnFMfm5ulK2dN701X-E,55465
-vidformer/cv2/__init__.py,sha256=9J_PV306rHYlf4FgBeQqJnlJJ6d2Mcb9s0TfiH8fASA,29528
-vidformer/supervision/__init__.py,sha256=KR-keBgDG29TSyIFU4Czgd8Yc5qckJKlSaMcPj_z-Zc,17490
-vidformer-0.11.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-vidformer-0.11.0.dist-info/METADATA,sha256=K3-g51c1iXRrkmqRwoYLUN8uJThtSCkjMs7kzr2SvNw,1800
-vidformer-0.11.0.dist-info/RECORD,,