Struct Polygon 

pub struct Polygon { /* private fields */ }

A polygon with exterior and optional interior rings.

This wraps geo::Polygon and provides additional functionality for GeoJSON conversion and spatial operations.

Examples

use spatio_types::geo::Polygon;
use geo::polygon;

let poly = polygon![
    (x: -80.0, y: 35.0),
    (x: -70.0, y: 35.0),
    (x: -70.0, y: 45.0),
    (x: -80.0, y: 45.0),
    (x: -80.0, y: 35.0),
];
let wrapped = Polygon::from(poly);

Implementations

impl Polygon

pub fn new(exterior: LineString<f64>, interiors: Vec<LineString<f64>>) -> Self

Create a new polygon from an exterior ring and optional interior rings (holes).

Arguments

• exterior - The outer boundary of the polygon
• interiors - Optional holes within the polygon

pub fn from_coords( exterior: &[(f64, f64)], interiors: Vec<Vec<(f64, f64)>>, ) -> Self

Create a new polygon from coordinate arrays without requiring geo::LineString.

This is a convenience method that allows creating polygons from raw coordinates without needing to import types from the geo crate.

Arguments

• exterior - Coordinates for the outer boundary [(lon, lat), …]
• interiors - Optional holes within the polygon, each as [(lon, lat), …]

Examples

use spatio_types::geo::Polygon;

// Create a simple rectangle
let polygon = Polygon::from_coords(
    &[
        (-80.0, 35.0),
        (-70.0, 35.0),
        (-70.0, 45.0),
        (-80.0, 45.0),
        (-80.0, 35.0),  // Close the ring
    ],
    vec![],
);

// Create a polygon with a hole
let polygon_with_hole = Polygon::from_coords(
    &[
        (-80.0, 35.0),
        (-70.0, 35.0),
        (-70.0, 45.0),
        (-80.0, 45.0),
        (-80.0, 35.0),
    ],
    vec![
        vec![
            (-75.0, 38.0),
            (-74.0, 38.0),
            (-74.0, 40.0),
            (-75.0, 40.0),
            (-75.0, 38.0),
        ]
    ],
);

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

Get a reference to the exterior ring.

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

Get references to the interior rings (holes).

pub fn inner(&self) -> &Polygon<f64>

Access the inner geo::Polygon.

pub fn into_inner(self) -> Polygon<f64>

Convert into the inner geo::Polygon.

pub fn contains(&self, point: &Point) -> bool

Check if a point is contained within this polygon.

Examples

use spatio_types::geo::{Point, Polygon};
use geo::polygon;

let poly = polygon![
    (x: -80.0, y: 35.0),
    (x: -70.0, y: 35.0),
    (x: -70.0, y: 45.0),
    (x: -80.0, y: 45.0),
    (x: -80.0, y: 35.0),
];
let polygon = Polygon::from(poly);
let point = Point::new(-75.0, 40.0);
assert!(polygon.contains(&point));

Trait Implementations

impl Clone for Polygon

fn clone(&self) -> Polygon

Returns a duplicate 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<'de> Deserialize<'de> for Polygon

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Polygon> for Polygon

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

Converts to this type from the input type.

impl From<Polygon> for Polygon<f64>

fn from(polygon: Polygon) -> Self

Converts to this type from the input type.

impl PartialEq for Polygon

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Polygon

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Polygon