Struct PointCloud 

pub struct PointCloud<P: Point> { /* private fields */ }

Main point cloud container that owns point data

This structure provides ownership-based point cloud management with efficient parallel processing capabilities.

Implementations

impl<P: Point> PointCloud<P>

pub fn new() -> Self

Create a new empty point cloud

pub fn from_points(points: Vec<P>) -> Self

Create a point cloud from a vector of points

pub fn with_capacity(capacity: usize) -> Self

Create a point cloud with specified capacity

pub fn from_points_and_metadata(points: Vec<P>, metadata: Metadata) -> Self

Create a point cloud from points and metadata

pub fn len(&self) -> usize

Get the number of points

pub fn is_empty(&self) -> bool

Check if the point cloud is empty

pub fn points(&self) -> &[P]

Get a reference to the points vector

pub fn points_mut(&mut self) -> &mut Vec<P>

Get a mutable reference to the points vector

pub fn metadata(&self) -> &Metadata

Get a reference to the metadata

pub fn metadata_mut(&mut self) -> &mut Metadata

Get a mutable reference to the metadata

pub fn push(&mut self, point: P)

Add a point to the cloud

pub fn extend<I>(&mut self, points: I)

where I: IntoIterator<Item = P>,

Add multiple points to the cloud

pub fn get(&self, index: usize) -> Option<&P>

Get a point by index

pub fn get_mut(&mut self, index: usize) -> Option<&mut P>

Get a mutable reference to a point by index

pub fn remove(&mut self, index: usize) -> P

Remove a point by index

pub fn clear(&mut self)

Clear all points

pub fn reserve(&mut self, additional: usize)

Reserve capacity for additional points

pub fn shrink_to_fit(&mut self)

Shrink the capacity to fit the current number of points

pub fn iter(&self) -> Iter<'_, P>

Create an iterator over the points

pub fn iter_mut(&mut self) -> IterMut<'_, P>

Create a mutable iterator over the points

pub fn par_iter(&self) -> Iter<'_, P>

Create a parallel iterator over the points

pub fn par_iter_mut(&mut self) -> IterMut<'_, P>

Create a parallel mutable iterator over the points

pub fn filter<F>(self, predicate: F) -> Self

where F: Fn(&P) -> bool + Send + Sync,

Filter points based on a predicate

pub fn map<F, Q>(self, mapper: F) -> PointCloud<Q>

where F: Fn(P) -> Q + Send + Sync, Q: Point,

Transform points using a mapping function

pub fn bounding_box(&self) -> Option<([f32; 3], [f32; 3])>

Calculate the bounding box of the point cloud

pub fn centroid(&self) -> Option<[f32; 3]>

Calculate the centroid of the point cloud

pub fn crop(self, min_bounds: [f32; 3], max_bounds: [f32; 3]) -> Self

Crop the point cloud to a bounding box

pub fn into_shared(self) -> Arc<Self>

Convert to shared ownership using Arc

Trait Implementations

impl<P: Clone + Point> Clone for PointCloud<P>

fn clone(&self) -> PointCloud<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug + Point> Debug for PointCloud<P>

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

Formats the value using the given formatter.

impl<P: Point> Default for PointCloud<P>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, P> Deserialize<'de> for PointCloud<P>

where P: Deserialize<'de> + Point,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<P: Point> FeatureExt<P> for PointCloud<P>

fn estimate_normals(&self, search_radius: f32) -> Result<Vec<[f32; 3]>>

Estimate surface normals

impl<P: Point> FilterExt<P> for PointCloud<P>

fn voxel_downsample(self, voxel_size: f32) -> PointCloud<P>

Apply voxel downsampling

fn remove_outliers( self, k_neighbors: usize, std_dev_threshold: f32, ) -> Result<PointCloud<P>>

Remove statistical outliers

fn remove_radius_outliers( self, radius: f32, min_neighbors: usize, ) -> PointCloud<P>

Remove radius outliers

fn pass_through( self, axis: Axis, min_value: f32, max_value: f32, ) -> PointCloud<P>

Apply pass-through filter

impl<P: Point> FromIterator<P> for PointCloud<P>

fn from_iter<I: IntoIterator<Item = P>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, P: Point> IntoIterator for &'a PointCloud<P>

type Item = &'a P

The type of the elements being iterated over.

type IntoIter = Iter<'a, P>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, P: Point> IntoIterator for &'a mut PointCloud<P>

type Item = &'a mut P

The type of the elements being iterated over.

type IntoIter = IterMut<'a, P>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<P: Point> IntoIterator for PointCloud<P>

type Item = P

The type of the elements being iterated over.

type IntoIter = IntoIter<P>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<P: Point> RegistrationExt<P> for PointCloud<P>

fn icp_register( &self, target: &PointCloud<P>, max_iterations: usize, tolerance: f32, ) -> Result<Transform>

Perform ICP registration with another point cloud

fn transform(self, transform: &Transform) -> PointCloud<P>

Apply transformation to the point cloud

impl<P: Point> SegmentationExt<P> for PointCloud<P>

fn euclidean_cluster( &self, tolerance: f32, min_size: usize, max_size: usize, ) -> Vec<Vec<usize>>

Perform Euclidean clustering

fn ransac_plane( &self, distance_threshold: f32, max_iterations: usize, ) -> Result<(Vec<usize>, [f32; 4])>

Perform RANSAC plane segmentation

impl<P> Serialize for PointCloud<P>

where P: Serialize + Point,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.