Struct rust_3d::point_cloud_2d::PointCloud2D

pub struct PointCloud2D<P> where
    P: Is2D,  {
    pub data: Vec<Box<P>>,
}

PointCloud2D, a collection of positions within 2D space

Fields

data: Vec<Box<P>>

Methods

impl<P> PointCloud2D<P> where
    P: Is2D, 

fn new() -> PointCloud2D<P>

Creates a new, empty point cloud

fn to_str(&self) -> String

Serializes the point cloud

fn for_each_point<F>(&mut self, f: F) where
    F: FnMut(&mut P), 

Applies a function to each position

impl<P> PointCloud2D<P> where
    P: IsBuildable2D + Clone, 

fn parse(text: String) -> Result<PointCloud2D<P>>

Creates a new point cloud from an input string

Trait Implementations

impl<P> Clone for PointCloud2D<P> where
    P: Is2D + Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P> Index<usize> for PointCloud2D<P> where
    P: Is2D, 

type Output = P

The returned type after indexing

fn index(&self, i: usize) -> &P

The method for the indexing (container[index]) operation

impl<P> IndexMut<usize> for PointCloud2D<P> where
    P: Is2D, 

fn index_mut(&mut self, i: usize) -> &mut P

The method for the mutable indexing (container[index]) operation

impl<P> IsRandomAccessible<P> for PointCloud2D<P> where
    P: Is2D, 

fn len(&self) -> usize

Should return the number of elements within the collection

impl<P> IsRandomInsertible<P> for PointCloud2D<P> where
    P: Is2D, 

fn push(&mut self, point: P)

Should push an element to the end of collection

fn insert(&mut self, index: usize, point: P) -> Result<()>

Should insert an element at the given index

impl<P> IsMoveable2D for PointCloud2D<P> where
    P: Is2D + IsMoveable2D, 

fn move_by(&mut self, x: f64, y: f64)

Should move the object by the given offset

impl<P> HasBoundingBox2D for PointCloud2D<P> where
    P: Is2D, 

fn bounding_box(&self) -> Result<BoundingBox2D>

Should return the bounding box as a pair of two points. The first point should be the minimum for all coordinates, the second the maximum for all coordinates

fn min_pos(&self) -> Result<Point2D>

Returns the minimum position of the bounding box

fn max_pos(&self) -> Result<Point2D>

Returns the maximum position of the bounding box

fn size_x(&self) -> Result<f64>

Returns the size the bounding box within the x-dimension

fn size_y(&self) -> Result<f64>

Returns the size the bounding box within the y-dimension

fn center_bb(&self) -> Result<Point2D>

Returns the center of the bounding box

fn is_inside<B>(&self, other: &B) -> Result<bool> where
    Self: Sized,
    B: HasBoundingBox2D, 

Tests whether this bounding box is within the other

fn contains<P>(&self, other: &P) -> Result<bool> where
    Self: Sized,
    P: Is2D, 

Tests whether this bounding box contains a position

fn has_inside<B>(&self, other: &B) -> Result<bool> where
    Self: Sized,
    B: HasBoundingBox2D, 

Tests whether this bounding box contains the other

fn collides_with<B>(&self, other: &B) -> Result<bool> where
    Self: Sized,
    B: HasBoundingBox2D, 

Tests whether this bounding box and the other overlap in any way

impl<P> HasCenterOfGravity2D for PointCloud2D<P> where
    P: Is2D, 

fn center_of_gravity(&self) -> Result<Point2D>

Should return the center of gravity

impl<P> HasLength for PointCloud2D<P> where
    P: Is2D, 

fn length(&self) -> f64

Should return the physical length

impl<P> IsViewBuildable for PointCloud2D<P> where
    P: Is2D + Clone, 

fn apply_view(&mut self, view: &View) -> Result<()>

Should apply the view and only keep items indexed within the view. Should return an error if any index is out of bounds

fn from_view(&self, view: &View) -> Result<Box<Self>>

Should create a new object consisting only of items indexed within the view. Should return an error if any index is out of bounds

impl<P> IsSortableND for PointCloud2D<P> where
    P: Is2D, 

fn n_dimensions() -> usize

Should return the number of dimensions. E.g. 2 for 2D space, 3 for 3D space etc.

fn sort_dim(&mut self, dimension: usize) -> Result<()>

Should sort all elements by the given dimension

impl<P> IsSortable2D for PointCloud2D<P> where
    P: Is2D, 

fn sort_x(&mut self)

Should sort all elements by x

fn sort_y(&mut self)

Should sort all elements by y

impl<P> IsMergeable for PointCloud2D<P> where
    P: Is2D + Clone, 

fn consume(&mut self, other: Self)

Should merge other into this

fn combine(&self, other: &Self) -> Self

Should return a combination of this and other

impl<P> Display for PointCloud2D<P> where
    P: Is2D + Display, 

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

Formats the value using the given formatter.