vidformer 0.5.3__py3-none-any.whl → 0.6.0__py3-none-any.whl

vidformer/__init__.py

@@ -0,0 +1,5 @@
+"""A Python library for creating and viewing videos with vidformer."""
+
+__version__ = "0.6.0"
+
+from .vf import *

vidformer/cv2/__init__.py

@@ -0,0 +1 @@
+from .vf_cv2 import *

vidformer/cv2/vf_cv2.py

@@ -0,0 +1,236 @@
+from .. import vf
+
+import uuid
+from fractions import Fraction
+from bisect import bisect_right
+
+CAP_PROP_POS_MSEC = 0
+CAP_PROP_POS_FRAMES = 1
+CAP_PROP_FRAME_WIDTH = 3
+CAP_PROP_FRAME_HEIGHT = 4
+CAP_PROP_FPS = 5
+
+FONT_HERSHEY_SIMPLEX = 0
+FONT_HERSHEY_PLAIN = 1
+FONT_HERSHEY_DUPLEX = 2
+FONT_HERSHEY_COMPLEX = 3
+FONT_HERSHEY_TRIPLEX = 4
+FONT_HERSHEY_COMPLEX_SMALL = 5
+FONT_HERSHEY_SCRIPT_SIMPLEX = 6
+FONT_HERSHEY_SCRIPT_COMPLEX = 7
+FONT_ITALIC = 16
+
+FILLED = -1
+LINE_4 = 4
+LINE_8 = 8
+LINE_AA = 16
+
+_filter_scale = vf.Filter("Scale")
+_filter_rectangle = vf.Filter("cv2.rectangle")
+_filter_putText = vf.Filter("cv2.putText")
+
+
+def _ts_to_fps(timestamps):
+    return int(1 / (timestamps[1] - timestamps[0]))  # TODO: Fix for non-integer fps
+
+
+def _fps_to_ts(fps, n_frames):
+    assert type(fps) == int
+    return [Fraction(i, fps) for i in range(n_frames)]
+
+
+_global_cv2_server = None
+
+
+def _server():
+    global _global_cv2_server
+    if _global_cv2_server is None:
+        _global_cv2_server = vf.YrdenServer()
+    return _global_cv2_server
+
+
+def set_cv2_server(server):
+    """Set the server to use for the cv2 frontend."""
+    global _global_cv2_server
+    assert isinstance(server, vf.YrdenServer)
+    _global_cv2_server = server
+
+
+class _Frame:
+    def __init__(self, f):
+        self._f = f
+
+        # denotes that the frame has not yet been modified
+        # when a frame is modified, it is converted to rgb24 first
+        self._modified = False
+
+    def _mut(self):
+        self._modified = True
+        self._f = _filter_scale(self._f, pix_fmt="rgb24")
+
+
+class VideoCapture:
+    def __init__(self, path):
+        self._path = path
+        server = _server()
+        self._source = vf.Source(server, str(uuid.uuid4()), path, 0)
+        self._next_frame_idx = 0
+
+    def isOpened(self):
+        return True
+
+    def get(self, prop):
+        if prop == CAP_PROP_FPS:
+            return _ts_to_fps(self._source.ts())
+        elif prop == CAP_PROP_FRAME_WIDTH:
+            return self._source.fmt()["width"]
+        elif prop == CAP_PROP_FRAME_HEIGHT:
+            return self._source.fmt()["height"]
+
+        raise Exception(f"Unknown property {prop}")
+
+    def set(self, prop, value):
+        if prop == CAP_PROP_POS_FRAMES:
+            assert value >= 0 and value < len(self._source.ts())
+            self._next_frame_idx = value
+        elif prop == CAP_PROP_POS_MSEC:
+            t = Fraction(value, 1000)
+            ts = self._source.ts()
+            next_frame_idx = bisect_right(ts, t)
+            self._next_frame_idx = next_frame_idx
+        else:
+            raise Exception(f"Unsupported property {prop}")
+
+    def read(self):
+        if self._next_frame_idx >= len(self._source.ts()):
+            return False, None
+        frame = self._source.iloc[self._next_frame_idx]
+        self._next_frame_idx += 1
+        frame = _Frame(frame)
+        return True, frame
+
+    def release(self):
+        pass
+
+
+class VideoWriter:
+    def __init__(self, path, fourcc, fps, size):
+        assert isinstance(fourcc, VideoWriter_fourcc)
+        self._path = path
+        self._fourcc = fourcc
+        self._fps = fps
+        self._size = size
+
+        self._frames = []
+        self._pix_fmt = "yuv420p"
+
+    def write(self, frame):
+        if not isinstance(frame, _Frame):
+            raise Exception("frame must be a _Frame object")
+        if frame._modified:
+            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):
+        spec = self.vf_spec()
+        server = _server()
+        spec.save(server, self._path)
+
+    def vf_spec(self):
+        fmt = {
+            "width": self._size[0],
+            "height": self._size[1],
+            "pix_fmt": self._pix_fmt,
+        }
+        domain = _fps_to_ts(self._fps, len(self._frames))
+        spec = vf.Spec(domain, lambda t, i: self._frames[i], fmt)
+        return spec
+
+
+class VideoWriter_fourcc:
+    def __init__(self, *args):
+        self._args = args
+
+
+def rectangle(img, pt1, pt2, color, thickness=None, lineType=None, shift=None):
+    """
+    cv.rectangle(	img, pt1, pt2, color[, thickness[, lineType[, shift]]]	)
+    """
+
+    assert isinstance(img, _Frame)
+    img._mut()
+
+    assert len(pt1) == 2
+    assert len(pt2) == 2
+    assert all(isinstance(x, int) for x in pt1)
+    assert all(isinstance(x, int) for x in pt2)
+
+    assert len(color) == 3 or len(color) == 4
+    color = [float(x) for x in color]
+    if len(color) == 3:
+        color.append(255.0)
+
+    args = []
+    if thickness is not None:
+        assert isinstance(thickness, int)
+        args.append(thickness)
+    if lineType is not None:
+        assert isinstance(lineType, int)
+        assert thickness is not None
+        args.append(lineType)
+    if shift is not None:
+        assert isinstance(shift, int)
+        assert shift is not None
+        args.append(shift)
+
+    img._f = _filter_rectangle(img._f, pt1, pt2, color, *args)
+
+
+def putText(
+    img,
+    text,
+    org,
+    fontFace,
+    fontScale,
+    color,
+    thickness=None,
+    lineType=None,
+    bottomLeftOrigin=None,
+):
+    """
+    cv.putText(	img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]]	)
+    """
+
+    assert isinstance(img, _Frame)
+    img._mut()
+
+    assert isinstance(text, str)
+
+    assert len(org) == 2
+    assert all(isinstance(x, int) for x in org)
+
+    assert isinstance(fontFace, int)
+    assert isinstance(fontScale, float) or isinstance(fontScale, int)
+    fontScale = float(fontScale)
+
+    assert len(color) == 3 or len(color) == 4
+    color = [float(x) for x in color]
+    if len(color) == 3:
+        color.append(255.0)
+
+    args = []
+    if thickness is not None:
+        assert isinstance(thickness, int)
+        args.append(thickness)
+    if lineType is not None:
+        assert isinstance(lineType, int)
+        assert thickness is not None
+        args.append(lineType)
+    if bottomLeftOrigin is not None:
+        assert isinstance(bottomLeftOrigin, bool)
+        assert lineType is not None
+        args.append(bottomLeftOrigin)
+
+    img._f = _filter_putText(img._f, text, org, fontFace, fontScale, color, *args)

vidformer.py → vidformer/vf.py

@@ -1,7 +1,3 @@
-"""A Python library for creating and viewing videos with vidformer."""
-
-__version__ = "0.5.3"
-
 import subprocess
 from fractions import Fraction
 import random
@@ -15,11 +11,14 @@ import uuid
 import threading
 import gzip
 import base64
+import re
 
 import requests
 import msgpack
 import numpy as np
 
+from . import __version__
+
 _in_notebook = False
 try:
     from IPython import get_ipython
@@ -354,7 +353,7 @@ class Loader:
 class YrdenServer:
     """A connection to a Yrden server"""
 
-    def __init__(self, domain=None, port=None, bin="vidformer-cli"):
+    def __init__(self, domain=None, port=None, bin=None):
         """Connect to a Yrden server
 
         Can either connect to an existing server, if domain and port are provided, or start a new server using the provided binary
@@ -364,7 +363,12 @@ class YrdenServer:
         self._port = port
         self._proc = None
         if self._port is None:
-            assert bin is not None
+            if bin is None:
+                if os.getenv("VIDFORMER_BIN") is not None:
+                    bin = os.getenv("VIDFORMER_BIN")
+                else:
+                    bin = "vidformer-cli"
+
             self._domain = "localhost"
             self._port = random.randint(49152, 65535)
             cmd = [bin, "yrden", "--port", str(self._port)]
@@ -507,6 +511,21 @@ class Source:
     def __init__(
         self, server: YrdenServer, name: str, path: str, stream: int, service=None
     ):
+        if service is None:
+            # check if path is a http URL and, if so, automatically set the service
+            # for example, the following code should work with just vf.Source(server, "tos_720p", "https://f.dominik.win/data/dve2/tos_720p.mp4")
+            # this creates a storage service with endpoint "https://f.dominik.win/" and path "data/dve2/tos_720p.mp4"
+            # don't use the root parameter in this case
+
+            match = re.match(r"(http|https)://([^/]+)(.*)", path)
+            if match is not None:
+                endpoint = f"{match.group(1)}://{match.group(2)}"
+                path = match.group(3)
+                # remove leading slash
+                if path.startswith("/"):
+                    path = path[1:]
+                service = StorageService("http", endpoint=endpoint)
+
         self._server = server
         self._name = name
         self._path = path
@@ -563,17 +582,31 @@ class StorageService:
         return f"{self._service}(config={self._config})"
 
 
-def _json_arg(arg):
+def _json_arg(arg, skip_data_anot=False):
     if type(arg) == FilterExpr or type(arg) == SourceExpr:
         return {"Frame": arg._to_json_spec()}
     elif type(arg) == int:
+        if skip_data_anot:
+            return {"Int": arg}
         return {"Data": {"Int": arg}}
     elif type(arg) == str:
+        if skip_data_anot:
+            return {"String": arg}
         return {"Data": {"String": arg}}
+    elif type(arg) == float:
+        if skip_data_anot:
+            return {"Float": arg}
+        return {"Data": {"Float": arg}}
     elif type(arg) == bool:
+        if skip_data_anot:
+            return {"Bool": arg}
         return {"Data": {"Bool": arg}}
+    elif type(arg) == tuple or type(arg) == list:
+        if skip_data_anot:
+            return {"List": [_json_arg(x, True) for x in list(arg)]}
+        return {"Data": {"List": [_json_arg(x, True) for x in list(arg)]}}
     else:
-        assert False
+        raise Exception(f"Unknown arg type: {type(arg)}")
 
 
 class Filter:
@@ -735,9 +768,9 @@ class UDF:
         keys = list(obj.keys())
         assert len(keys) == 1
         type_key = keys[0]
-        assert type_key in ["Frame", "String", "Int", "Bool"]
+        assert type_key in ["FrameType", "String", "Int", "Bool"]
 
-        if type_key == "Frame":
+        if type_key == "FrameType":
             frame = obj[type_key]
             assert type(frame) == dict
             assert "width" in frame

{vidformer-0.5.3.dist-info → vidformer-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vidformer
-Version: 0.5.3
+Version: 0.6.0
 Summary: A Python library for creating and viewing videos with vidformer.
 Author-email: Dominik Winecki <dominikwinecki@gmail.com>
 Requires-Python: >=3.8

vidformer-0.6.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+vidformer/__init__.py,sha256=MgZOCVL7wOxSseM5LArXHtW3FzPKLcmGzUaosUhSn6A,113
+vidformer/vf.py,sha256=gexrp0PQ8cbkixCPLY9BCquHeHWfD6iUcA_wbSxGmFQ,29511
+vidformer/cv2/__init__.py,sha256=wOjDsYyUKlP_Hye8-tyz-msu9xwaPMpN2sGMu3Lh3-w,22
+vidformer/cv2/vf_cv2.py,sha256=C3b8OEGSHh7AFbtddybP_DwR7rvy34lCewt9JWcLTaM,6196
+vidformer-0.6.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+vidformer-0.6.0.dist-info/METADATA,sha256=hK3hz1DM6NQfkmMz2L5Uc098wgCvPJzaHbpkZy-DDt8,643
+vidformer-0.6.0.dist-info/RECORD,,

vidformer-0.5.3.dist-info/RECORD

@@ -1,4 +0,0 @@
-vidformer.py,sha256=nlgIXey_gOWnsQPtJ3cuhq0WqENVyQNJ5tslwFSnPR4,27989
-vidformer-0.5.3.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-vidformer-0.5.3.dist-info/METADATA,sha256=tpzhQ8QKqulcUoSBSmb-zGJRye3lCCucqfJzOSWp2FA,643
-vidformer-0.5.3.dist-info/RECORD,,