eventify-dvs 0.1.0__py3-none-any.whl

eventify/__init__.py

@@ -0,0 +1,15 @@
+from eventify.dvs import (
+    EVENT_DTYPE,
+    frame_to_event_tuples,
+    interpolate_frames,
+    video_to_event_stream,
+    write_hdf5,
+)
+
+__all__ = [
+    "EVENT_DTYPE",
+    "frame_to_event_tuples",
+    "interpolate_frames",
+    "video_to_event_stream",
+    "write_hdf5",
+]

eventify/_fast.py

@@ -0,0 +1,39 @@
+"""Fast primitives for the low-latency webcam preview."""
+
+from __future__ import annotations
+
+from typing import Optional, Tuple
+
+import numpy as np
+
+
+def build_log_lut(eps: float = 1.0) -> np.ndarray:
+    """Precompute ``log(x + eps)`` for x = 0..255 as a float32 array."""
+    x = np.arange(256, dtype=np.float32)
+    return np.log(x + np.float32(eps))
+
+
+def frame_to_crossing_counts(
+    prev_frame: np.ndarray,
+    curr_frame: np.ndarray,
+    c_thresh: float = 0.05,
+    log_lut: Optional[np.ndarray] = None,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Return ``(on_counts, off_counts)`` 2D int arrays. Inputs must be uint8 grayscale."""
+    if prev_frame.dtype != np.uint8 or curr_frame.dtype != np.uint8:
+        raise TypeError(
+            "frame_to_crossing_counts requires uint8 inputs; "
+            f"got {prev_frame.dtype} and {curr_frame.dtype}"
+        )
+    if prev_frame.shape != curr_frame.shape:
+        raise ValueError(
+            f"Frame shape mismatch: {prev_frame.shape} vs {curr_frame.shape}"
+        )
+
+    if log_lut is None:
+        log_lut = build_log_lut(eps=1.0)
+
+    delta = log_lut[curr_frame] - log_lut[prev_frame]
+    crossings = np.floor_divide(np.abs(delta), c_thresh).astype(np.int16)
+    positive = delta > 0
+    return np.where(positive, crossings, 0), np.where(positive, 0, crossings)

eventify/cli.py

@@ -0,0 +1,279 @@
+"""Command-line entry point for eventify."""
+
+from __future__ import annotations
+
+import argparse
+import queue
+import sys
+import threading
+import time
+from typing import Optional, Sequence
+
+import cv2
+import numpy as np
+
+from eventify._fast import build_log_lut, frame_to_crossing_counts
+from eventify.dvs import EVENT_DTYPE, video_to_event_stream, write_hdf5
+
+# DVS palette (BGR): ON = deep blue, OFF = amber.
+_ON_BGR = np.array([180, 70, 0], dtype=np.float32)
+_OFF_BGR = np.array([0, 170, 220], dtype=np.float32)
+
+
+def _parse_sensor_size(spec: str) -> tuple[int, int]:
+    try:
+        w_str, h_str = spec.split(",")
+        return int(w_str), int(h_str)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError(
+            f"--sensor-size must be 'W,H' (got {spec!r})"
+        ) from exc
+
+
+def _capture_settings_from_args(args: argparse.Namespace) -> Optional[dict]:
+    props = {}
+    if getattr(args, "width", None):
+        props[cv2.CAP_PROP_FRAME_WIDTH] = args.width
+    if getattr(args, "height", None):
+        props[cv2.CAP_PROP_FRAME_HEIGHT] = args.height
+    if getattr(args, "fps", None):
+        props[cv2.CAP_PROP_FPS] = args.fps
+    return props or None
+
+
+def _events_to_frame(chunk: np.ndarray, h: int, w: int) -> np.ndarray:
+    """Render a structured event array into a BGR uint8 frame."""
+    on = np.zeros((h, w), dtype=np.float32)
+    off = np.zeros((h, w), dtype=np.float32)
+    if len(chunk):
+        mask_on = chunk["p"] == 1
+        np.add.at(on, (chunk["y"][mask_on], chunk["x"][mask_on]), 1)
+        np.add.at(off, (chunk["y"][~mask_on], chunk["x"][~mask_on]), 1)
+
+    peak = max(on.max(), off.max(), 1.0)
+    intensity_on = np.clip(on / peak, 0.0, 1.0)[..., None]
+    intensity_off = np.clip(off / peak, 0.0, 1.0)[..., None]
+    img = intensity_on * _ON_BGR + intensity_off * _OFF_BGR
+    return np.clip(img, 0, 255).astype(np.uint8)
+
+
+def _convert(args: argparse.Namespace) -> int:
+    cap = cv2.VideoCapture(args.input)
+    if not cap.isOpened():
+        print(f"error: could not open input video: {args.input}", file=sys.stderr)
+        return 1
+    fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    cap.release()
+
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    writer = cv2.VideoWriter(args.output, fourcc, fps, (width, height), isColor=True)
+    if not writer.isOpened():
+        print(f"error: could not open output for writing: {args.output}", file=sys.stderr)
+        return 1
+
+    count = 0
+    try:
+        for chunk in video_to_event_stream(args.input, c_thresh=args.threshold):
+            writer.write(_events_to_frame(chunk, height, width))
+            count += 1
+    finally:
+        writer.release()
+
+    print(f"wrote {count} event frames to {args.output}")
+    return 0
+
+
+class _ThreadedCapture:
+    """Drops stale frames so the display loop always gets the latest."""
+
+    def __init__(self, source, capture_settings: Optional[dict] = None):
+        self._cap = cv2.VideoCapture(source)
+        if not self._cap.isOpened():
+            self._cap.release()
+            raise IOError(f"Could not open video source: {source!r}")
+        if capture_settings:
+            for prop, value in capture_settings.items():
+                self._cap.set(prop, value)
+        self._q: "queue.Queue" = queue.Queue(maxsize=1)
+        self._stop = threading.Event()
+        self._thread = threading.Thread(target=self._reader, daemon=True)
+        self._thread.start()
+
+    def _reader(self) -> None:
+        while not self._stop.is_set():
+            ok, frame = self._cap.read()
+            if not ok or frame is None:
+                self._stop.set()
+                break
+            try:
+                self._q.get_nowait()
+            except queue.Empty:
+                pass
+            try:
+                self._q.put_nowait(frame)
+            except queue.Full:
+                pass
+
+    def read(self, timeout: float = 1.0) -> Optional[np.ndarray]:
+        try:
+            return self._q.get(timeout=timeout)
+        except queue.Empty:
+            return None
+
+    def release(self) -> None:
+        self._stop.set()
+        self._thread.join(timeout=1.0)
+        self._cap.release()
+
+    @property
+    def actual_size(self) -> tuple[int, int]:
+        return (
+            int(self._cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
+            int(self._cap.get(cv2.CAP_PROP_FRAME_HEIGHT)),
+        )
+
+
+def _accum_to_bgr(accum: np.ndarray, max_events: float) -> np.ndarray:
+    intensity = np.clip(np.abs(accum) / max_events, 0.0, 1.0)[..., None]
+    positive = accum >= 0
+    target = np.empty(accum.shape + (3,), dtype=np.float32)
+    target[..., 0] = np.where(positive, 180.0, 0.0)
+    target[..., 1] = np.where(positive, 70.0, 170.0)
+    target[..., 2] = np.where(positive, 0.0, 220.0)
+    return np.clip(intensity * target, 0, 255).astype(np.uint8)
+
+
+def _webcam(args: argparse.Namespace) -> int:
+    window = "eventify — press q to quit"
+    cv2.namedWindow(window, cv2.WINDOW_NORMAL)
+
+    log_lut = build_log_lut(eps=1.0)
+    half_life_sec = max(args.accum_ms, 1) / 1000.0
+
+    accum: Optional[np.ndarray] = None
+    prev_gray: Optional[np.ndarray] = None
+    last_tick = time.monotonic()
+    frames_shown = 0
+    events_seen = 0
+    start = time.monotonic()
+
+    cap = _ThreadedCapture(args.device, capture_settings=_capture_settings_from_args(args))
+    print(f"capture opened at {cap.actual_size[0]}x{cap.actual_size[1]}", file=sys.stderr)
+
+    try:
+        while True:
+            frame = cap.read(timeout=1.0)
+            if frame is None:
+                break
+
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+            if prev_gray is None:
+                prev_gray = gray
+                accum = np.zeros(gray.shape, dtype=np.float32)
+                continue
+
+            on, off = frame_to_crossing_counts(prev_gray, gray, c_thresh=args.threshold, log_lut=log_lut)
+
+            now = time.monotonic()
+            dt = now - last_tick
+            last_tick = now
+            decay = 0.5 ** (dt / half_life_sec)
+
+            accum *= decay
+            accum += on.astype(np.float32)
+            accum -= off.astype(np.float32)
+
+            events_seen += int(on.sum()) + int(off.sum())
+            cv2.imshow(window, _accum_to_bgr(accum, max_events=args.max_events))
+            frames_shown += 1
+            prev_gray = gray
+
+            if cv2.waitKey(1) & 0xFF == ord("q"):
+                break
+    finally:
+        cap.release()
+        cv2.destroyAllWindows()
+
+    elapsed = max(time.monotonic() - start, 1e-6)
+    print(
+        f"showed {frames_shown} frames in {elapsed:.1f}s "
+        f"({frames_shown / elapsed:.1f} fps display, "
+        f"{events_seen / elapsed:,.0f} ev/s)"
+    )
+    return 0
+
+
+def _export(args: argparse.Namespace) -> int:
+    chunks = []
+    total = 0
+    for chunk in video_to_event_stream(
+        args.input,
+        c_thresh=args.threshold,
+        sensor_size=args.sensor_size,
+        interp=args.interp,
+    ):
+        chunks.append(chunk)
+        total += len(chunk)
+
+    if args.sensor_size is not None:
+        w, h = args.sensor_size
+        resolved_shape = (h, w)
+    else:
+        cap = cv2.VideoCapture(args.input)
+        resolved_shape = (
+            int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)),
+            int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
+        )
+        cap.release()
+
+    events = np.concatenate(chunks) if chunks else np.zeros(0, dtype=EVENT_DTYPE)
+    write_hdf5(args.output, events, sensor_shape=resolved_shape)
+    print(f"wrote {total} events to {args.output} (sensor_shape={resolved_shape})")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="eventify",
+        description="Convert video or webcam feeds into simulated event-camera data.",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    convert = sub.add_parser("convert", help="Convert a video file to an event-rendered video.")
+    convert.add_argument("input", help="Path to the input video file.")
+    convert.add_argument("output", help="Path to write the event-rendered video (e.g. out.mp4).")
+    convert.add_argument("--threshold", type=float, default=0.05, help="Log-intensity event threshold (default: 0.05).")
+    convert.set_defaults(func=_convert)
+
+    webcam = sub.add_parser("webcam", help="Show live event stream from the webcam.")
+    webcam.add_argument("--device", type=int, default=0, help="Webcam device index (default: 0).")
+    webcam.add_argument("--threshold", type=float, default=0.05, help="Log-intensity event threshold (default: 0.05).")
+    webcam.add_argument("--width", type=int, default=1280, help="Requested capture width (default: 1280).")
+    webcam.add_argument("--height", type=int, default=720, help="Requested capture height (default: 720).")
+    webcam.add_argument("--fps", type=float, default=60.0, help="Requested capture FPS (default: 60).")
+    webcam.add_argument("--accum-ms", type=float, default=80.0, help="Event accumulation half-life in ms (default: 80).")
+    webcam.add_argument("--max-events", type=float, default=8.0, help="Saturation ceiling for accumulated events per pixel (default: 8).")
+    webcam.set_defaults(func=_webcam)
+
+    export = sub.add_parser("export", help="Export a video's events to a DVS-Gesture-compatible HDF5 file.")
+    export.add_argument("input", help="Path to the input video file.")
+    export.add_argument("output", help="Path to write the events HDF5 file (e.g. out.h5).")
+    export.add_argument("--threshold", type=float, default=0.05, help="Log-intensity event threshold (default: 0.05).")
+    export.add_argument("--sensor-size", type=_parse_sensor_size, default=None, metavar="W,H", help="Override sensor resolution as 'W,H'.")
+    export.add_argument("--interp", type=int, default=0, help="Number of interpolated sub-frames between real frames (default: 0).")
+    export.set_defaults(func=_export)
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

eventify/dvs.py

@@ -0,0 +1,232 @@
+"""DVS-style event simulation: binary-polarity (x, y, t_us, p) tuples."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Generator, Optional, Tuple, Union
+
+import cv2
+import h5py
+import numpy as np
+
+# NumPy structured dtype for a single DVS event.
+# int16 coords cover any realistic sensor; int64 for µs timestamps to
+# hold long captures without overflow. Polarity ∈ {0, 1}.
+EVENT_DTYPE = np.dtype([("x", "<i2"), ("y", "<i2"), ("t", "<i8"), ("p", "<i1")])
+
+
+def _to_gray_float(frame: np.ndarray) -> np.ndarray:
+    if frame.ndim == 3:
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    return frame.astype(np.float32, copy=False)
+
+
+def _maybe_resize(
+    frame: np.ndarray, sensor_size: Optional[Tuple[int, int]]
+) -> np.ndarray:
+    if sensor_size is None:
+        return frame
+    w, h = sensor_size
+    return cv2.resize(frame, (w, h), interpolation=cv2.INTER_AREA)
+
+
+def interpolate_frames(
+    prev_frame: np.ndarray,
+    curr_frame: np.ndarray,
+    n_intermediate: int,
+) -> list:
+    """Linearly interpolate ``n_intermediate`` frames between two endpoints.
+
+    Returns a list of length ``n_intermediate + 2`` starting with ``prev_frame``
+    and ending with ``curr_frame``. A naive stand-in for optical-flow-based
+    interpolation (v2e's SuperSloMo) that keeps the library dependency-free.
+    """
+    if prev_frame.shape != curr_frame.shape:
+        raise ValueError(
+            f"Frame shape mismatch: {prev_frame.shape} vs {curr_frame.shape}"
+        )
+    if n_intermediate < 0:
+        raise ValueError(f"n_intermediate must be >= 0, got {n_intermediate}")
+
+    prev_f = prev_frame.astype(np.float32, copy=False)
+    curr_f = curr_frame.astype(np.float32, copy=False)
+
+    total = n_intermediate + 2
+    alphas = np.linspace(0.0, 1.0, total)
+    return [(1.0 - a) * prev_f + a * curr_f for a in alphas]
+
+
+def frame_to_event_tuples(
+    prev_frame: np.ndarray,
+    curr_frame: np.ndarray,
+    prev_t_us: int,
+    curr_t_us: int,
+    c_thresh: float = 0.05,
+    eps: float = 1.0,
+    sensor_size: Optional[Tuple[int, int]] = None,
+) -> np.ndarray:
+    """Emit binary-polarity DVS event tuples with multi-crossing.
+
+    A pixel whose log-intensity change spans ``K`` threshold widths emits
+    ``K`` events (matching how a real DVS sensor fires once per crossing).
+    Each pixel's events are staggered uniformly across
+    ``[prev_t_us, curr_t_us]`` so their timestamps are strictly monotonic.
+    """
+    if prev_frame.shape != curr_frame.shape:
+        raise ValueError(
+            f"Frame shape mismatch: {prev_frame.shape} vs {curr_frame.shape}"
+        )
+    if curr_t_us < prev_t_us:
+        raise ValueError(f"curr_t_us ({curr_t_us}) must be >= prev_t_us ({prev_t_us})")
+
+    prev = _maybe_resize(_to_gray_float(prev_frame), sensor_size)
+    curr = _maybe_resize(_to_gray_float(curr_frame), sensor_size)
+
+    delta = np.log(curr + eps) - np.log(prev + eps)
+
+    # How many full c_thresh crossings did each pixel span?
+    crossings = np.floor(np.abs(delta) / c_thresh).astype(np.int32)
+    total_events = int(crossings.sum())
+    if total_events == 0:
+        return np.zeros(0, dtype=EVENT_DTYPE)
+
+    # Flat arrays of (x, y, polarity) counts, one entry per firing pixel.
+    ys, xs = np.nonzero(crossings)
+    counts = crossings[ys, xs]
+    polarities = (delta[ys, xs] > 0).astype(np.int8)  # 1 = ON, 0 = OFF
+
+    # Expand: each pixel contributes `counts[i]` copies of its coords/polarity.
+    events = np.zeros(total_events, dtype=EVENT_DTYPE)
+    events["x"] = np.repeat(xs.astype(np.int16), counts)
+    events["y"] = np.repeat(ys.astype(np.int16), counts)
+    events["p"] = np.repeat(polarities, counts)
+
+    # Timestamps: for each pixel with K events, stagger them uniformly across
+    # the frame interval. Position k of K → alpha = (k+1)/(K+1) so no event
+    # lands exactly on the boundary, and consecutive events at the same pixel
+    # are strictly ordered.
+    #
+    # Vectorized construction of per-pixel indices [1..K1, 1..K2, ...]:
+    # start_indices marks where each pixel's block begins in the flat array;
+    # a running cumsum minus the offset per block yields 1..K per pixel.
+    interval = curr_t_us - prev_t_us
+    starts = np.concatenate([[0], np.cumsum(counts[:-1])])
+    within_pixel_idx = (np.arange(total_events) - np.repeat(starts, counts) + 1).astype(
+        np.float64
+    )
+    within_pixel_denom = np.repeat(counts + 1, counts).astype(np.float64)
+    alphas = within_pixel_idx / within_pixel_denom
+    events["t"] = (prev_t_us + alphas * interval).astype(np.int64)
+
+    return events
+
+
+def video_to_event_stream(
+    source: Union[str, int],
+    c_thresh: float = 0.05,
+    sensor_size: Optional[Tuple[int, int]] = None,
+    interp: int = 0,
+    capture_settings: Optional[dict] = None,
+) -> Generator[np.ndarray, None, None]:
+    """Yield per-frame-pair structured event arrays from a video or webcam.
+
+    ``source`` is a file path or an integer webcam device index. When
+    ``interp > 0``, that many sub-frames are linearly interpolated between
+    each real frame pair and event generation runs on every sub-interval,
+    yielding one chunk per sub-interval. ``capture_settings`` is an optional
+    dict of OpenCV ``CAP_PROP_*`` overrides (e.g. width/height/fps) applied
+    right after the capture opens.
+    """
+    cap = cv2.VideoCapture(source)
+    if not cap.isOpened():
+        cap.release()
+        raise IOError(f"Could not open video source: {source!r}")
+
+    if capture_settings:
+        for prop, value in capture_settings.items():
+            cap.set(prop, value)
+
+    fps = cap.get(cv2.CAP_PROP_FPS) or 0.0
+    frame_period_us = (
+        int(1_000_000 / fps) if fps > 0 else 33_333
+    )  # ~30 FPS webcam fallback
+
+    try:
+        ok, prev = cap.read()
+        if not ok or prev is None:
+            return
+        prev_t_us = 0
+
+        prev_processed = _maybe_resize(_to_gray_float(prev), sensor_size)
+
+        frame_idx = 1
+        while True:
+            ok, curr = cap.read()
+            if not ok or curr is None:
+                break
+
+            curr_processed = _maybe_resize(_to_gray_float(curr), sensor_size)
+
+            pos_ms = cap.get(cv2.CAP_PROP_POS_MSEC)
+            if pos_ms and pos_ms > 0:
+                curr_t_us = int(pos_ms * 1000)
+            else:
+                curr_t_us = frame_idx * frame_period_us
+
+            if interp <= 0:
+                yield frame_to_event_tuples(
+                    prev_processed,
+                    curr_processed,
+                    prev_t_us=prev_t_us,
+                    curr_t_us=curr_t_us,
+                    c_thresh=c_thresh,
+                )
+            else:
+                sub_frames = interpolate_frames(
+                    prev_processed, curr_processed, n_intermediate=interp
+                )
+                n_sub = len(sub_frames) - 1  # number of sub-intervals
+                span = curr_t_us - prev_t_us
+                for i in range(n_sub):
+                    sub_prev_t = prev_t_us + i * span // n_sub
+                    sub_curr_t = prev_t_us + (i + 1) * span // n_sub
+                    yield frame_to_event_tuples(
+                        sub_frames[i],
+                        sub_frames[i + 1],
+                        prev_t_us=sub_prev_t,
+                        curr_t_us=sub_curr_t,
+                        c_thresh=c_thresh,
+                    )
+
+            prev_processed = curr_processed
+            prev_t_us = curr_t_us
+            frame_idx += 1
+    finally:
+        cap.release()
+
+
+def write_hdf5(
+    path: Union[str, os.PathLike],
+    events: np.ndarray,
+    sensor_shape: Tuple[int, int],
+) -> None:
+    """Write events to an HDF5 file using the DVS-Gesture reprocessed layout.
+
+    Layout::
+
+        /events                     (group)
+            .attrs["sensor_shape"]  (2,) int  – (height, width)
+            /xs   int16   x coords
+            /ys   int16   y coords
+            /ts   int64   timestamps (µs)
+            /ps   int8    polarities ∈ {0, 1}
+    """
+    path = Path(path)
+    with h5py.File(path, "w") as f:
+        grp = f.create_group("events")
+        grp.attrs["sensor_shape"] = np.array(sensor_shape, dtype=np.int64)
+        grp.create_dataset("xs", data=events["x"].astype(np.int16), dtype="<i2")
+        grp.create_dataset("ys", data=events["y"].astype(np.int16), dtype="<i2")
+        grp.create_dataset("ts", data=events["t"].astype(np.int64), dtype="<i8")
+        grp.create_dataset("ps", data=events["p"].astype(np.int8), dtype="<i1")

eventify_dvs-0.1.0.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: eventify-dvs
+Version: 0.1.0
+Summary: Convert video files or webcam feeds into simulated event-camera (DVS) data.
+Author: Arpan Pandey
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: h5py>=3.8
+Requires-Dist: numpy>=1.24
+Requires-Dist: opencv-python>=4.8
+Description-Content-Type: text/markdown
+
+# eventify-dvs
+
+Convert video files or webcam feeds into simulated event-camera (DVS) data using log-intensity differencing. A clean-room, dependency-light reimplementation of the core idea behind v2e/ESIM — no CUDA, no PyTorch, no pretrained models. Just NumPy, OpenCV, and h5py.
+
+## Install
+
+```bash
+pip install eventify-dvs
+```
+
+The CLI entry point is `eventify`. With `uv`:
+
+```bash
+uv add eventify-dvs
+uv run eventify --help
+```
+
+## CLI
+
+Three subcommands under the `eventify` entry point.
+
+### `eventify webcam` — live event preview
+
+Opens the default camera and shows the event stream in an OpenCV window. Press `q` to quit. On macOS, grant camera permission to your terminal app first (System Settings → Privacy & Security → Camera).
+
+```bash
+# Defaults — 1280x720 @ 60 FPS
+eventify webcam
+
+# Snappy, high-sensitivity preview
+eventify webcam --threshold 0.03 --accum-ms 40
+
+# Different camera
+eventify webcam --device 1
+```
+
+| Flag | Default | Purpose |
+|---|---|---|
+| `--device` | `0` | Webcam device index |
+| `--threshold` | `0.05` | Log-intensity event threshold |
+| `--width` | `1280` | Requested capture width |
+| `--height` | `720` | Requested capture height |
+| `--fps` | `60` | Requested capture FPS |
+| `--accum-ms` | `80` | Event accumulator half-life in ms |
+| `--max-events` | `8` | Saturation ceiling for accumulated events per pixel |
+
+### `eventify convert` — video file → event-visualized video
+
+```bash
+eventify convert input.mp4 events.mp4
+eventify convert input.mp4 events.mp4 --threshold 0.03
+```
+
+| Flag | Default | Purpose |
+|---|---|---|
+| `input` | — | Path to source video |
+| `output` | — | Path to write the rendered MP4 |
+| `--threshold` | `0.05` | Log-intensity event threshold |
+
+### `eventify export` — video → DVS-Gesture HDF5
+
+Emits binary-polarity DVS events to an HDF5 file compatible with the DVS128 Gesture dataset layout (Tonic / SpikingJelly loaders).
+
+```bash
+eventify export input.mp4 events.h5
+eventify export input.mp4 events.h5 --sensor-size 128,128 --interp 4
+```
+
+| Flag | Default | Purpose |
+|---|---|---|
+| `input` | — | Path to source video |
+| `output` | — | Path to write the HDF5 events file |
+| `--threshold` | `0.05` | Log-intensity event threshold |
+| `--sensor-size` | source resolution | Override as `W,H` |
+| `--interp` | `0` | Interpolated sub-frames between real frames |
+
+## Library
+
+```python
+import numpy as np
+from eventify import (
+    frame_to_event_tuples,
+    video_to_event_stream,
+    interpolate_frames,
+    write_hdf5,
+    EVENT_DTYPE,
+)
+
+# Per-frame-pair event tuples
+events = frame_to_event_tuples(prev, curr, prev_t_us=0, curr_t_us=1000)
+# events["x"], events["y"], events["t"], events["p"]  — p ∈ {0, 1}
+
+# Full stream from a video file
+chunks = list(video_to_event_stream("video.mp4", sensor_size=(128, 128), interp=4))
+all_events = np.concatenate(chunks)
+write_hdf5("out.h5", all_events, sensor_shape=(128, 128))
+```
+
+## API reference
+
+- **`frame_to_event_tuples(prev, curr, prev_t_us, curr_t_us, c_thresh=0.05, eps=1.0, sensor_size=None)`** —
+  returns a NumPy structured array with dtype `EVENT_DTYPE` and fields
+  `(x: i2, y: i2, t: i8, p: i1)`. Polarity is binary (0 = OFF, 1 = ON).
+  A pixel whose log-delta spans `K` thresholds emits `K` events, uniformly
+  staggered across the interval.
+
+- **`video_to_event_stream(source, c_thresh=0.05, sensor_size=None, interp=0, capture_settings=None)`** —
+  generator yielding one structured event array per (sub-)frame-pair.
+  Timestamps are monotonic microseconds.
+
+- **`interpolate_frames(prev, curr, n_intermediate)`** —
+  linearly interpolates `n_intermediate` frames between two endpoints,
+  returning a list of `n_intermediate + 2` frames.
+
+- **`write_hdf5(path, events, sensor_shape)`** — writes events in the
+  DVS-Gesture reprocessed layout:
+
+  ```
+  /events
+      .attrs["sensor_shape"]  (height, width)
+      /xs   i2
+      /ys   i2
+      /ts   i8   microseconds
+      /ps   i1   ∈ {0, 1}
+  ```
+
+- **`EVENT_DTYPE`** — NumPy structured dtype `[("x", "<i2"), ("y", "<i2"), ("t", "<i8"), ("p", "<i1")]`.
+
+## Tests
+
+```bash
+uv run pytest
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

eventify_dvs-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+eventify/__init__.py,sha256=o6LvIf2BELvXgk_EklUXxO3RMcT18v5zrlo8vWzPyek,276
+eventify/_fast.py,sha256=gYKQ5gmwnwAWuoQaRjnh6ecMIytOdWNG8UEVWWYu8eo,1327
+eventify/cli.py,sha256=4bWZf8rVbRw0Ry7PM68jaATUom6vXmEm-Y-rnl7rEUE,10193
+eventify/dvs.py,sha256=wyfMdL6cgJ4fe9wr1rI8uFO1Styn5Ejzv9axYL2MBHc,8519
+eventify_dvs-0.1.0.dist-info/METADATA,sha256=Xp_YJ_yJMS02FyujFTm9lS1vm9qbPwSGrMe-FbY5HOE,4519
+eventify_dvs-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+eventify_dvs-0.1.0.dist-info/entry_points.txt,sha256=OB4pJxjEKJk6ePwVLV5f8tXEVK0nOnXy-Cz2Xh03q60,47
+eventify_dvs-0.1.0.dist-info/licenses/LICENSE,sha256=_APnY1FSXTPgIMinskdb35YwV0MPhJ8ph5VjZkKCzuE,1069
+eventify_dvs-0.1.0.dist-info/RECORD,,

eventify_dvs-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

eventify_dvs-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+eventify = eventify.cli:main

eventify_dvs-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arpan Pandey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.