Struct CountMask 

pub struct CountMask { /* private fields */ }

Count-mask image (GEPT, Sec. 3.2 “Event Accumulation”, Eq. 2): a three-channel RGB encoding where red and blue hold the per-pixel positive and negative event counts and green is a binary activity mask — full scale wherever an event of either polarity landed. Timestamps are not used at all, which is what separates it from Tencode (latest polarity plus event age) and from EventCount (one plane of raw totals).

Both count planes are clipped and rescaled by a single alpha: the pct-th percentile of the non-zero counts of the two planes pooled together. A per-channel percentile would let a quiet polarity saturate against a busy one, so the joint scale is what keeps red and blue comparable.

white_frame inverts the image to a white background. The black-background default is the form downstream descriptor models are trained on; the inverted one is offered for parity with the reference renderer, not for feeding a model.

Implementations

impl CountMask

pub fn new(pct: f64, white_frame: bool) -> Self

Trait Implementations

impl Clone for CountMask

fn clone(&self) -> CountMask

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for CountMask

impl Debug for CountMask

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CountMask

fn default() -> Self

Returns the “default value” for a type.

impl Representation for CountMask

fn generate_on( &self, stream: &EventStream, device: Device, ) -> Result<EventFrame, RepresentationError>

Only the two count planes move to the GPU. The percentile that sets the scale stays on the CPU: it is O(pixels) rather than O(events), it is already the cheap half, and it is the part that has to agree with the reference NumPy pipeline bit for bit.

type Output = EventFrame

fn generate( &self, stream: &EventStream, ) -> Result<EventFrame, RepresentationError>

The reference implementation, on the CPU. Always available, always the definition of what this representation is: the GPU kernels are checked against it, not the other way round.