SDK Analytics Algorithms¶

class Metavision::CountingAlgorithm¶

Class to count objects using Metavision Counting API.

Public Types

using OutputCb = std::function<void(const OutputEvent&)>¶: Type of the callback to access the last count.

Public Functions

CountingAlgorithm(int width, int height, const CountingAlgorithmConfig &config)¶

Constructor.

Parameters

width: Sensor’s width (in pixels)
height: Sensor’s height (in pixels)
config: Counting configuration

~CountingAlgorithm()¶: Default destructor.

void add_line_counter(int row)¶

Adds a new line to count objects.

Parameters

row: Specifies which row (y coordinate in pixels) is used to count

template<typename InputIt> void process_events(InputIt it_begin, InputIt it_last)¶

Processes a buffer of events.

Parameters

it_begin: The first element of the buffer of events
it_last: The last element of the buffer of events

void set_output_callback(const OutputCb &output_cb)¶

Function to pass a callback to get the last count.

Parameters

output_cb: Function to call

void reset_counters()¶: Resets the count of all lines.

template<typename T, typename V, V T::* v, typename precision_type = float> class Metavision::DominantValueEventsAlgorithm¶

Class computing the dominant value of an event’s field from an events batch.

Template Parameters

T: Type for which the dominant value of one of its fields will be estimated
V: Type of the field from which the dominant value is extracted
v: Address in T of the field from which the dominant value is extracted
precision_type: Return type of the dominant value, used to define the type of the boundaries of the histogram bins

Public Functions

DominantValueEventsAlgorithm(precision_type min_val, precision_type max_val, precision_type precision_val, unsigned int min_count)¶

Constructor.

We split the range [ min_val, max_val ] to get values spaced by precision_val . Bins are centered around these values and are of a width that ensures that consecutive bins touch each other. For example, given the range [3, 5] and precision_val = 1, it will compute the bin centers {3, 4, 5}, the boundaries of which are given by {2.5, 3.5, 4.5, 5.5}

Note

The histogram bins are initialized during the class construction and won’t change dynamically.

Parameters

min_val: Minimum included value (lower bound of the histogram bins)
max_val: Maximum included value (upper bound of the histogram bins)
precision_val: Width of the bins of the histogram (same unit as the value to estimate)
min_count: Minimum size of a given bin in the histogram to be eligible as dominant

template<typename InputIt> bool compute_dominant_value(InputIt begin, InputIt end, precision_type &output_dominant_value)¶

Computes the dominant value from a batch of events.

Return

false if none of the bins were sufficiently filled with respect to the count criterion

Template Parameters

InputIt: An iterator type over an event of type T

Parameters

begin: First iterator of the T events buffer to process
end: End iterator of the T events buffer to process
output_dominant_value: Peak of the histogram of the values contained between begin and end

template<typename precision_type = float> class Metavision::DominantValueMapAlgorithm¶

Class computing the dominant value of a map.

Template Parameters

precision_type: Return type of the dominant value, used to define the type of the boundaries of the histogram bins

Public Functions

DominantValueMapAlgorithm(precision_type min_val, precision_type max_val, precision_type precision_val, unsigned int min_count)¶

Constructor.

We split the range [ min_val, max_val ] to get values spaced apart by precision_val . Bins are centered around these values and are of width step so that consecutive bins touch each other. For example, given the range [3, 5] and precision_val = 1, it will compute the bin centers {3, 4, 5}, the boundaries of which are given by {2.5, 3.5, 4.5, 5.5}

Note

The histogram bins are initialized during the class construction and won’t change dynamically.

Parameters

min_val: Minimum included value (lower bound of the histogram bins)
max_val: Maximum included value (upper bound of the histogram bins)
precision_val: Width of the bins of the histogram (same unit as the value to estimate)
min_count: Minimum size of a given bin in the histogram to be eligible as dominant

~DominantValueMapAlgorithm() = default¶: Destructor.

bool compute_dominant_value(const cv::Mat &value_map, precision_type &output_dominant_value)¶

Computes the dominant value from a value map.

Return

false if none of the bins were sufficiently filled with respect to the count criterion

Parameters

value_map: Input map containing values
output_dominant_value: Peak of the histogram of the values contained in value_map

class Metavision::FrequencyMapAsyncAlgorithm¶

Class that estimates the pixel-wise frequency of vibrating objects using Metavision Vibration API.

Public Types

using OutputCb = std::function<void(timestamp, OutputMap&)>¶: Type of the callback to access the period map.

Public Functions

FrequencyMapAsyncAlgorithm(int width, int height, const FrequencyEstimationConfig &frequency_config)¶

Builds a new FrequencyMapAsyncAlgorithm object.

Parameters

width: Sensor’s width in pixels
height: Sensor’s height in pixels
frequency_config: Frequency estimation configuration

~FrequencyMapAsyncAlgorithm()¶: Default destructor.

void set_output_callback(const OutputCb &output_cb)¶

Sets a callback to get the output frequency map.

Parameters

output_cb: Callback to call

void set_update_frequency(const float freq)¶

Sets the frequency at which the algorithm generates the frequency map.

Parameters

freq: Frequency at which the frequency map will be generated

template<typename InputIt> void process_events(InputIt it_begin, InputIt it_last)¶

Processes a buffer of events.

Parameters

it_begin: First element of the buffer
it_last: Last element of the buffer

class Metavision::HeatMapFrameGeneratorAlgorithm¶

Class that produces a BGR image of a floating point value map.

A colormap bar at the bottom of the image shows the color convention. Pixels for which a value was not computed are shown in black. Also pixels outside the defined minimum/maximum values are shown in black too.

Public Types

using float_type = float¶: Type of foating point values.

Public Functions

HeatMapFrameGeneratorAlgorithm(float_type min_value, float_type max_value, float_type value_precision, int width, int height, const std::string &unit_str = std::string(), unsigned int cmap = cv::COLORMAP_JET, bool do_invert_cmap = true)¶

Constructor.

Parameters

min_value: Minimum value
max_value: Maximum value
value_precision: Precision used to determine the number of decimal digits to display (0.5, 0.01, …)
width: Sensor’s width (in pixels)
height: Sensor’s height (in pixels)
unit_str: String representation of the values’s unit, e.g. Hz, us, m/s …
cmap: Colormap used to colorize the value map
do_invert_cmap: Flip the uchar values before applying the color map

~HeatMapFrameGeneratorAlgorithm() = default¶: Destructor.

void generate_bgr_heat_map(const cv::Mat &value_map, cv::Mat &out_image_bgr)¶

Draws the value map with a bar showing the colormap convention.

Parameters

value_map: Input value map, 1 floating point channel (CV_32SC1)
out_image_bgr: Output image

template<typename T, typename F, F T::* f> class Metavision::MapGeneratorAsyncAlgorithm : public Metavision::AsyncAlgorithm<MapGeneratorAsyncAlgorithm<T, F, f>>¶

Class that accumulates events in a map.

More specifically, this class accumulates one of the event’s fields in a map. Each map’s cell contains the last value of that field at that location. Under the hood this class uses the OpenCV’s Mat_<T> structure, meaning that it is only compatible with the types for which the Mat_<T> structure is compatible too (i.e. uchar, short, ushort, int, float and double). This class is not compatible with OpenCV’s vector types (i.e. instantiations of the Vec<T, int cn> class).

Template Parameters

T: Type, one of the fields of which will be accumulated in the map
F: Type of the field that will be accumulated in the map
f: Address in T of the field to be accumulated

Public Functions

MapGeneratorAsyncAlgorithm(int width, int height)¶

Builds a new MapGeneratorAsyncAlgorithm object.

Parameters

width: Sensor’s width (in pixels)
height: Sensor’s height (in pixels)

~MapGeneratorAsyncAlgorithm() = default¶: Default destructor.

void set_output_callback(const OutputCb &cb)¶

Sets the callback that will be called to let the user retrieve the generated map.

The generated map will be passed through the callback via a non constant reference, meaning that the client is free to copy it or swap it.

Note

In case of a swap with a non initialized map, it will automatically be initialized by the MapGeneratorAsyncAlgorithm.

Parameters

cb: The callback to call

class Metavision::PeriodMapAsyncAlgorithm¶

Class that estimates the pixel-wise period of vibrating objects using Metavision Vibration API.

Public Types

using OutputCb = std::function<void(timestamp, OutputMap&)>¶: Type of the callback to access the period map.

Public Functions

PeriodMapAsyncAlgorithm(int width, int height, const PeriodEstimationConfig &period_map_async_config)¶

Builds a new PeriodMapAsyncAlgorithm object.

Parameters

width: Sensor’s width (in pixels)
height: Sensor’s height (in pixels)
period_map_async_config: Period estimation configuration

~PeriodMapAsyncAlgorithm()¶: Default destructor.

void set_output_callback(const OutputCb &output_cb)¶

Sets a callback to get the output period map.

Parameters

output_cb: Callback to call

void set_update_frequency(const float freq)¶

Sets the frequency at which the algorithm generates the period map.

Parameters

freq: Frequency at which the period map will be generated

template<typename InputIt> void process_events(InputIt it_begin, InputIt it_last)¶

Processes a buffer of events.

Parameters

it_begin: First element of the buffer
it_last: Last element of the buffer

class Metavision::SpatterTrackerAlgorithm¶

Class that tracks spatter clusters using Metavision SpatterTracking API.

Public Types

using TrackerCb = std::function<void(const timestamp, const std::vector<EventSpatterCluster>&)>¶: Type of the callback to access the output cluster events.

Public Functions

SpatterTrackerAlgorithm(int width, int height, const SpatterTrackerAlgorithmConfig &config)¶

Builds a new SpatterTrackerAlgorithm object.

Parameters

width: Sensor’s width (in pixels)
height: Sensor’s height (in pixels)
config: Spatter tracker’s configuration

~SpatterTrackerAlgorithm()¶: Default destructor.

void set_callback(const TrackerCb &tracker_cb)¶

Registers a callback to get the output cluster events.

Parameters

tracker_cb: Function to call

void remove_callback()¶: Removes the callback.

void set_nozone(cv::Point center, int radius)¶

Sets the region that isn’t processed.

Parameters

center: Center of the region
radius: Radius of the region

void set_write_range(const timestamp &time_from, const timestamp &time_to)¶

Sets the time to start and stop writing the outcome video.

Parameters

time_from: Timestamp to start writing the outcome video
time_to: Timestamp to stop writing the outcome video

int get_cluster_count() const¶

Returns the current number of clusters.

Return: The current number of clusters

template<typename InputIt> void process_events(InputIt it_begin, InputIt it_last)¶

Function to process events. The callback will be called when necessary.

Parameters

it_begin: First iterator of the buffer
it_last: Last iterator of the buffer

class Metavision::TrackingAlgorithm¶

Class that tracks objects using Metavision Tracking API.

Public Functions

TrackingAlgorithm(int sensor_width, int sensor_height, TrackingConfig &config)¶

Builds a new TrackingAlgorithm object.

Parameters

sensor_width: Sensor’s width.
sensor_height: Sensor’s height.
config: Tracking’s configuration.

~TrackingAlgorithm()¶: Default Destructor.

void set_output_callback(const OutputCb &output_cb)¶

Sets a callback to retrieve the list of tracked objects (see EventTrackingData) when the tracker is updated (see set_update_frequency).

Note

The generated vector will be passed to the callback as a non constant reference, meaning that the client is free to copy it or swap it. In case of a swap, the swapped vector will be automatically cleaned.

Parameters

output_cb: Function to call

std::uint16_t get_min_size() const¶: Gets the size of the smallest trackable object.

std::uint16_t get_max_size() const¶: Gets the size of the biggest trackable object.

float get_min_speed() const¶: Gets the speed of the slowest trackable object.

float get_max_speed() const¶: Gets the speed of the fastest trackable object.

void set_min_size(std::uint16_t min_size)¶

Sets the size of the smallest trackable object.

Parameters

min_size: Size of the smallest object (in pixels)

void set_max_size(std::uint16_t max_size)¶

Sets the size of the biggest trackable object.

Parameters

max_size: Size of the biggest object (in pixels)

void set_min_speed(float min_speed)¶

Sets the speed of the slowest trackable object.

Parameters

min_speed: Speed of the slowest object

void set_max_speed(float max_speed)¶

Sets the speed of the fastest trackable object.

Parameters

max_speed: Speed of the fastest object

void set_update_frequency(float freq)¶

Sets the frequency at which the algorithm generates the output.

Parameters

freq: Frequency to generate the output

template<typename InputIt> void process(InputIt first, InputIt last)¶

Processes events. This method might call the output callback depending on the time slice’s size.

Parameters

first: Iterator to the first event to process
last: Iterator to the last event to process