RAW File Loading

In this tutorial you will learn how to open RAW or DAT files using the metavision_core.event_io.RawReader and metavision_core.event_io.EventDatReader classes.

import os
import numpy as np

from metavision_core.event_io.raw_reader import RawReader
from metavision_core.event_io.py_reader import EventDatReader

Opening a File

Opening a RAW or DAT file is as easy as creating a new RawReader or EventDatReader passing the path of the file. Printing the created object will show some metadata about the reading status, such as the current index time and position.

Note how RAW files and DAT files contain different metadata.

input_path_raw = "spinner.raw"
input_path_dat = "spinner.dat"
# if the file doesn't exist, it will be downloaded from Prophesee's public sample server
from metavision_core.utils import get_sample

get_sample(input_path_raw, folder=".")
get_sample(input_path_dat, folder=".")

Here is an example of openning a RAW file.

# open a file
record_raw = RawReader(input_path_raw)
print(record_raw)  # show some metadata
RawReader(spinner.raw)
current time : 0us done : False
current event index : 0
_begin_buffer 0,_end_buffer_ 0,  buffer_size 100000000

Here is an example of openning a DAT file.

record_dat = EventDatReader(input_path_dat)
print(record_dat)
DatReader: spinner.dat
-----------
Event Type: EventCD
Event Size: 8 bytes
Event Count: 54165303
Duration: 5.002329 s
-----------

Getting the Events

Now that the reader is created, we can get the events. This is done in the same way for both RAW and DAT files. Here we show an example using the RAW file, but the same can be done using the DAT file.

There are two ways to read events:

  • by number of events, using the load_n_events() function

  • by time slices, using the load_delta_t() function

events = record_raw.load_n_events(10)  # load the 10 next events
events_by_time = record_raw.load_delta_t(10000)  # load the next 10ms of data

print(events)
[(237, 121, 1, 0) (246, 121, 1, 0) (248, 132, 1, 0) (239, 133, 1, 0)
 (256, 134, 1, 0) (248, 135, 1, 0) (238, 129, 1, 1) (239, 129, 1, 1)
 (258, 129, 1, 1) (250, 128, 1, 1)]

Events are stored in a numpy structured array. This means you can conveniently access each attribute of the events (\(x\),\(y\), polarity \(p\) and timestamp \(t\)) as a numpy array. It also allows to use native numpy operators such as slicing or boolean masking

# we can access different fields in this one dimensional array
print(events['t'])  # this shows only the timestamps of events
# for instance, to count the events of positive polarity you can do:
np.sum(events['p'] == 1)
[0 0 0 0 0 0 1 1 1 1]
10
# let's randomly select some events
np.random.choice(events, len(events)//2)
array([(239, 133, 1, 0), (238, 129, 1, 1), (250, 128, 1, 1),
       (258, 129, 1, 1), (238, 129, 1, 1)],
      dtype={'names':['x','y','p','t'], 'formats':['<u2','<u2','<i2','<i8'], 'offsets':[0,2,4,8], 'itemsize':16})

Iteration

The two functions load_n_events() and load_delta_t() can be used to read all events in a file using a while loop.

sums = 0
#  load 10M events by batches of 50ms:
while not record_raw.is_done() and record_raw.current_event_index() < 1E7:
    # load the next 50 ms worth of events
    events = record_raw.load_delta_t(50000)
    sums += events.size
print("Event count: {}".format(sums))
print(record_raw)
Event count: 10333420
RawReader(spinner.raw)
current time : 960001us done : False
current event index : 10443584
_begin_buffer 10443584,_end_buffer_ 10881430,  buffer_size 100000000

You can restart from the beginning by calling the reset function. Note how all attributes are reset, and the event timestamps are the same as the first ones above.

record_raw.reset()
print(record_raw)
RawReader(spinner.raw)
current time : 0us done : False
current event index : 0
_begin_buffer 0,_end_buffer_ 0,  buffer_size 100000000

Visualization

We can visualize events using a function that will prepare an image from the numpy array of events.

Then we can display this image using standard visualization tools, such as Matplotlib.

def viz_events(events, height, width):
    img = np.full((height, width, 3), 128, dtype=np.uint8)
    img[events['y'], events['x']] = 255 * events['p'][:, None]
    return img
%matplotlib inline
from matplotlib import pyplot as plt  # graphic library, for plots

height, width = record_raw.get_size()

# load the next 50 ms worth of events
events = record_raw.load_delta_t(50000)
im = viz_events(events, height, width)

plt.imshow(im)
plt.tight_layout()
../../../../_images/raw_dat_loading_22_0.png

Note

This tutorial was created using Jupiter Notebooks

Download the source code.