def testToAveragedTimesurfaceXytp(self, ordering):
(
orig_events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
cell_size = 10
surface_size = 5
temporal_window = 100
tau = 100
merge_polarities = True
surfaces = F.to_averaged_timesurface(
events=orig_events.copy(),
sensor_size=sensor_size,
ordering=ordering,
cell_size=cell_size,
surface_size=surface_size,
temporal_window=temporal_window,
tau=tau,
merge_polarities=merge_polarities,
)
self.assertEqual(surfaces.shape[0], len(orig_events))
self.assertEqual(surfaces.shape[1], 1)
self.assertEqual(surfaces.shape[2], surface_size)
def testFlipPolarity(self, ordering, flip_probability):
(
orig_events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
events = F.flip_polarity_numpy(
orig_events.copy(),
ordering=ordering,
flip_probability=flip_probability,
)
x_index, y_index, t_index, p_index = self.findXytpPermutation(ordering)
if flip_probability == 1:
self.assertTrue(
np.array_equal(orig_events[:, p_index] * -1, events[:,
p_index]),
"When flipping polarity with probability 1, all event polarities must"
" flip",
)
else:
self.assertTrue(
np.array_equal(orig_events[:, p_index], events[:, p_index]),
"When flipping polarity with probability 0, no event polarities must"
" flip",
)
def testStTransform(self, ordering):
(
orig_events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
spatial_transform = np.array(((1, 0, 10), (0, 1, 10), (0, 0, 1)))
temporal_transform = np.array((2, 0))
events = F.st_transform(
orig_events.copy(),
sensor_size=sensor_size,
ordering=ordering,
spatial_transform=spatial_transform,
temporal_transform=temporal_transform,
roll=False,
)
x_index, y_index, t_index, p_index = self.findXytpPermutation(ordering)
self.assertTrue(
np.all(events[:, x_index]) < sensor_size[0]
and np.all(events[:, y_index] < sensor_size[1]),
"Transformation does not map beyond sensor size",
)
def testRefractoryPeriod(self, ordering, refractory_period):
(
orig_events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
events = F.refractory_period_numpy(
events=orig_events,
sensor_size=sensor_size,
ordering=ordering,
refractory_period=refractory_period,
)
self.assertTrue(len(events) > 0, "Not all events should be filtered")
self.assertTrue(
len(events) < len(orig_events),
"Result should be fewer events than original event stream",
)
self.assertTrue(
np.isin(events, orig_events).all(),
"Added additional events that were not present in original event stream",
)
self.assertTrue(events.dtype == events.dtype)
def testSpatialJitter(self, ordering, variance):
(
orig_events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
events = F.spatial_jitter_numpy(
orig_events.copy(),
sensor_size=sensor_size,
ordering=ordering,
variance_x=variance,
variance_y=variance,
sigma_x_y=0,
integer_coordinates=False,
clip_outliers=False,
)
x_index, y_index, t_index, p_index = self.findXytpPermutation(ordering)
self.assertTrue(len(events) == len(orig_events))
self.assertTrue((events[:, t_index] == orig_events[:, t_index]).all())
self.assertTrue((events[:, p_index] == orig_events[:, p_index]).all())
self.assertFalse((events[:, x_index] == orig_events[:, x_index]).all())
self.assertFalse((events[:, y_index] == orig_events[:, y_index]).all())
self.assertTrue(
np.isclose(events[:, x_index].all(),
orig_events[:, x_index].all(),
atol=variance))
self.assertTrue(
np.isclose(events[:, y_index].all(),
orig_events[:, y_index].all(),
atol=variance))
def testCrop(self, ordering, target_size):
(
events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
events, images = F.crop_numpy(
events,
images=images,
sensor_size=sensor_size,
ordering=ordering,
multi_image=is_multi_image,
target_size=target_size,
)
x_index, y_index, t_index, p_index = self.findXytpPermutation(ordering)
self.assertTrue(
np.all(events[:, x_index]) < target_size[0]
and np.all(events[:, y_index] < target_size[1]),
"Cropping needs to map the events into the new space",
)
self.assertTrue(
images.shape[2] == target_size[0]
and images.shape[1] == target_size[1],
"Cropping needs to map the images into the new space",
)
def testDenoise(self, ordering, filter_time):
(
orig_events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
events = F.denoise_numpy(
orig_events,
sensor_size=sensor_size,
ordering=ordering,
filter_time=filter_time,
)
self.assertTrue(len(events) > 0, "Not all events should be filtered")
self.assertTrue(
len(events) < len(orig_events),
"Result should be fewer events than original event stream",
)
self.assertTrue(
np.isin(events, orig_events).all(),
"Denoising should not add additional events that were not present in"
" original event stream",
)
def testTimeReversal(self, ordering, flip_probability):
(
orig_events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
x_index, y_index, t_index, p_index = self.findXytpPermutation(ordering)
original_t = orig_events[0, t_index]
original_p = orig_events[0, p_index]
max_t = np.max(orig_events[:, t_index])
events, images = F.time_reversal_numpy(
orig_events,
images=images,
sensor_size=sensor_size,
ordering=ordering,
multi_image=is_multi_image,
flip_probability=flip_probability,
)
same_time = np.isclose(max_t - original_t, events[0, t_index])
same_polarity = np.isclose(events[0, p_index], -1.0 * original_p)
self.assertTrue(same_time,
"When flipping time must map t_i' = max(t) - t_i")
self.assertTrue(same_polarity,
"When flipping time polarity should be flipped")
self.assertTrue(events.dtype == events.dtype)
def testUniformNoiseXytp(self, ordering):
(
orig_events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
noisy_events = F.uniform_noise_numpy(
orig_events.copy(),
sensor_size=sensor_size,
ordering=ordering,
scaling_factor_to_micro_sec=1000000,
noise_density=1e-8,
)
self.assertTrue(len(noisy_events) > len(orig_events))
self.assertTrue(np.isin(orig_events, noisy_events).all())
def testToTimesurface(self, ordering, surface_dimensions, tau):
(
orig_events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
merge_polarities = True
surfaces = F.to_timesurface_numpy(
events=orig_events.copy(),
sensor_size=sensor_size,
ordering=ordering,
surface_dimensions=surface_dimensions,
tau=tau,
merge_polarities=merge_polarities,
)
self.assertEqual(surfaces.shape[0], len(orig_events))
self.assertEqual(surfaces.shape[1], 1)
self.assertEqual(surfaces.shape[2:], surface_dimensions)
def testTimeJitter(self, ordering, variance):
(
orig_events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
events = F.time_jitter_numpy(
orig_events.copy(),
ordering=ordering,
variance=variance,
integer_timestamps=False,
clip_negative=False,
)
x_index, y_index, t_index, p_index = self.findXytpPermutation(ordering)
self.assertTrue(len(events) == len(orig_events))
self.assertTrue((events[:, x_index] == orig_events[:, x_index]).all())
self.assertTrue((events[:, y_index] == orig_events[:, y_index]).all())
self.assertFalse((events[:, t_index] == orig_events[:, t_index]).all())
self.assertTrue((events[:, p_index] == orig_events[:, p_index]).all())
def testFlipLR(self, ordering, flip_probability):
(
orig_events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
events, images = F.flip_lr_numpy(
orig_events.copy(),
images=images,
sensor_size=sensor_size,
ordering=ordering,
multi_image=is_multi_image,
flip_probability=flip_probability,
)
x_index, y_index, t_index, p_index = self.findXytpPermutation(ordering)
self.assertTrue(
((sensor_size[0] - 1) -
orig_events[:, x_index] == events[:, x_index]).all(),
"When flipping left and right x must map to the opposite pixel, i.e. x' ="
" sensor width - x",
)
def testToRatecodedFrame(self, ordering, frame_time):
(
orig_events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
x_index, y_index, t_index, p_index = self.findXytpPermutation(ordering)
frames = F.to_ratecoded_frame_numpy(
events=orig_events.copy(),
sensor_size=sensor_size,
ordering=ordering,
frame_time=frame_time,
)
self.assertEqual(
frames.shape,
(
math.ceil(orig_events[-1, t_index] / frame_time),
sensor_size[1],
sensor_size[0],
),
)
def testTimeSkew(self, ordering, offset, coefficient):
(
orig_events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
x_index, y_index, t_index, p_index = self.findXytpPermutation(ordering)
events = F.time_skew_numpy(
orig_events.copy(),
ordering=ordering,
coefficient=coefficient,
offset=offset,
)
self.assertTrue(len(events) == len(orig_events))
self.assertTrue(np.min(events[:, t_index]) >= offset)
if coefficient > 1:
self.assertTrue(
(events[:, t_index] - offset > orig_events[:, t_index]).all())
elif coefficient < 1:
self.assertTrue(
(events[:, t_index] - offset < orig_events[:, t_index]).all())
def testDropEvents(self, ordering, drop_probability,
random_drop_probability):
(
orig_events,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
events = F.drop_events_numpy(
orig_events.copy(),
drop_probability=drop_probability,
random_drop_probability=random_drop_probability,
)
x_index, y_index, t_index, p_index = self.findXytpPermutation(ordering)
if random_drop_probability:
self.assertTrue(
events.shape[0] >=
(1 - drop_probability) * orig_events.shape[0],
"Event dropout with random drop probability should result in less than"
" drop_probability*len(original) events dropped out.",
)
else:
self.assertTrue(
np.isclose(
events.shape[0],
(1 - drop_probability) * orig_events.shape[0],
),
"Event dropout should result in drop_probability*len(original) events"
" dropped out.",
)
self.assertTrue(
np.isclose(
np.sum((events[:, t_index] - np.sort(events[:, t_index]))**2),
0),
"Event dropout should maintain temporal order.",
)
def testMixEvents(self, ordering):
(
stream1,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
(
stream2,
images,
sensor_size,
is_multi_image,
) = utils.create_random_input_with_ordering(ordering)
x_index, y_index, t_index, p_index = self.findXytpPermutation(ordering)
events = (stream1, stream2)
mixed_events_no_offset, _ = F.mix_ev_streams_numpy(
events,
offsets=None,
check_conflicts=False,
sensor_size=sensor_size,
ordering=ordering,
)
mixed_events_random_offset, _ = F.mix_ev_streams_numpy(
events,
offsets="Random",
check_conflicts=False,
sensor_size=sensor_size,
ordering=ordering,
)
mixed_events_defined_offset, _ = F.mix_ev_streams_numpy(
events,
offsets=(0, 100),
check_conflicts=False,
sensor_size=sensor_size,
ordering=ordering,
)
mixed_events_conflict, num_conflicts = F.mix_ev_streams_numpy(
(stream1, stream1),
offsets=None,
check_conflicts=True,
sensor_size=sensor_size,
ordering=ordering,
)
no_offset_monotonic = np.all(
mixed_events_no_offset[1:, t_index] >=
mixed_events_no_offset[:-1, t_index],
axis=0,
)
random_offset_monotonic = np.all(
mixed_events_random_offset[1:, t_index] >=
mixed_events_random_offset[:-1, t_index],
axis=0,
)
defined_offset_monotonic = np.all(
mixed_events_defined_offset[1:, t_index] >=
mixed_events_defined_offset[:-1, t_index],
axis=0,
)
conflict_offset_monotonic = np.all(
mixed_events_conflict[1:, t_index] >=
mixed_events_conflict[:-1, t_index],
axis=0,
)
all_colisions_detected = len(stream1) == num_conflicts
self.assertTrue(
all_colisions_detected,
"Missed some event colisions, may cause processing problems.",
)
self.assertTrue(no_offset_monotonic, "Result was not monotonic.")
self.assertTrue(random_offset_monotonic, "Result was not monotonic.")
self.assertTrue(defined_offset_monotonic, "Result was not monotonic.")
self.assertTrue(conflict_offset_monotonic, "Result was not monotonic.")
def setUp(self):
self.event_array_txyp, self.sensor_size, self.ordering_txyp = create_random_input_with_ordering(
"txyp")
self.event_array_xytp, self.sensor_size, self.ordering_xytp = create_random_input_with_ordering(
"xytp")
def setUp(self):
self.ordering = "xytp"
self.random_xytp = utils.create_random_input_with_ordering(
self.ordering)
self.original_events = self.random_xytp[0].copy()
self.original_images = self.random_xytp[1].copy()
