def test_write_es_generic(self):
parsed_file = loris.read_file(examples_path_es + 'generic.es')
new_file = 'new_generic.es'
loris.write_events_to_file(parsed_file, new_file)
self.assertEqual(os.path.getsize(new_file),
os.path.getsize(examples_path_es + 'generic.es'))
os.remove(new_file)
def poker_to_es(filepath_in, filepath_out, verbose=False):
""" Converts a file from the POKER-DVS dataset into the .es format with dimensions 35x35"""
if filepath_in.split('.')[1] == 'dat':
# create the output directory if it doesn't exist
basepath_out = os.path.dirname(filepath_out)
if not os.path.exists(basepath_out):
os.makedirs(basepath_out)
# read file
data = loris.read_file(filepath_in)
# parse data according to the POKER-DVS specs
data['width'] = 35
data['height'] = 35
for event in data['events']:
event[2] = 239 - event[2]
# write to es
loris.write_events_to_file(data, filepath_out)
else:
if verbose:
print(filepath_in, "is not an accepted file")
def test_write_es_atis(self):
file_atis = loris.read_file(examples_path_es + 'atis.es')
new_file = 'new_atis.es'
loris.write_events_to_file(file_atis, new_file)
self.assertEqual(os.path.getsize(new_file),
os.path.getsize(examples_path_es + 'atis.es'))
os.remove(new_file)
def __getitem__(self, index):
events = loris.read_file(self.samples[index])["events"]
events = np.array(structured_to_unstructured(events, dtype=np.float))
events[:, 2] -= self.minimum_y_value
target = self.targets[index]
if self.transform is not None:
events = self.transform(events, self.sensor_size, self.ordering)
if self.target_transform is not None:
target = self.target_transform(target)
return events, target
def __getitem__(self, index):
events, target = loris.read_file(
self.samples[index]), self.targets[index]
events = numpy.lib.recfunctions.structured_to_unstructured(
events["events"], dtype=numpy.float)
if self.transform is not None:
events = self.transform(events, self.sensor_size, self.ordering)
if self.target_transform is not None:
target = self.target_transform(target)
return events, target
def read_aedat4(in_file):
import loris
"""
Get the aer events from version 4 of .aedat file
Args:
in_file: str The name of the .aedat file
Returns:
xytp: numpy structured array of events
"""
event_data = loris.read_file(in_file)
events = event_data["events"]
return events
def read_bin(file_name: str):
'''
:param file_name: NavGesture原始bin格式数据的文件名
:return: 一个字典，键是{'t', 'x', 'y', 'p'}，值是np数组
原始的NavGesture提供的是bin格式数据，不能直接读取。本函数提供了一个读取的接口。
原始数据以二进制存储：
Events are encoded in binary format on 64 bits (8 bytes):
32 bits for timestamp
9 bits for x address
8 bits for y address
2 bits for polarity
13 bits padding
'''
txyp = loris.read_file(file_name)['events']
# txyp.p是bool类型，转换成int
return {'t': txyp.t, 'x': txyp.x, 'y': txyp.y, 'p': txyp.p.astype(int)}
def inject_spikes(self, data):
# if a container is given then convert that to deque
if isinstance(data, (list, np.ndarray)):
self.spikes = np.array(data)
# if string is given then load data
elif isinstance(data, str):
# handles .es files containing events with the format (t,x,y,p)
if data_path.endswith('.es'):
data_file = loris.read_file(data_path)
for event in data_file['events']:
self.spikes.append(
[event.t, event.x + data_file['width'] * event.y])
self.spikes = np.array(self.spikes)
# handles .npy files containing numpy arrays with the format (t,neuron_idx)
elif data_path.endswith('.npy'):
self.spikes = np.load(data_path)
else:
raise Exception("unsupported data format")
def ncar_to_es(filepath_in, filepath_out, verbose=False):
if filepath_in.split('.')[1] == 'dat':
# create the output directory if it doesn't exist
basepath_out = os.path.dirname(filepath_out)
if not os.path.exists(basepath_out):
os.makedirs(basepath_out)
# read file
data = loris.read_file(filepath_in)
# parse data according to the N-CAR specs
data['width'] = 64
data['height'] = 56
for event in data['events']:
event[2] = 55 - event[2]
# write to es
loris.write_events_to_file(data, filepath_out)
else:
if verbose:
print(filepath_in, "is not an accepted file")
def test_read_dat_without_td_in_filename(self):
parsed_file = loris.read_file(examples_path + 'user01_do_3.dat')
events = parsed_file['events']
self.assertEqual(len(events), 723759)
self.assertEqual(parsed_file['type'], 'dvs')
def test_read_dat_v2_dvs(self):
parsed_file = loris.read_file(examples_path +
'NCARS_obj_004397_td.dat')
events = parsed_file['events']
self.assertEqual(len(events), 4407)
self.assertEqual(parsed_file['type'], 'dvs')
def test_read_aedat4(self):
parsed_file = loris.read_file(examples_path + 'parramatta.aedat4')
events = parsed_file['events']
self.assertEqual(len(events), 78830)
self.assertEqual(parsed_file['type'], 'dvs')
def test_write_dvs_from_event_array_xytp(self):
new_file = 'new_dvs.es'
loris.write_events_to_file(self.event_array_xytp, new_file,
self.ordering_xytp)
parsed_file = loris.read_file(new_file)
self.assertEqual(len(parsed_file['events']), 10000)
def test_read_es_atis(self):
file_atis = loris.read_file(examples_path_es + 'atis.es')
self.assertEqual(1326017, len(file_atis['events']))
self.assertEqual('atis', file_atis['type'])
def test_read_es_generic(self):
file_generic = loris.read_file(examples_path_es + 'generic.es')
self.assertEqual(70, len(file_generic['events']))
self.assertEqual('generic', file_generic['type'])
def test_read_es_dvs(self):
file_dvs = loris.read_file(examples_path_es + 'dvs.es')
self.assertEqual(473225, len(file_dvs['events']))
self.assertEqual('dvs', file_dvs['type'])
def test_read_es_color(self):
file_color = loris.read_file(examples_path_es + 'color.es')
self.assertEqual(473225, len(file_color['events']))
self.assertEqual('color', file_color['type'])
def test_write_dvs_from_event_array_txyp_without_ordering(self):
new_file = 'new_dvs.es'
loris.write_events_to_file(self.event_array_txyp, new_file)
parsed_file = loris.read_file(new_file)
self.assertEqual(len(parsed_file['events']), 10000)
import argparse
import loris
parser = argparse.ArgumentParser(
description=
'Fix tcommon issues in recorded files, and mnormalize the timestamps')
parser.add_argument('input', type=str, help='the input .es file')
parser.add_argument('output', type=str, help='the output .es file')
arguments = parser.parse_args()
if arguments.input == arguments.output:
raise Exception('the input and output files must be different')
stream = loris.read_file(arguments.input)
if len(stream['events']) > 0:
previous_t = stream['events'][0][0]
for index in range(1, 1000):
t = stream['events'][index][0]
if t - previous_t > 1000000:
stream['events'] = stream['events'][index:]
break
previous_t = t
stream['events']['ts'] -= stream['events'][0][0]
loris.write_events_to_file(stream, arguments.output)
