Struct diesel_mysql_spatial::data_types::Polygon

pub struct Polygon {
    pub srid: SRID,
    pub geom: Polygon<f64>,
}

A bounded two-dimensional area.

MySQL extension: The spatial reference system identifier (SRID) may identify the used coordinate system.

Fields

srid: SRID

geom: Polygon<f64>

Methods from Deref<Target = Polygon<f64>>

pub fn exterior(&self) -> &LineString<T>

Return a reference to the exterior LineString ring.

Examples

use geo_types::{LineString, Polygon};

let exterior = LineString::from(vec![(0., 0.), (1., 1.), (1., 0.), (0., 0.)]);

let polygon = Polygon::new(exterior.clone(), vec![]);

assert_eq!(polygon.exterior(), &exterior);

pub fn exterior_mut<F>(&mut self, f: F) where
    F: FnOnce(&mut LineString<T>), 

Execute the provided closure f, which is provided with a mutable reference to the exterior LineString ring.

After the closure executes, the exterior LineString will be closed.

Examples

use geo_types::{coord, LineString, Polygon};

let mut polygon = Polygon::new(
    LineString::from(vec![(0., 0.), (1., 1.), (1., 0.), (0., 0.)]),
    vec![],
);

polygon.exterior_mut(|exterior| {
    exterior.0[1] = coord! { x: 1., y: 2. };
});

assert_eq!(
    polygon.exterior(),
    &LineString::from(vec![(0., 0.), (1., 2.), (1., 0.), (0., 0.),])
);

If the first and last Coordinates of the exterior LineString no longer match, the LineString will be closed:

use geo_types::{coord, LineString, Polygon};

let mut polygon = Polygon::new(
    LineString::from(vec![(0., 0.), (1., 1.), (1., 0.), (0., 0.)]),
    vec![],
);

polygon.exterior_mut(|exterior| {
    exterior.0[0] = coord! { x: 0., y: 1. };
});

assert_eq!(
    polygon.exterior(),
    &LineString::from(vec![(0., 1.), (1., 1.), (1., 0.), (0., 0.), (0., 1.),])
);

pub fn interiors(&self) -> &[LineString<T>]

Return a slice of the interior LineString rings.

Examples

use geo_types::{coord, LineString, Polygon};

let interiors = vec![LineString::from(vec![
    (0.1, 0.1),
    (0.9, 0.9),
    (0.9, 0.1),
    (0.1, 0.1),
])];

let polygon = Polygon::new(
    LineString::from(vec![(0., 0.), (1., 1.), (1., 0.), (0., 0.)]),
    interiors.clone(),
);

assert_eq!(interiors, polygon.interiors());

pub fn interiors_mut<F>(&mut self, f: F) where
    F: FnOnce(&mut [LineString<T>]), 

Execute the provided closure f, which is provided with a mutable reference to the interior LineString rings.

After the closure executes, each of the interior LineStrings will be closed.

Examples

use geo_types::{coord, LineString, Polygon};

let mut polygon = Polygon::new(
    LineString::from(vec![(0., 0.), (1., 1.), (1., 0.), (0., 0.)]),
    vec![LineString::from(vec![
        (0.1, 0.1),
        (0.9, 0.9),
        (0.9, 0.1),
        (0.1, 0.1),
    ])],
);

polygon.interiors_mut(|interiors| {
    interiors[0].0[1] = coord! { x: 0.8, y: 0.8 };
});

assert_eq!(
    polygon.interiors(),
    &[LineString::from(vec![
        (0.1, 0.1),
        (0.8, 0.8),
        (0.9, 0.1),
        (0.1, 0.1),
    ])]
);

If the first and last Coordinates of any interior LineString no longer match, those LineStrings will be closed:

use geo_types::{coord, LineString, Polygon};

let mut polygon = Polygon::new(
    LineString::from(vec![(0., 0.), (1., 1.), (1., 0.), (0., 0.)]),
    vec![LineString::from(vec![
        (0.1, 0.1),
        (0.9, 0.9),
        (0.9, 0.1),
        (0.1, 0.1),
    ])],
);

polygon.interiors_mut(|interiors| {
    interiors[0].0[0] = coord! { x: 0.1, y: 0.2 };
});

assert_eq!(
    polygon.interiors(),
    &[LineString::from(vec![
        (0.1, 0.2),
        (0.9, 0.9),
        (0.9, 0.1),
        (0.1, 0.1),
        (0.1, 0.2),
    ])]
);

pub fn interiors_push(&mut self, new_interior: impl Into<LineString<T>>)

Add an interior ring to the Polygon.

The new LineString interior ring will be closed:

Examples

use geo_types::{coord, LineString, Polygon};

let mut polygon = Polygon::new(
    LineString::from(vec![(0., 0.), (1., 1.), (1., 0.), (0., 0.)]),
    vec![],
);

assert_eq!(polygon.interiors().len(), 0);

polygon.interiors_push(vec![(0.1, 0.1), (0.9, 0.9), (0.9, 0.1)]);

assert_eq!(
    polygon.interiors(),
    &[LineString::from(vec![
        (0.1, 0.1),
        (0.9, 0.9),
        (0.9, 0.1),
        (0.1, 0.1),
    ])]
);

pub fn is_convex(&self) -> bool

👎 Deprecated since 0.6.1:

Please use geo::is_convex on poly.exterior() instead

Determine whether a Polygon is convex

Trait Implementations

impl AsMut<Polygon<f64>> for Polygon

fn as_mut(&mut self) -> &mut Polygon<f64>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Polygon<f64>> for Polygon

fn as_ref(&self) -> &Polygon<f64>

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Polygon

fn clone(&self) -> Polygon

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Polygon

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

Formats the value using the given formatter.

impl Deref for Polygon

type Target = Polygon<f64>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Polygon

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl From<BoundingBox> for Polygon

fn from(other: BoundingBox) -> Self

Converts to this type from the input type.

impl From<Polygon<f64>> for Polygon

fn from(geom: Polygon<f64>) -> Self

Converts to this type from the input type.

impl From<Polygon> for Geometry

fn from(other: Polygon) -> Self

Converts to this type from the input type.

impl FromSql<Polygon, Mysql> for Polygon

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl<__ST, __DB> FromSqlRow<__ST, __DB> for Polygon where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

See the trait documentation.

const FIELDS_NEEDED: usize = 1usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

impl PartialEq<Polygon> for Polygon

fn eq(&self, other: &Polygon) -> bool

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

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

This method tests for !=.

impl<__ST, __DB> Queryable<__ST, __DB> for Polygon where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

type Row = Polygon

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

impl ToSql<Geometry, Mysql> for Polygon

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Mysql>) -> Result

See the trait documentation.

impl ToSql<Polygon, Mysql> for Polygon

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Mysql>) -> Result

See the trait documentation.

impl TryFrom<Geometry> for Polygon

type Error = <Polygon<f64> as TryFrom<Geometry<f64>>>::Error

The type returned in the event of a conversion error.

fn try_from(other: Geometry) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for Polygon