Enum GateGeometry 

pub enum GateGeometry {
    Polygon {
        nodes: Vec<GateNode>,
        closed: bool,
    },
    Rectangle {
        min: GateNode,
        max: GateNode,
    },
    Ellipse {
        center: GateNode,
        radius_x: f32,
        radius_y: f32,
        angle: f32,
    },
    Boolean {
        operation: BooleanOperation,
        operands: Vec<Arc<str>>,
    },
}

The geometry of a gate, defining its shape in 2D parameter space.

Gates can be one of four geometric types:

• Polygon: A closed or open polygonal region defined by vertices
• Rectangle: An axis-aligned rectangular region
• Ellipse: An elliptical region with optional rotation
• Boolean: A combination of other gates using boolean operations (AND, OR, NOT)

All geometries operate in raw data coordinate space and are parameterized by two channel names (x and y parameters).

Example

use flow_gates::{GateGeometry, GateNode};

// Create a rectangle gate
let min = GateNode::new("min")
    .with_coordinate("FSC-A", 100.0)
    .with_coordinate("SSC-A", 200.0);
let max = GateNode::new("max")
    .with_coordinate("FSC-A", 500.0)
    .with_coordinate("SSC-A", 600.0);

let geometry = GateGeometry::Rectangle { min, max };

// Check if a point is inside
let inside = geometry.contains_point(300.0, 400.0, "FSC-A", "SSC-A")?;

Variants

Polygon

Fields

nodes: Vec<GateNode>

closed: bool

Rectangle

Fields

min: GateNode

max: GateNode

Ellipse

Fields

center: GateNode

radius_x: f32

radius_y: f32

angle: f32

Boolean

Boolean gate combining other gates with logical operations

Boolean gates reference other gates by ID and combine their results using AND, OR, or NOT operations. The referenced gates must be resolved externally when filtering events.

Fields

operation: BooleanOperation

The boolean operation to apply

operands: Vec<Arc<str>>

IDs of the gates to combine (gate IDs, not the gates themselves)

Implementations

impl GateGeometry

pub fn bounding_box( &self, x_param: &str, y_param: &str, ) -> Option<(f32, f32, f32, f32)>

Calculate the bounding box for this geometry in the specified parameter space

pub fn calculate_center( &self, x_param: &str, y_param: &str, ) -> Result<(f32, f32)>

Calculate the center point in raw data coordinates

pub fn contains_point( &self, x: f32, y: f32, x_param: &str, y_param: &str, ) -> Result<bool>

Check if a point (in raw coordinates) is inside the gate

pub fn contains_points_batch( &self, points: &[(f32, f32)], x_param: &str, y_param: &str, ) -> Result<Vec<bool>>

Batch check if points (in raw coordinates) are inside the gate

Uses optimized CPU-based batch filtering with Rayon parallelization.

pub fn is_valid(&self, x_param: &str, y_param: &str) -> Result<bool>

Check if the gate has valid geometry and coordinates

pub fn gate_type_name(&self) -> &'static str

Get a descriptive name for this gate type

Trait Implementations

impl Clone for GateGeometry

fn clone(&self) -> GateGeometry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GateGeometry

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GateGeometry

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl GateBounds for GateGeometry

fn bounding_box( &self, x_param: &str, y_param: &str, ) -> Result<(f32, f32, f32, f32)>

Calculate the bounding box (min_x, min_y, max_x, max_y) in raw coordinates

impl GateCenter for GateGeometry

fn calculate_center(&self, x_param: &str, y_param: &str) -> Result<(f32, f32)>

Calculate the center point in raw data coordinates

impl GateContainment for GateGeometry

fn contains_point( &self, x: f32, y: f32, x_param: &str, y_param: &str, ) -> Result<bool>

Check if a point (in raw coordinates) is inside the gate

impl GateGeometryOps for GateGeometry

fn gate_type_name(&self) -> &'static str

Get a descriptive name for this gate type

impl GateValidation for GateGeometry

fn is_valid(&self, x_param: &str, y_param: &str) -> Result<bool>

Check if the gate has valid geometry and coordinates

impl Serialize for GateGeometry

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.