vidformer 0.5.4__py3-none-any.whl → 0.6.1__py3-none-any.whl

vidformer/__init__.py

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

vidformer/cv2/__init__.py

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

vidformer/cv2/vf_cv2.py

@@ -0,0 +1,428 @@
+from .. import vf
+
+try:
+    import cv2 as _opencv2
+except:
+    _opencv2 = None
+
+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")
+_filter_arrowedLine = vf.Filter("cv2.arrowedLine")
+_filter_line = vf.Filter("cv2.line")
+_filter_circle = vf.Filter("cv2.circle")
+_filter_addWeighted = vf.Filter("cv2.addWeighted")
+
+
+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)
+
+
+def arrowedLine(
+    img, pt1, pt2, color, thickness=None, line_type=None, shift=None, tipLength=None
+):
+    """
+    cv.arrowedLine(	img, pt1, pt2, color[, thickness[, line_type[, shift[, tipLength]]]]	)
+    """
+    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 line_type is not None:
+        assert isinstance(line_type, int)
+        assert thickness is not None
+        args.append(line_type)
+    if shift is not None:
+        assert isinstance(shift, int)
+        assert shift is not None
+        args.append(shift)
+    if tipLength is not None:
+        assert isinstance(tipLength, float)
+        assert shift is not None
+        args.append(tipLength)
+
+    img._f = _filter_arrowedLine(img._f, pt1, pt2, color, *args)
+
+
+def line(img, pt1, pt2, color, thickness=None, lineType=None, shift=None):
+    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_line(img._f, pt1, pt2, color, *args)
+
+
+def circle(img, center, radius, color, thickness=None, lineType=None, shift=None):
+    assert isinstance(img, _Frame)
+    img._mut()
+
+    assert len(center) == 2
+    assert all(isinstance(x, int) for x in center)
+
+    assert isinstance(radius, int)
+
+    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_circle(img._f, center, radius, color, *args)
+
+
+def getFontScaleFromHeight(*args, **kwargs):
+    """
+    cv.getFontScaleFromHeight(	fontFace, pixelHeight[, thickness]	)
+    """
+    if _opencv2 is None:
+        raise NotImplementedError("getFontScaleFromHeight requires the cv2 module")
+    return _opencv2.getFontScaleFromHeight(*args, **kwargs)
+
+
+def getTextSize(*args, **kwargs):
+    """
+    cv.getTextSize(	text, fontFace, fontScale, thickness	)
+    """
+    if _opencv2 is None:
+        raise NotImplementedError("getTextSize requires the cv2 module")
+    return _opencv2.getTextSize(*args, **kwargs)
+
+
+def addWeighted(src1, alpha, src2, beta, gamma, dst=None, dtype=-1):
+    """
+    cv.addWeighted(	src1, alpha, src2, beta, gamma[, dst[, dtype]]	) -> 	dst
+    """
+    assert isinstance(src1, _Frame)
+    assert isinstance(src2, _Frame)
+    src1._mut()
+    src2._mut()
+
+    if dst is None:
+        dst = _Frame(src1._f)
+    else:
+        assert isinstance(dst, _Frame)
+    dst._mut()
+
+    assert isinstance(alpha, float) or isinstance(alpha, int)
+    assert isinstance(beta, float) or isinstance(beta, int)
+    assert isinstance(gamma, float) or isinstance(gamma, int)
+    alpha = float(alpha)
+    beta = float(beta)
+    gamma = float(gamma)
+
+    if dtype != -1:
+        raise Exception("addWeighted does not support the dtype argument")
+
+    dst._f = _filter_addWeighted(src1._f, alpha, src2._f, beta, gamma)
+    return dst
+
+
+# Stubs for unimplemented functions
+
+
+def clipLine(*args, **kwargs):
+    raise NotImplementedError("clipLine is not yet implemented in the cv2 frontend")
+
+
+def drawContours(*args, **kwargs):
+    raise NotImplementedError("drawContours is not yet implemented in the cv2 frontend")
+
+
+def drawMarker(*args, **kwargs):
+    raise NotImplementedError("drawMarker is not yet implemented in the cv2 frontend")
+
+
+def ellipse(*args, **kwargs):
+    raise NotImplementedError("ellipse is not yet implemented in the cv2 frontend")
+
+
+def ellipse2Poly(*args, **kwargs):
+    raise NotImplementedError("ellipse2Poly is not yet implemented in the cv2 frontend")
+
+
+def fillConvexPoly(*args, **kwargs):
+    raise NotImplementedError(
+        "fillConvexPoly is not yet implemented in the cv2 frontend"
+    )
+
+
+def fillPoly(*args, **kwargs):
+    raise NotImplementedError("fillPoly is not yet implemented in the cv2 frontend")
+
+
+def polylines(*args, **kwargs):
+    raise NotImplementedError("polylines is not yet implemented in the cv2 frontend")

vidformer.py → vidformer/vf.py

@@ -1,7 +1,3 @@
-"""A Python library for creating and viewing videos with vidformer."""
-
-__version__ = "0.5.4"
-
 import subprocess
 from fractions import Fraction
 import random
@@ -21,6 +17,8 @@ import requests
 import msgpack
 import numpy as np
 
+from . import __version__
+
 _in_notebook = False
 try:
     from IPython import get_ipython
@@ -355,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
@@ -365,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)]
@@ -579,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:
@@ -751,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.6.1.dist-info/METADATA

@@ -0,0 +1,36 @@
+Metadata-Version: 2.1
+Name: vidformer
+Version: 0.6.1
+Summary: A Python library for creating and viewing videos with vidformer.
+Author-email: Dominik Winecki <dominikwinecki@gmail.com>
+Requires-Python: >=3.8
+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/
+Project-URL: Issues, https://github.com/ixlab/vidformer/issues
+
+# vidformer-py
+
+[![PyPI version](https://img.shields.io/pypi/v/vidformer.svg)](https://pypi.org/project/vidformer/)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/ixlab/vidformer/blob/main/LICENSE)
+
+
+vidformer-py is our Python 🐍 interface for [vidformer](https://github.com/ixlab/vidformer).
+Our [getting started guide](https://ixlab.github.io/vidformer/getting-started.html) explains how to use it.
+
+**Quick links:**
+* [📦 PyPI](https://pypi.org/project/vidformer/)
+* [📘 Documentation](https://ixlab.github.io/vidformer/vidformer-py/)
+* [🧑‍💻 Source Code](https://github.com/ixlab/vidformer/tree/main/vidformer-py/)
+
+**Publish:**
+```bash
+ export FLIT_USERNAME='__token__' FLIT_PASSWORD='<token>'
+flit publish
+```
+

vidformer-0.6.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+vidformer/__init__.py,sha256=C-kb3m7hPUh0Sw09vty3JKJHMbJTQcdqSmt8m2V9HIM,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=m05MNPklhaaAfFQfTWetJ_FqWq0u_s77INfABUnHVoA,11664
+vidformer-0.6.1.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+vidformer-0.6.1.dist-info/METADATA,sha256=gbvJy_0NGLbnq-EvDsDSoUm7EmHhlfUQL5au6pKCsXk,1383
+vidformer-0.6.1.dist-info/RECORD,,

vidformer-0.5.4.dist-info/METADATA

@@ -1,24 +0,0 @@
-Metadata-Version: 2.1
-Name: vidformer
-Version: 0.5.4
-Summary: A Python library for creating and viewing videos with vidformer.
-Author-email: Dominik Winecki <dominikwinecki@gmail.com>
-Requires-Python: >=3.8
-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: Homepage, https://ixlab.github.io/vidformer/
-Project-URL: Issues, https://ixlab.github.io/vidformer/issues
-
-# vidformer-py
-
-## Publish
-
-```bash
- export FLIT_USERNAME='__token__' FLIT_PASSWORD='<token>'
-flit publish
-```
-

vidformer-0.5.4.dist-info/RECORD

@@ -1,4 +0,0 @@
-vidformer.py,sha256=11H5DONF82OWWdd4DxE30u9puuT_Y3sy3bFEhvKZs54,28821
-vidformer-0.5.4.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-vidformer-0.5.4.dist-info/METADATA,sha256=Sn-s_MobObWQkbOiqDqeKNB69Td5kjM79TdXN-YXgHs,643
-vidformer-0.5.4.dist-info/RECORD,,