aedat 2.2.0__cp313-none-win_amd64.whl

aedat/__init__.py

@@ -0,0 +1,5 @@
+from .aedat import *
+
+__doc__ = aedat.__doc__
+if hasattr(aedat, "__all__"):
+    __all__ = aedat.__all__

aedat-2.2.0.dist-info/METADATA

@@ -0,0 +1,241 @@
+Metadata-Version: 2.3
+Name: aedat
+Version: 2.2.0
+Requires-Dist: numpy >=1.26
+License-File: LICENSE
+Summary: A fast AEDAT4 decoder with an underlying Rust implementation
+Author: International Centre for Neuromorphic Systems, Alexandre Marcireau
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: homepage, https://github.com/neuromorphicsystems/aedat/
+Project-URL: repository, https://github.com/neuromorphicsystems/aedat/
+Project-URL: documentation, https://github.com/neuromorphicsystems/aedat/
+
+AEDAT is a fast AEDAT 4 python reader, with a Rust underlying implementation.
+
+Run `pip install aedat` to install it.
+
+- [Example](#example)
+- [Process frames](#process-frames)
+    - [Pillow (PIL)](#pillow-pil)
+    - [OpenCV](#opencv)
+- [Detailed example](#detailed-example)
+- [Install from source](#install-from-source)
+    - [Linux](#linux)
+    - [macOS](#macos)
+    - [Windows](#windows)
+- [Contribute](#contribute)
+- [Publish](#publish)
+
+## Example
+
+The `aedat` library provides a single class: `Decoder`. A decoder object is created by passing a file name to `Decoder`. The file name must be a [path-like object](https://docs.python.org/3/glossary.html#term-path-like-object).
+
+```python
+import aedat
+
+decoder = aedat.Decoder("/path/to/file.aedat")
+print(decoder.id_to_stream())
+
+for packet in decoder:
+    print(packet["stream_id"], end=": ")
+    if "events" in packet:
+        print("{} polarity events".format(len(packet["events"])))
+    elif "frame" in packet:
+        print("{} x {} frame".format(packet["frame"]["width"], packet["frame"]["height"]))
+    elif "imus" in packet:
+        print("{} IMU samples".format(len(packet["imus"])))
+    elif "triggers" in packet:
+        print("{} trigger events".format(len(packet["triggers"])))
+```
+
+## Process frames
+
+### Pillow (PIL)
+
+```py
+import aedat
+import PIL.Image # https://pypi.org/project/Pillow/
+
+index = 0
+for packet in decoder:
+    if "frame" in packet:
+        image = PIL.Image.fromarray(
+            packet["frame"]["pixels"],
+            mode=packet["frame"]["format"],
+        )
+        image.save(f"{index}.png")
+        index += 1
+```
+
+### OpenCV
+
+```py
+import aedat
+import cv2 # https://pypi.org/project/opencv-python/
+
+index = 0
+for packet in decoder:
+    if "frame" in packet:
+        image = packet["frame"]["pixels"]
+        if packet["frame"]["format"] == "RGB":
+            image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+        elif packet["frame"]["format"] == "RGBA":
+            image = cv2.cvtColor(image, cv2.COLOR_RGBA2BGRA)
+        cv2.imwrite(f"{index}.png", image)
+        index += 1
+```
+
+## Detailed example
+
+This is the same as the first example, with detailed comments:
+
+```python
+import aedat
+
+decoder = aedat.Decoder("/path/to/file.aedat")
+"""
+decoder is a packet iterator with an additional method id_to_stream
+id_to_stream returns a dictionary with the following structure:
+{
+    <int>: {
+        "type": <str>,
+    }
+}
+type is one of "events", "frame", "imus", "triggers"
+if type is "events" or "frame", its parent dictionary has the following structure:
+{
+    "type": <str>,
+    "width": <int>,
+    "height": <int>,
+}
+"""
+print(decoder.id_to_stream())
+
+for packet in decoder:
+    """
+    packet is a dictionary with the following structure:
+    {
+        "stream_id": <int>,
+    }
+    packet also has exactly one of the following fields:
+        "events", "frame", "imus", "triggers"
+    """
+    print(packet["stream_id"], end=": ")
+    if "events" in packet:
+        """
+        packet["events"] is a structured numpy array with the following dtype:
+            [
+                ("t", "<u8"),
+                ("x", "<u2"),
+                ("y", "<u2"),
+                ("on", "?"),
+            ]
+        """
+        print("{} polarity events".format(len(packet["events"])))
+    elif "frame" in packet:
+        """
+        packet["frame"] is a dictionary with the following structure:
+            {
+                "t": <int>,
+                "begin_t": <int>,
+                "end_t": <int>,
+                "exposure_begin_t": <int>,
+                "exposure_end_t": <int>,
+                "format": <str>,
+                "width": <int>,
+                "height": <int>,
+                "offset_x": <int>,
+                "offset_y": <int>,
+                "pixels": <numpy.array(shape=(height, width), dtype=uint8)>,
+            }
+        format is one of "L", "RGB", "RGBA"
+        """
+        print("{} x {} frame".format(packet["frame"]["width"], packet["frame"]["height"]))
+    elif "imus" in packet:
+        """
+        packet["imus"] is a structured numpy array with the following dtype:
+            [
+                ("t", "<u8"),
+                ("temperature", "<f4"),
+                ("accelerometer_x", "<f4"),
+                ("accelerometer_y", "<f4"),
+                ("accelerometer_z", "<f4"),
+                ("gyroscope_x", "<f4"),
+                ("gyroscope_y", "<f4"),
+                ("gyroscope_z", "<f4"),
+                ("magnetometer_x", "<f4"),
+                ("magnetometer_y", "<f4"),
+                ("magnetometer_z", "<f4"),
+            ]
+        """
+        print("{} IMU samples".format(len(packet["imus"])))
+    elif "triggers" in packet:
+        """
+        packet["triggers"] is a structured numpy array with the following dtype:
+            [
+                ("t", "<u8"),
+                ("source", "u1"),
+            ]
+        the source value has the following meaning:
+            0: timestamp reset
+            1: external signal rising edge
+            2: external signal falling edge
+            3: external signal pulse
+            4: external generator rising edge
+            5: external generator falling edge
+            6: frame begin
+            7: frame end
+            8: exposure begin
+            9: exposure end
+        """
+        print("{} trigger events".format(len(packet["triggers"])))
+```
+
+Because the lifetime of the file handle is managed by Rust, decoder objects are not compatible with the [with](https://docs.python.org/3/reference/compound_stmts.html#with) statement. To ensure garbage collection, point the decoder variable to something else, for example `None`, when you are done using it:
+
+```py
+import aedat
+
+decoder = aedat.Decoder("/path/to/file.aedat")
+# do something with decoder
+decoder = None
+```
+
+## Install from source
+
+Local build (first run).
+
+```sh
+python3 -m venv .venv
+source .venv/bin/activate
+pip install --upgrade pip
+pip install maturin numpy
+maturin develop  # or maturin develop --release to build with optimizations
+```
+
+Local build (subsequent runs).
+
+```sh
+source .venv/bin/activate
+maturin develop  # or maturin develop --release to build with optimizations
+```
+
+After changing any of the files in _framebuffers_, one must run:
+
+```sh
+flatc --rust -o src/ flatbuffers/*.fbs
+```
+
+To format the code, run:
+
+```sh
+cargo fmt
+```
+
+# Publish
+
+1. Bump the version number in _Cargo.toml_ and _pyproject.toml_.
+
+2. Create a new release on GitHub.
+

aedat-2.2.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+aedat-2.2.0.dist-info/METADATA,sha256=wXY2pUg_yDCv17Bmkqb4O3NF7YktiAMqumLwVai6AMI,7218
+aedat-2.2.0.dist-info/WHEEL,sha256=1ZpRl7NI5FUTGBGfAoLBw2DqQx_-H3hwfjZ2VbdjU5g,95
+aedat-2.2.0.dist-info/licenses/LICENSE,sha256=fNneVkKWFh9p0XoRrDTFAXrj-VMTtlf10iqLsGGverY,1123
+aedat/__init__.py,sha256=MLUJ9eDi5oJ_gJuqmMTyw8Xb2sHGU7PqJh6_QpDMn8Y,103
+aedat/aedat.cp313-win_amd64.pyd,sha256=x10p2G2GabLr6xSRdt-omcwtd8vyvnMsdfiT6_foLl4,605184
+aedat-2.2.0.dist-info/RECORD,,

aedat-2.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.7.4)
+Root-Is-Purelib: false
+Tag: cp313-none-win_amd64

aedat-2.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 International Centre for Neuromorphic Systems
+
+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.