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

vidformer/__init__.py

@@ -9,27 +9,28 @@ vidformer-py is a Python 🐍 interface for [vidformer](https://github.com/ixlab
 * [🧑‍💻 Source Code](https://github.com/ixlab/vidformer/tree/main/vidformer-py/)
 """
 
-__version__ = "0.10.0"
+__version__ = "0.11.0"
 
 
-import subprocess
-from fractions import Fraction
-import random
-import time
+import base64
+import gzip
 import json
-import socket
-import os
 import multiprocessing
-import uuid
-import threading
-import gzip
-import base64
+import os
+import random
 import re
+import socket
+import struct
+import subprocess
+import threading
+import time
+import uuid
+from fractions import Fraction
 from urllib.parse import urlparse
 
-import requests
 import msgpack
 import numpy as np
+import requests
 
 _in_notebook = False
 try:
@@ -182,6 +183,214 @@ def _play(namespace, hls_video_url, hls_js_url, method="html", status_url=None):
         raise ValueError("Invalid method")
 
 
+def _feb_expr_coded_as_scalar(expr) -> bool:
+    if type(expr) is tuple:
+        expr = list(expr)
+    if type(expr) is FilterExpr:
+        return False
+    if type(expr) is list:
+        if len(expr) > 3:
+            return False
+        else:
+            return all([type(x) is int and x >= -(2**15) and x < 2**15 for x in expr])
+    else:
+        assert type(expr) in [int, float, str, bytes, SourceExpr, bool, list]
+        return True
+
+
+class _FrameExpressionBlock:
+    def __init__(self):
+        self._functions = []
+        self._literals = []
+        self._sources = []
+        self._kwarg_keys = []
+        self._source_fracs = []
+        self._exprs = []
+        self._frame_exprs = []
+
+    def __len__(self):
+        return len(self._frame_exprs)
+
+    def insert_expr(self, expr):
+        if type(expr) is SourceExpr or type(expr) is FilterExpr:
+            return self.insert_frame_expr(expr)
+        else:
+            return self.insert_data_expr(expr)
+
+    def insert_data_expr(self, data):
+        if type(data) is tuple:
+            data = list(data)
+        if type(data) is bool:
+            self._exprs.append(0x01000000_00000000 | int(data))
+            return len(self._exprs) - 1
+        elif type(data) is int:
+            if data >= -(2**31) and data < 2**31:
+                self._exprs.append(data & 0xFFFFFFFF)
+            else:
+                self._literals.append(_json_arg(data, skip_data_anot=True))
+                self._exprs.append(0x40000000_00000000 | len(self._literals) - 1)
+            return len(self._exprs) - 1
+        elif type(data) is float:
+            self._exprs.append(
+                0x02000000_00000000 | int.from_bytes(struct.pack("f", data)[::-1])
+            )
+        elif type(data) is str:
+            self._literals.append(_json_arg(data, skip_data_anot=True))
+            self._exprs.append(0x40000000_00000000 | len(self._literals) - 1)
+        elif type(data) is bytes:
+            self._literals.append(_json_arg(data, skip_data_anot=True))
+            self._exprs.append(0x40000000_00000000 | len(self._literals) - 1)
+        elif type(data) is list:
+            if len(data) == 0:
+                self._exprs.append(0x03000000_00000000)
+                return len(self._exprs) - 1
+            if (
+                len(data) == 1
+                and type(data[0]) is int
+                and data[0] >= -(2**15)
+                and data[0] < 2**15
+            ):
+                self._exprs.append(0x04000000_00000000 | (data[0] & 0xFFFF))
+                return len(self._exprs) - 1
+            if (
+                len(data) == 2
+                and type(data[0]) is int
+                and data[0] >= -(2**15)
+                and data[0] < 2**15
+                and type(data[1]) is int
+                and data[1] >= -(2**15)
+                and data[1] < 2**15
+            ):
+                self._exprs.append(
+                    0x05000000_00000000
+                    | ((data[0] & 0xFFFF) << 16)
+                    | (data[1] & 0xFFFF)
+                )
+                return len(self._exprs) - 1
+            if (
+                len(data) == 3
+                and type(data[0]) is int
+                and data[0] >= -(2**15)
+                and data[0] < 2**15
+                and type(data[1]) is int
+                and data[1] >= -(2**15)
+                and data[1] < 2**15
+                and type(data[2]) is int
+                and data[2] >= -(2**15)
+                and data[2] < 2**15
+            ):
+                self._exprs.append(
+                    0x06000000_00000000
+                    | ((data[0] & 0xFFFF) << 32)
+                    | ((data[1] & 0xFFFF) << 16)
+                    | (data[2] & 0xFFFF)
+                )
+                return len(self._exprs) - 1
+            out = len(self._exprs)
+            member_idxs = []
+            for member in data:
+                if _feb_expr_coded_as_scalar(member):
+                    member_idxs.append(None)
+                else:
+                    member_idxs.append(self.insert_data_expr(member))
+
+            self._exprs.append(0x42000000_00000000 | len(data))
+
+            for i in range(len(data)):
+                if member_idxs[i] is None:
+                    self.insert_data_expr(data[i])
+                else:
+                    self._exprs.append(0x45000000_00000000 | member_idxs[i])
+
+            return out
+        else:
+            raise Exception("Invalid data type")
+
+    def insert_frame_expr(self, frame):
+        if type(frame) is SourceExpr:
+            source = frame._source._name
+            if source in self._sources:
+                source_idx = self._sources.index(source)
+            else:
+                source_idx = len(self._sources)
+                self._sources.append(source)
+            if frame._is_iloc:
+                self._exprs.append(
+                    0x43000000_00000000 | (source_idx << 32) | frame._idx
+                )
+            else:
+                idx = len(self._source_fracs) // 2
+                self._source_fracs.append(frame._idx.numerator)
+                self._source_fracs.append(frame._idx.denominator)
+                self._exprs.append(0x44000000_00000000 | (source_idx << 32) | idx)
+            return len(self._exprs) - 1
+        elif type(frame) is FilterExpr:
+            func = frame._filter._func
+            if func in self._functions:
+                func_idx = self._functions.index(func)
+            else:
+                func_idx = len(self._functions)
+                self._functions.append(func)
+            len_args = len(frame._args)
+            len_kwargs = len(frame._kwargs)
+
+            arg_idxs = []
+            for arg in frame._args:
+                if _feb_expr_coded_as_scalar(arg):
+                    arg_idxs.append(None)
+                else:
+                    arg_idxs.append(self.insert_expr(arg))
+            kwarg_idxs = {}
+            for k, v in frame._kwargs.items():
+                if _feb_expr_coded_as_scalar(v):
+                    kwarg_idxs[k] = None
+                else:
+                    kwarg_idxs[k] = self.insert_expr(v)
+
+            out_idx = len(self._exprs)
+            self._exprs.append(
+                0x41000000_00000000 | (len_args << 24) | (len_kwargs << 16) | func_idx
+            )
+            for i in range(len_args):
+                if arg_idxs[i] is None:
+                    # It's a scalar
+                    self.insert_expr(frame._args[i])
+                else:
+                    # It's an expression pointer
+                    self._exprs.append(0x45000000_00000000 | arg_idxs[i])
+            for k, v in frame._kwargs.items():
+                if k in self._kwarg_keys:
+                    k_idx = self._kwarg_keys.index(k)
+                else:
+                    k_idx = len(self._kwarg_keys)
+                    self._kwarg_keys.append(k)
+                self._exprs.append(0x46000000_00000000 | k_idx)
+                if kwarg_idxs[k] is None:
+                    # It's a scalar
+                    self.insert_expr(v)
+                else:
+                    # It's an expression pointer
+                    self._exprs.append(0x45000000_00000000 | kwarg_idxs[k])
+            return out_idx
+        else:
+            raise Exception("Invalid frame type")
+
+    def insert_frame(self, frame):
+        idx = self.insert_frame_expr(frame)
+        self._frame_exprs.append(idx)
+
+    def as_dict(self):
+        return {
+            "functions": self._functions,
+            "literals": self._literals,
+            "sources": self._sources,
+            "kwarg_keys": self._kwarg_keys,
+            "source_fracs": self._source_fracs,
+            "exprs": self._exprs,
+            "frame_exprs": self._frame_exprs,
+        }
+
+
 class IgniSource:
     def __init__(self, id: str, src):
         self._name = id
@@ -245,7 +454,9 @@ class IgniServer:
         self._endpoint = endpoint
 
         self._api_key = api_key
-        response = requests.get(
+        self._session = requests.Session()
+        self._session.headers.update({"Authorization": f"Bearer {self._api_key}"})
+        response = self._session.get(
             f"{self._endpoint}/auth",
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
@@ -256,7 +467,7 @@ class IgniServer:
 
     def get_source(self, id: str) -> IgniSource:
         assert type(id) is str
-        response = requests.get(
+        response = self._session.get(
             f"{self._endpoint}/source/{id}",
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
@@ -266,7 +477,7 @@ class IgniServer:
         return IgniSource(response["id"], response)
 
     def list_sources(self) -> list[str]:
-        response = requests.get(
+        response = self._session.get(
             f"{self._endpoint}/source",
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
@@ -277,7 +488,7 @@ class IgniServer:
 
     def delete_source(self, id: str):
         assert type(id) is str
-        response = requests.delete(
+        response = self._session.delete(
             f"{self._endpoint}/source/{id}",
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
@@ -302,7 +513,7 @@ class IgniServer:
             "storage_service": storage_service,
             "storage_config": storage_config,
         }
-        response = requests.post(
+        response = self._session.post(
             f"{self._endpoint}/source/search",
             json=req,
             headers={"Authorization": f"Bearer {self._api_key}"},
@@ -328,7 +539,7 @@ class IgniServer:
             "storage_service": storage_service,
             "storage_config": storage_config,
         }
-        response = requests.post(
+        response = self._session.post(
             f"{self._endpoint}/source",
             json=req,
             headers={"Authorization": f"Bearer {self._api_key}"},
@@ -354,7 +565,7 @@ class IgniServer:
 
     def get_spec(self, id: str) -> IgniSpec:
         assert type(id) is str
-        response = requests.get(
+        response = self._session.get(
             f"{self._endpoint}/spec/{id}",
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
@@ -364,7 +575,7 @@ class IgniServer:
         return IgniSpec(response["id"], response)
 
     def list_specs(self) -> list[str]:
-        response = requests.get(
+        response = self._session.get(
             f"{self._endpoint}/spec",
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
@@ -382,6 +593,7 @@ class IgniServer:
         frame_rate,
         ready_hook=None,
         steer_hook=None,
+        ttl=None,
     ) -> IgniSpec:
         assert type(width) is int
         assert type(height) is int
@@ -390,6 +602,7 @@ class IgniServer:
         assert type(frame_rate) is Fraction
         assert type(ready_hook) is str or ready_hook is None
         assert type(steer_hook) is str or steer_hook is None
+        assert ttl is None or type(ttl) is int
 
         req = {
             "width": width,
@@ -402,8 +615,9 @@ class IgniServer:
             "frame_rate": [frame_rate.numerator, frame_rate.denominator],
             "ready_hook": ready_hook,
             "steer_hook": steer_hook,
+            "ttl": ttl,
         }
-        response = requests.post(
+        response = self._session.post(
             f"{self._endpoint}/spec",
             json=req,
             headers={"Authorization": f"Bearer {self._api_key}"},
@@ -416,7 +630,7 @@ class IgniServer:
 
     def delete_spec(self, id: str):
         assert type(id) is str
-        response = requests.delete(
+        response = self._session.delete(
             f"{self._endpoint}/spec/{id}",
             headers={"Authorization": f"Bearer {self._api_key}"},
         )
@@ -453,7 +667,7 @@ class IgniServer:
             "frames": req_frames,
             "terminal": terminal,
         }
-        response = requests.post(
+        response = self._session.post(
             f"{self._endpoint}/spec/{spec_id}/part",
             json=req,
             headers={"Authorization": f"Bearer {self._api_key}"},
@@ -463,6 +677,84 @@ class IgniServer:
         response = response.json()
         assert response["status"] == "ok"
 
+    def push_spec_part_block(
+        self, spec_id: str, pos, blocks, terminal, compression="gzip"
+    ):
+        if type(spec_id) is IgniSpec:
+            spec_id = spec_id._id
+        assert type(spec_id) is str
+        assert type(pos) is int
+        assert type(blocks) is list
+        assert type(terminal) is bool
+        assert compression is None or compression == "gzip"
+
+        req_blocks = []
+        for block in blocks:
+            assert type(block) is _FrameExpressionBlock
+            block_body = block.as_dict()
+            block_frames = len(block_body["frame_exprs"])
+            block_body = json.dumps(block_body).encode("utf-8")
+            if compression == "gzip":
+                block_body = gzip.compress(block_body, 1)
+            block_body = base64.b64encode(block_body).decode("utf-8")
+            req_blocks.append(
+                {
+                    "frames": block_frames,
+                    "compression": compression,
+                    "body": block_body,
+                }
+            )
+
+        req = {
+            "pos": pos,
+            "terminal": terminal,
+            "blocks": req_blocks,
+        }
+        response = self._session.post(
+            f"{self._endpoint}/spec/{spec_id}/part_block",
+            json=req,
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        if not response.ok:
+            raise Exception(response.text)
+        response = response.json()
+        assert response["status"] == "ok"
+
+    def frame(self, width, height, pix_fmt, frame_expr, compression="gzip"):
+        assert type(frame_expr) is FilterExpr or type(frame_expr) is SourceExpr
+        assert compression is None or compression in ["gzip"]
+        feb = _FrameExpressionBlock()
+        feb.insert_frame(frame_expr)
+        feb_body = feb.as_dict()
+
+        feb_body = json.dumps(feb_body).encode("utf-8")
+        if compression == "gzip":
+            feb_body = gzip.compress(feb_body, 1)
+        feb_body = base64.b64encode(feb_body).decode("utf-8")
+        req = {
+            "width": width,
+            "height": height,
+            "pix_fmt": pix_fmt,
+            "compression": compression,
+            "block": {
+                "frames": 1,
+                "compression": compression,
+                "body": feb_body,
+            },
+        }
+        response = self._session.post(
+            f"{self._endpoint}/frame",
+            json=req,
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        if not response.ok:
+            raise Exception(response.text)
+        response_body = response.content
+        assert type(response_body) is bytes
+        if compression == "gzip":
+            response_body = gzip.decompress(response_body)
+        return response_body
+
 
 class YrdenSpec:
     """
@@ -543,12 +835,11 @@ class YrdenSpec:
             }
             for k, v in filters.items()
         }
-        arrays = []
 
         if verbose:
             print(f"Sending to server. Spec is {len(spec_obj_json_gzip_b64)} bytes")
 
-        resp = server._new(spec_obj_json_gzip_b64, sources, filters, arrays, self._fmt)
+        resp = server._new(spec_obj_json_gzip_b64, sources, filters, self._fmt)
         hls_video_url = resp["stream_url"]
         hls_player_url = resp["player_url"]
         namespace = resp["namespace"]
@@ -616,9 +907,7 @@ class YrdenSpec:
             }
             for k, v in filters.items()
         }
-        arrays = []
-
-        resp = server._new(spec_obj_json_gzip_b64, sources, filters, arrays, self._fmt)
+        resp = server._new(spec_obj_json_gzip_b64, sources, filters, self._fmt)
         namespace = resp["namespace"]
         return YrdenLoader(server, namespace, self._domain)
 
@@ -652,14 +941,12 @@ class YrdenSpec:
             }
             for k, v in filters.items()
         }
-        arrays = []
 
         resp = server._export(
             pth,
             spec_obj_json_gzip_b64,
             sources,
             filters,
-            arrays,
             self._fmt,
             encoder,
             encoder_opts,
@@ -692,12 +979,11 @@ class YrdenSpec:
             }
             for k, v in filters.items()
         }
-        arrays = []
         end_t = time.time()
         out["vrod_create_spec"] = end_t - start_t
 
         start = time.time()
-        resp = server._new(pth, sources, filters, arrays, self._fmt)
+        resp = server._new(pth, sources, filters, self._fmt)
         end = time.time()
         out["vrod_register"] = end - start
 
@@ -735,12 +1021,11 @@ class YrdenSpec:
             }
             for k, v in filters.items()
         }
-        arrays = []
         end_t = time.time()
         out["dve2_create_spec"] = end_t - start_t
 
         start = time.time()
-        resp = server._export(pth, sources, filters, arrays, self._fmt, None, None)
+        resp = server._export(pth, sources, filters, self._fmt, None, None)
         resp.raise_for_status()
         end = time.time()
         out["dve2_exec"] = end - start
@@ -861,12 +1146,11 @@ class YrdenServer:
         resp["ts"] = [Fraction(x[0], x[1]) for x in resp["ts"]]
         return resp
 
-    def _new(self, spec, sources, filters, arrays, fmt):
+    def _new(self, spec, sources, filters, fmt):
         req = {
             "spec": spec,
             "sources": sources,
             "filters": filters,
-            "arrays": arrays,
             "width": fmt["width"],
             "height": fmt["height"],
             "pix_fmt": fmt["pix_fmt"],
@@ -878,14 +1162,11 @@ class YrdenServer:
 
         return r.json()
 
-    def _export(
-        self, pth, spec, sources, filters, arrays, fmt, encoder, encoder_opts, format
-    ):
+    def _export(self, pth, spec, sources, filters, fmt, encoder, encoder_opts, format):
         req = {
             "spec": spec,
             "sources": sources,
             "filters": filters,
-            "arrays": arrays,
             "width": fmt["width"],
             "height": fmt["height"],
             "pix_fmt": fmt["pix_fmt"],

vidformer/cv2/__init__.py

@@ -18,13 +18,13 @@ try:
 except Exception:
     _opencv2 = None
 
-import numpy as np
-
+import re
 import uuid
-from fractions import Fraction
-from bisect import bisect_right
 import zlib
-import re
+from bisect import bisect_right
+from fractions import Fraction
+
+import numpy as np
 
 CAP_PROP_POS_MSEC = 0
 CAP_PROP_POS_FRAMES = 1
@@ -51,6 +51,7 @@ LINE_AA = 16
 _inline_mat = vf.Filter("_inline_mat")
 _slice_mat = vf.Filter("_slice_mat")
 _slice_write_mat = vf.Filter("_slice_write_mat")
+_black = vf.Filter("_black")
 
 
 _filter_scale = vf.Filter("Scale")
@@ -61,6 +62,7 @@ _filter_line = vf.Filter("cv2.line")
 _filter_circle = vf.Filter("cv2.circle")
 _filter_addWeighted = vf.Filter("cv2.addWeighted")
 _filter_ellipse = vf.Filter("cv2.ellipse")
+_set_to = vf.Filter("cv2.setTo")
 
 
 def _ts_to_fps(timestamps):
@@ -89,11 +91,30 @@ def set_server(server):
     _global_cv2_server = server
 
 
+_PIX_FMT_MAP = {
+    "rgb24": "rgb24",
+    "yuv420p": "rgb24",
+    "yuv422p": "rgb24",
+    "yuv444p": "rgb24",
+    "yuvj420p": "rgb24",
+    "yuvj422p": "rgb24",
+    "yuvj444p": "rgb24",
+    "gray": "gray",
+}
+
+
+def _top_level_pix_fmt(pix_fmt):
+    if pix_fmt in _PIX_FMT_MAP:
+        return _PIX_FMT_MAP[pix_fmt]
+    raise Exception(f"Unsupported pix_fmt {pix_fmt}")
+
+
 class Frame:
     def __init__(self, f, fmt):
         self._f = f
         self._fmt = fmt
-        self.shape = (fmt["height"], fmt["width"], 3)
+        channels = 3 if _top_level_pix_fmt(fmt["pix_fmt"]) == "rgb24" else 1
+        self.shape = (fmt["height"], fmt["width"], channels)
 
         # denotes that the frame has not yet been modified
         # when a frame is modified, it is converted to rgb24 first
@@ -101,13 +122,22 @@ class Frame:
 
     def _mut(self):
         if self._modified:
-            assert self._fmt["pix_fmt"] == "rgb24"
+            assert self._fmt["pix_fmt"] in ["rgb24", "gray"]
             return
 
         self._modified = True
-        if self._fmt["pix_fmt"] != "rgb24":
+        if (
+            self._fmt["pix_fmt"] != "rgb24"
+            and _top_level_pix_fmt(self._fmt["pix_fmt"]) == "rgb24"
+        ):
             self._f = _filter_scale(self._f, pix_fmt="rgb24")
             self._fmt["pix_fmt"] = "rgb24"
+        elif (
+            self._fmt["pix_fmt"] != "gray"
+            and _top_level_pix_fmt(self._fmt["pix_fmt"]) == "gray"
+        ):
+            self._f = _filter_scale(self._f, pix_fmt="gray")
+            self._fmt["pix_fmt"] = "gray"
 
     def copy(self):
         return Frame(self._f, self._fmt.copy())
@@ -118,16 +148,29 @@ class Frame:
         """
 
         self._mut()
-        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 = frame[:, :, ::-1]  # convert RGB to BGR
-        return frame
+        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 = 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
 
     def __getitem__(self, key):
         if not isinstance(key, tuple):
@@ -171,49 +214,71 @@ class Frame:
         return Frame(f, fmt)
 
     def __setitem__(self, key, value):
-        value = frameify(value, "value")
-
-        if not isinstance(key, tuple):
-            raise NotImplementedError("Only 2D slicing is supported")
-
-        if len(key) != 2:
-            raise NotImplementedError("Only 2D slicing is supported")
-
-        if not all(isinstance(x, slice) for x in key):
-            raise NotImplementedError("Only 2D slicing is supported")
-
-        miny = key[0].start if key[0].start is not None else 0
-        maxy = key[0].stop if key[0].stop is not None else self.shape[0]
-        minx = key[1].start if key[1].start is not None else 0
-        maxx = key[1].stop if key[1].stop is not None else self.shape[1]
-
-        # handle negative indices
-        if miny < 0:
-            miny = self.shape[0] + miny
-        if maxy < 0:
-            maxy = self.shape[0] + maxy
-        if minx < 0:
-            minx = self.shape[1] + minx
-        if maxx < 0:
-            maxx = self.shape[1] + maxx
-
-        if (
-            maxy <= miny
-            or maxx <= minx
-            or miny < 0
-            or minx < 0
-            or maxy > self.shape[0]
-            or maxx > self.shape[1]
-        ):
-            raise NotImplementedError("Invalid slice")
-
-        if value.shape[0] != maxy - miny or value.shape[1] != maxx - minx:
-            raise NotImplementedError("Shape mismatch")
-
-        self._mut()
-        value._mut()
-
-        self._f = _slice_write_mat(self._f, value._f, miny, maxy, minx, maxx)
+        if type(key) is tuple:
+            value = frameify(value, "value")
+
+            if len(key) != 2:
+                raise NotImplementedError("Only 2D slicing is supported")
+
+            if not all(isinstance(x, slice) for x in key):
+                raise NotImplementedError("Only 2D slicing is supported")
+
+            miny = key[0].start if key[0].start is not None else 0
+            maxy = key[0].stop if key[0].stop is not None else self.shape[0]
+            minx = key[1].start if key[1].start is not None else 0
+            maxx = key[1].stop if key[1].stop is not None else self.shape[1]
+
+            # handle negative indices
+            if miny < 0:
+                miny = self.shape[0] + miny
+            if maxy < 0:
+                maxy = self.shape[0] + maxy
+            if minx < 0:
+                minx = self.shape[1] + minx
+            if maxx < 0:
+                maxx = self.shape[1] + maxx
+
+            if (
+                maxy <= miny
+                or maxx <= minx
+                or miny < 0
+                or minx < 0
+                or maxy > self.shape[0]
+                or maxx > self.shape[1]
+            ):
+                raise NotImplementedError("Invalid slice")
+
+            if value.shape[0] != maxy - miny or value.shape[1] != maxx - minx:
+                raise NotImplementedError("Shape mismatch")
+
+            self._mut()
+            value._mut()
+
+            self._f = _slice_write_mat(self._f, value._f, miny, maxy, minx, maxx)
+        elif type(key) is Frame or type(key) is np.ndarray:
+            key = frameify(key, "key")
+
+            if key.shape[0] != self.shape[0] or key.shape[1] != self.shape[1]:
+                raise NotImplementedError("Shape mismatch")
+
+            if key.shape[2] != 1:
+                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")
+            value = [float(x) for x in value]
+            if len(value) == 3:
+                value.append(255.0)
+
+            self._mut()
+            key._mut()
+
+            self._f = _set_to(self._f, value, key._f)
+        else:
+            raise NotImplementedError(
+                "__setitem__ only supports slicing by a 2d tuple or a mask frame"
+            )
 
 
 def _inline_frame(arr):
@@ -341,6 +406,8 @@ class _IgniVideoWriter:
         fps,
         size,
         batch_size=1024,
+        compression="gzip",
+        ttl=3600,
         vod_segment_length=Fraction(2, 1),
     ):
         server = _server()
@@ -358,27 +425,35 @@ class _IgniVideoWriter:
 
         assert isinstance(size, tuple) or isinstance(size, list)
         assert len(size) == 2
-        width, height = size
+        height, width = size
+        assert ttl is None or isinstance(ttl, int)
         self._spec = server.create_spec(
-            width, height, "yuv420p", vod_segment_length, 1 / self._f_time
+            width, height, "yuv420p", vod_segment_length, 1 / self._f_time, ttl=ttl
         )
         self._batch_size = batch_size
+        assert compression is None or compression in ["gzip"]
+        self._compression = compression
         self._idx = 0
-        self._frame_buffer = []
+        self._feb = vf._FrameExpressionBlock()
 
     def _flush(self, terminal=False):
         server = _server()
-        server.push_spec_part(
-            self._spec,
-            self._idx - len(self._frame_buffer),
-            self._frame_buffer,
-            terminal=terminal,
-        )
-        self._frame_buffer = []
-
-    def _explicit_terminate(self):
-        server = _server()
-        server.push_spec_part(self._spec._id, self._idx, [], terminal=True)
+        if len(self._feb) > 0:
+            server.push_spec_part_block(
+                self._spec,
+                self._idx - len(self._feb),
+                [self._feb],
+                terminal=terminal,
+                compression=self._compression,
+            )
+            self._feb = vf._FrameExpressionBlock()
+        else:
+            server.push_spec_part_block(
+                self._spec,
+                self._idx - len(self._feb),
+                [],
+                terminal=terminal,
+            )
 
     def spec(self):
         return self._spec
@@ -397,18 +472,14 @@ class _IgniVideoWriter:
             if frame._fmt["pix_fmt"] != self._spec._fmt["pix_fmt"]:
                 f_obj = _filter_scale(frame._f, pix_fmt=self._spec._fmt["pix_fmt"])
                 frame = Frame(f_obj, self._spec._fmt)
-        t = self._f_time * self._idx
-        self._frame_buffer.append((t, frame._f if frame is not None else None))
+        self._feb.insert_frame(frame._f if frame is not None else None)
         self._idx += 1
 
-        if len(self._frame_buffer) >= self._batch_size:
+        if len(self._feb) >= self._batch_size:
             self._flush()
 
     def release(self):
-        if len(self._frame_buffer) > 0:
-            self._flush(True)
-        else:
-            self._explicit_terminate()
+        self._flush(True)
 
 
 class _YrdenVideoWriter:
@@ -443,8 +514,8 @@ class _YrdenVideoWriter:
 
     def spec(self) -> vf.YrdenSpec:
         fmt = {
-            "width": self._size[0],
-            "height": self._size[1],
+            "width": self._size[1],
+            "height": self._size[0],
             "pix_fmt": self._pix_fmt,
         }
         domain = _fps_to_ts(self._fps, len(self._frames))
@@ -478,18 +549,33 @@ def frameify(obj, field_name=None):
 def imread(path, *args):
     if len(args) > 0:
         raise NotImplementedError("imread does not support additional arguments")
-
     assert path.lower().endswith((".jpg", ".jpeg", ".png"))
     server = _server()
-    source = vf.YrdenSource(server, str(uuid.uuid4()), path, 0)
-    frame = Frame(source.iloc[0], source.fmt())
-    return frame
+
+    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
 
 
 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()
@@ -518,7 +604,7 @@ def imwrite(path, img, *args):
                 fmt["pix_fmt"] = "yuvj420p"
 
         spec = vf.YrdenSpec(domain, lambda t, i: f, fmt)
-        spec.save(_server(), path, encoder="mjpeg")
+        spec.save(server, path, encoder="mjpeg")
     else:
         raise Exception("Unsupported image format")
 
@@ -546,6 +632,39 @@ def vidplay(video, *args, **kwargs):
         raise Exception("Unsupported video type to vidplay")
 
 
+def zeros(shape, dtype=np.uint8):
+    """
+    Create a black frame. Mimics numpy.zeros.
+    """
+    assert isinstance(shape, tuple) or isinstance(shape, list)
+    assert len(shape) == 3
+    assert shape[2] in [1, 3]
+    assert dtype == np.uint8
+
+    height, width, channels = shape
+    if channels == 1:
+        pix_fmt = "gray"
+    else:
+        pix_fmt = "rgb24"
+
+    f = _black(width=width, height=height, pix_fmt=pix_fmt)
+    fmt = {"width": width, "height": height, "pix_fmt": pix_fmt}
+    return Frame(f, fmt)
+
+
+def resize(src, dsize):
+    src = frameify(src)
+    src._mut()
+
+    assert isinstance(dsize, tuple) or isinstance(dsize, list)
+    assert len(dsize) == 2
+    height, width = dsize
+
+    f = _filter_scale(src._f, width=width, height=height)
+    fmt = {"width": width, "height": height, "pix_fmt": src._fmt["pix_fmt"]}
+    return Frame(f, fmt)
+
+
 def rectangle(img, pt1, pt2, color, thickness=None, lineType=None, shift=None):
     """
     cv.rectangle(	img, pt1, pt2, color[, thickness[, lineType[, shift]]]	)

vidformer/supervision/__init__.py

@@ -2,17 +2,18 @@
 vidformer.supervision is the [supervision](https://supervision.roboflow.com/) frontend for [vidformer](https://github.com/ixlab/vidformer).
 """
 
-import vidformer.cv2 as vf_cv2
+from math import sqrt
 
-import supervision as _sv
 import numpy as np
-from supervision import Color, ColorPalette, ColorLookup, Detections
+import supervision as _sv
+from supervision import Color, ColorLookup, ColorPalette, Detections
 from supervision.annotators.utils import resolve_color, resolve_text_background_xyxy
-from supervision.detection.utils import spread_out_boxes
 from supervision.config import CLASS_NAME_DATA_FIELD
-from math import sqrt
+from supervision.detection.utils import spread_out_boxes
 from supervision.geometry.core import Position
 
+import vidformer.cv2 as vf_cv2
+
 CV2_FONT = vf_cv2.FONT_HERSHEY_SIMPLEX
 
 
@@ -499,31 +500,40 @@ class LabelAnnotator:
 
         border_radius = min(border_radius, min(width, height) // 2)
 
-        rectangle_coordinates = [
-            ((x1 + border_radius, y1), (x2 - border_radius, y2)),
-            ((x1, y1 + border_radius), (x2, y2 - border_radius)),
-        ]
-        circle_centers = [
-            (x1 + border_radius, y1 + border_radius),
-            (x2 - border_radius, y1 + border_radius),
-            (x1 + border_radius, y2 - border_radius),
-            (x2 - border_radius, y2 - border_radius),
-        ]
-
-        for coordinates in rectangle_coordinates:
+        if border_radius <= 0:
             vf_cv2.rectangle(
                 img=scene,
-                pt1=coordinates[0],
-                pt2=coordinates[1],
-                color=color,
-                thickness=-1,
-            )
-        for center in circle_centers:
-            vf_cv2.circle(
-                img=scene,
-                center=center,
-                radius=border_radius,
+                pt1=(x1, y1),
+                pt2=(x2, y2),
                 color=color,
                 thickness=-1,
             )
+        else:
+            rectangle_coordinates = [
+                ((x1 + border_radius, y1), (x2 - border_radius, y2)),
+                ((x1, y1 + border_radius), (x2, y2 - border_radius)),
+            ]
+            circle_centers = [
+                (x1 + border_radius, y1 + border_radius),
+                (x2 - border_radius, y1 + border_radius),
+                (x1 + border_radius, y2 - border_radius),
+                (x2 - border_radius, y2 - border_radius),
+            ]
+
+            for coordinates in rectangle_coordinates:
+                vf_cv2.rectangle(
+                    img=scene,
+                    pt1=coordinates[0],
+                    pt2=coordinates[1],
+                    color=color,
+                    thickness=-1,
+                )
+            for center in circle_centers:
+                vf_cv2.circle(
+                    img=scene,
+                    center=center,
+                    radius=border_radius,
+                    color=color,
+                    thickness=-1,
+                )
         return scene

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: vidformer
-Version: 0.10.0
+Version: 0.11.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

vidformer-0.11.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+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,,

vidformer-0.10.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-vidformer/__init__.py,sha256=qpWcttHsW1wnaGx5__qJqaT-m5VF7yMiHCxdm10Fjek,44916
-vidformer/cv2/__init__.py,sha256=DGm5NB4FGCHxPVez-yO748DjocKruxn4QBqqThgskWI,25555
-vidformer/supervision/__init__.py,sha256=T2QJ3gKtUSoKOlxAf06TG4fD9IgIDuBpiVOBKVk3qAw,17150
-vidformer-0.10.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-vidformer-0.10.0.dist-info/METADATA,sha256=f_aUIFbQUoVJuYTKtqexwyN5uzWRoS2Fvd2dHZ_EGbo,1800
-vidformer-0.10.0.dist-info/RECORD,,