Struct shapefile::record::multipoint::GenericMultipoint

pub struct GenericMultipoint<PointType> { /* private fields */ }

Generic struct to create the Multipoint, MultipointM, MultipointZ types

Multipoints are a collection of… multiple points, they can be created from Vec of points using the From trait or using the new method.

Multipoint shapes only offers non-mutable access to the points data, to be able to mutate it you have to move the points data out of the struct.

use shapefile::{Multipoint, Point};
let multipoint = Multipoint::from(vec![
    Point::new(1.0, 1.0),
    Point::new(2.0, 2.0),
]);

assert_eq!(multipoint[0], Point::new(1.0, 1.0));

let points: Vec<Point> = multipoint.into();
assert_eq!(points.len(), 2);

geo-types

Multipoints are convertible to the geo-types’s Multipoint

let mut multipoints = shapefile::read_shapes_as::<_, shapefile::Multipoint>("tests/data/multipoint.shp")?;
let geo_multipoint: geo_types::MultiPoint<f64> = multipoints.pop().unwrap().into();
let multipoint = shapefile::Multipoint::from(geo_multipoint);

Implementations

impl<PointType: ShrinkablePoint + GrowablePoint + Copy> GenericMultipoint<PointType>

pub fn new(points: Vec<PointType>) -> Self

Creates a new Multipoint shape

Examples

Creating Multipoint

use shapefile::{Multipoint, Point};
let points = vec![
    Point::new(1.0, 1.0),
    Point::new(2.0, 2.0),
];
let multipoint = Multipoint::new(points);

Creating a MultipointM

use shapefile::{MultipointM, PointM, NO_DATA};
let points = vec![
    PointM::new(1.0, 1.0, NO_DATA),
    PointM::new(2.0, 2.0, NO_DATA),
];
let multipointm = MultipointM::new(points);

Creating a MultipointZ

use shapefile::{MultipointZ, PointZ, NO_DATA};
let points = vec![
    PointZ::new(1.0, 1.0, 1.0, NO_DATA),
    PointZ::new(2.0, 2.0, 2.0, NO_DATA),
];
let multipointz = MultipointZ::new(points);

impl<PointType> GenericMultipoint<PointType>

pub fn bbox(&self) -> &GenericBBox<PointType>

Returns the bbox

Example

use shapefile::{MultipointZ, PointZ, NO_DATA};
let multipointz = MultipointZ::new(vec![
    PointZ::new(1.0, 4.0, 1.2, 4.2),
    PointZ::new(2.0, 6.0, 4.0, 13.37),
]);

let bbox = multipointz.bbox();
assert_eq!(bbox.min.x, 1.0);
assert_eq!(bbox.max.x, 2.0);
assert_eq!(bbox.m_range(), [4.2, 13.37])

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

Returns a non-mutable slice of point

pub fn point(&self, index: usize) -> Option<&PointType>

Returns a reference to a point

Example

use shapefile::{MultipointZ, PointZ};
let multipointz = MultipointZ::new(vec![
    PointZ::new(1.0, 4.0, 1.2, 4.2),
    PointZ::new(2.0, 6.0, 4.0, 13.37),
]);

assert_eq!(multipointz.point(0), Some(&PointZ::new(1.0, 4.0, 1.2, 4.2)));
assert_eq!(multipointz.point(2), None);

pub fn into_inner(self) -> Vec<PointType>

Consumes the shape, returning the points

Trait Implementations

impl<PointType: Clone> Clone for GenericMultipoint<PointType>

fn clone(&self) -> GenericMultipoint<PointType>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<PointType: Debug> Debug for GenericMultipoint<PointType>

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

Formats the value using the given formatter.

impl From<GenericMultipoint<Point>> for Shape

fn from(concrete: Multipoint) -> Self

Converts to this type from the input type.

impl From<GenericMultipoint<Point>> for Vec<Point>

fn from(multipoints: GenericMultipoint<Point>) -> Self

Converts to this type from the input type.

impl From<GenericMultipoint<PointM>> for Shape

fn from(concrete: MultipointM) -> Self

Converts to this type from the input type.

impl From<GenericMultipoint<PointM>> for Vec<PointM>

fn from(multipoints: GenericMultipoint<PointM>) -> Self

Converts to this type from the input type.

impl<PointType> From<GenericMultipoint<PointType>> for MultiPoint<f64>

where Point<f64>: From<PointType>,

fn from(multi_points: GenericMultipoint<PointType>) -> Self

Converts to this type from the input type.

impl From<GenericMultipoint<PointZ>> for Shape

fn from(concrete: MultipointZ) -> Self

Converts to this type from the input type.

impl From<GenericMultipoint<PointZ>> for Vec<PointZ>

fn from(multipoints: GenericMultipoint<PointZ>) -> Self

Converts to this type from the input type.

impl<PointType> From<MultiPoint> for GenericMultipoint<PointType>

where PointType: From<Point<f64>> + ShrinkablePoint + GrowablePoint + Copy,

fn from(mp: MultiPoint<f64>) -> Self

Converts to this type from the input type.

impl<PointType> From<Vec<PointType>> for GenericMultipoint<PointType>

where PointType: ShrinkablePoint + GrowablePoint + Copy,

fn from(points: Vec<PointType>) -> Self

Converts to this type from the input type.

impl<PointType, I: SliceIndex<[PointType]>> Index<I> for GenericMultipoint<PointType>

type Output = <I as SliceIndex<[PointType]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<PointType: PartialEq> PartialEq for GenericMultipoint<PointType>

fn eq(&self, other: &GenericMultipoint<PointType>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<PointType> StructuralPartialEq for GenericMultipoint<PointType>