geometry-algorithm 0.0.8

Free-function algorithms (distance, length, area, within, intersects, …) ported from Boost.Geometry.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

//! `envelope_dyn` — runtime-dispatched envelope for [`DynGeometry`].
//!
//! Mirrors `boost::geometry::envelope(g)` reached through the variant
//! adapter (`algorithms/envelope.hpp`). Returns a
//! `model::Box<Point<S, 2, Cs>>`.
//!
//! Every single/multi variant is supported (each per-kind envelope
//! strategy resolves through the tag-keyed
//! [`geometry_strategy::EnvelopeStrategyForKind`] picker). The
//! `GeometryCollection` arm returns `Err(DynKindMismatch)`: computing
//! its envelope needs a box-merge primitive v1 does not yet ship (and
//! an empty collection has no well-defined envelope). That arm lands
//! when the merge helper does.

use geometry_coords::CoordinateScalar;
use geometry_cs::{CartesianFamily, CoordinateSystem};
use geometry_model::{Box, DynGeometry, DynKind, Linestring, Point, Polygon};
use geometry_strategy::{EnvelopeStrategy, EnvelopeStrategyForKind};
use geometry_tag::{
    LinestringTag, MultiLinestringTag, MultiPointTag, MultiPolygonTag, PointTag, PolygonTag, SameAs,
};

use crate::dyn_error::DynKindMismatch;
use crate::envelope::envelope;

const SUPPORTED: &[&[DynKind]] = &[
    &[DynKind::Point],
    &[DynKind::LineString],
    &[DynKind::Polygon],
    &[DynKind::MultiPoint],
    &[DynKind::MultiLineString],
    &[DynKind::MultiPolygon],
];

/// Runtime-dispatched envelope.
///
/// Returns `Ok(Box)` for every single/multi kind.
///
/// # Errors
///
/// Returns `Err(DynKindMismatch)` for `GeometryCollection` (see the
/// module docs — it needs a box-merge primitive v1 lacks).
pub fn envelope_dyn<S, Cs>(g: &DynGeometry<S, Cs>) -> Result<Box<Point<S, 2, Cs>>, DynKindMismatch>
where
    S: CoordinateScalar,
    Cs: CoordinateSystem,
    Cs::Family: SameAs<CartesianFamily>,
    // Each arm calls the tag-dispatched `envelope` free fn; require the
    // picked per-kind strategy for each concrete arm type to produce a
    // `Box<Point<S, 2, Cs>>`.
    <PointTag as EnvelopeStrategyForKind>::S:
        EnvelopeStrategy<Point<S, 2, Cs>, Output = Box<Point<S, 2, Cs>>>,
    <LinestringTag as EnvelopeStrategyForKind>::S:
        EnvelopeStrategy<Linestring<Point<S, 2, Cs>>, Output = Box<Point<S, 2, Cs>>>,
    <PolygonTag as EnvelopeStrategyForKind>::S:
        EnvelopeStrategy<Polygon<Point<S, 2, Cs>>, Output = Box<Point<S, 2, Cs>>>,
    <MultiPointTag as EnvelopeStrategyForKind>::S: EnvelopeStrategy<geometry_model::MultiPoint<Point<S, 2, Cs>>, Output = Box<Point<S, 2, Cs>>>,
    <MultiLinestringTag as EnvelopeStrategyForKind>::S: EnvelopeStrategy<
            geometry_model::MultiLinestring<Linestring<Point<S, 2, Cs>>>,
            Output = Box<Point<S, 2, Cs>>,
        >,
    <MultiPolygonTag as EnvelopeStrategyForKind>::S: EnvelopeStrategy<
            geometry_model::MultiPolygon<Polygon<Point<S, 2, Cs>>>,
            Output = Box<Point<S, 2, Cs>>,
        >,
{
    use DynGeometry::{
        GeometryCollection, LineString, MultiLineString, MultiPoint, MultiPolygon,
        Point as PointArm, Polygon as PolygonArm,
    };
    match g {
        PointArm(p) => Ok(envelope(p)),
        LineString(ls) => Ok(envelope(ls)),
        PolygonArm(pg) => Ok(envelope(pg)),
        MultiPoint(mp) => Ok(envelope(mp)),
        MultiLineString(ml) => Ok(envelope(ml)),
        MultiPolygon(mpg) => Ok(envelope(mpg)),
        GeometryCollection(_) => Err(DynKindMismatch {
            got: alloc::vec![g.kind()],
            expected: SUPPORTED,
        }),
    }
}