Geo

https://docs.rs/geo/latest
Admin
Geo is a Rust crate providing planar geospatial geometries and algorithms including topological...
Tokens:2,056,903
Snippets:9,706
Trust Score:9.7
Update:1 day ago
Show doc for...
Tokens:
Raw
### Example for point_at_ratio_from_start

Source: https://docs.rs/geo/latest/geo/algorithm/line_measures/trait.InterpolateLine.html

Shows how to use point_at_ratio_from_start with Euclidean and Haversine algorithms. The ratio is bounded between 0 and 1, where 0.0 returns the start and 1.0 returns the end.

```rust
use geo::algorithm::{Haversine, Euclidean, InterpolateLine};
use geo::wkt;

let line_string = wkt!(LINESTRING(0. 0., 0. 10.,10. 10.));
let quarter_distance = Euclidean.point_at_ratio_from_start(&line_string, 0.25).unwrap();
assert_relative_eq!(quarter_distance, wkt!(POINT(0. 5.)));

let quarter_distance = Haversine.point_at_ratio_from_start(&line_string, 0.25).unwrap();
assert_relative_eq!(quarter_distance, wkt!(POINT(0. 4.961924877405399)), epsilon=1e-14);
```

--------------------------------

### Example for point_at_ratio_from_end

Source: https://docs.rs/geo/latest/geo/algorithm/line_measures/trait.InterpolateLine.html

Shows how to use point_at_ratio_from_end with Euclidean and Haversine algorithms. The ratio is bounded between 0 and 1, where 0.0 returns the end and 1.0 returns the start.

```rust
use geo::algorithm::{Haversine, Euclidean, InterpolateLine};
use geo::wkt;

let line_string = wkt!(LINESTRING(0. 0., 0. 10.,10. 10.));
let quarter_distance = Euclidean.point_at_ratio_from_end(&line_string, 0.25).unwrap();
assert_relative_eq!(quarter_distance, wkt!(POINT(5. 10.0)));

let quarter_distance = Haversine.point_at_ratio_from_end(&line_string, 0.25).unwrap();
assert_relative_eq!(quarter_distance, wkt!(POINT(4.961333045966285 10.037420806650719)), epsilon=1e-14);
```

--------------------------------

### get method example

Source: https://docs.rs/geo/latest/geo/algorithm/relate/struct.IntersectionMatrix.html

Creates a LineString and a Rect, computes their intersection matrix via relate, and uses get to assert the dimension of each coordinate position pair. The comments explain the expected dimensions for each pair.

```rust
use geo_types::{LineString, Rect, line_string};
use geo::{coordinate_position::CoordPos, dimensions::Dimensions, relate::Relate};

let line_string: LineString = line_string![(x: 0.0, y: 0.0), (x: 10.0, y: 0.0), (x: 5.0, y: 5.0)];
let rect = Rect::new((0.0, 0.0), (5.0, 5.0));

let intersection = line_string.relate(&rect);

// The intersection of the two interiors is empty, because no part of the string is inside the rect
assert_eq!(intersection.get(CoordPos::Inside, CoordPos::Inside), Dimensions::Empty);

// The intersection of the line string's interior with the rect's boundary is one-dimensional, because part of the first line overlaps one of the rect's edges
assert_eq!(intersection.get(CoordPos::Inside, CoordPos::OnBoundary), Dimensions::OneDimensional);

// The intersection of the line string's interior with the rect's exterior is one-dimensional, because part of the string is outside the rect
assert_eq!(intersection.get(CoordPos::Inside, CoordPos::Outside), Dimensions::OneDimensional);

// The intersection of the line string's boundary with the rect's interior is empty, because neither of its end points are inside the rect
assert_eq!(intersection.get(CoordPos::OnBoundary, CoordPos::Inside), Dimensions::Empty);

// The intersection of the line string's boundary with the rect's boundary is zero-dimensional, because the string's start and end points are on the rect's edges
assert_eq!(intersection.get(CoordPos::OnBoundary, CoordPos::OnBoundary), Dimensions::ZeroDimensional);

// The intersection of the line string's boundary with the rect's exterior is empty, because neither of its end points are outside the rect
assert_eq!(intersection.get(CoordPos::OnBoundary, CoordPos::Outside), Dimensions::Empty);

// The intersection of the the line's exterior with the rect's interior is two-dimensional, because it's simply the rect's interior
assert_eq!(intersection.get(CoordPos::Outside, CoordPos::Inside), Dimensions::TwoDimensional);

// The intersection of the line's exterior with the rect's boundary is one-dimensional, because it's the rect's edges (minus where the string overlaps it)
assert_eq!(intersection.get(CoordPos::Outside, CoordPos::OnBoundary), Dimensions::OneDimensional);

// The intersection of the two exteriors is two-dimensional, because it's the whole plane around the two shapes
assert_eq!(intersection.get(CoordPos::Outside, CoordPos::Outside), Dimensions::TwoDimensional);
```

--------------------------------

### center example

Source: https://docs.rs/geo/latest/geo/geometry/struct.Rect.html

Returns the center coordinate of a rectangle. The example creates a rectangle from (5,5) to (15,15) and asserts the center is (10,10).

```rust
use geo_types::{coord, Rect};

let rect = Rect::new(
    coord! { x: 5., y: 5. },
    coord! { x: 15., y: 15. },
);

assert_eq!(rect.center(), coord! { x: 10., y: 10. });
```

--------------------------------

### Example: get method on IntersectionMatrix

Source: https://docs.rs/geo/latest/src/geo/algorithm/relate/geomgraph/intersection_matrix.rs.html

Rust example showing direct access to the matrix using get with CoordPos. Uses geo_types::{LineString, Rect, line_string} and geo::{coordinate_position::CoordPos, dimensions::Dimensions, relate::Relate}. Asserts that the interior intersection is empty.

```rust
use geo_types::{LineString, Rect, line_string};
use geo::{coordinate_position::CoordPos, dimensions::Dimensions, relate::Relate};

let line_string: LineString = line_string![(x: 0.0, y: 0.0), (x: 10.0, y: 0.0), (x: 5.0, y: 5.0)];
let rect = Rect::new((0.0, 0.0), (5.0, 5.0));

let intersection = line_string.relate(&rect);

// The intersection of the two interiors is empty, because no part of the string is inside the rect
assert_eq!(intersection.get(CoordPos::Inside, CoordPos::Inside), Dimensions::Empty);
```

--------------------------------

### Example: Creating a Point with x/y values

Source: https://docs.rs/geo/latest/geo/macro.point.html

Rust example demonstrating the `point!` macro with explicit x/y values and with a `coord!` macro. Asserts the resulting point's x and y coordinates.

```rust
use geo_types::{point, coord};

let p = point! { x: 181.2, y: 51.79 };

assert_eq!(p.x(), 181.2);
assert_eq!(p.y(), 51.79);

let p = point!(coord! { x: 181.2, y: 51.79 });

assert_eq!(p.x(), 181.2);
assert_eq!(p.y(), 51.79);
```

--------------------------------

### HasDimensions trait with boundary_dimensions example

Source: https://docs.rs/geo/latest/src/geo/algorithm/dimensions.rs.html

Defines the `boundary_dimensions` method of the `HasDimensions` trait. The doc example shows how to get the boundary dimensions of a point and a rectangle.

```rust
    /// The dimensions of the `Geometry`'s boundary, as used by OGC-SFA.
    ///
    /// ## Examples
    ///
    /// ```
    /// use geo_types::{GeometryCollection, Rect, Point};
    /// use geo::dimensions::{Dimensions, HasDimensions};
    ///
    /// // a point has no boundary
    /// let point = Point::new(10.0, 10.0);
    /// assert_eq!(Dimensions::Empty, point.boundary_dimensions());
    ///
    /// // a typical rectangle has a *line* (one dimensional) boundary
    /// let rect = Rect::new((0.0, 0.0), (10.0, 10.0));
    /// assert_eq!(Dimensions::OneDimensional, rect.boundary_dimensions());
```

--------------------------------

### Example: Using HasDimensions to get Dimensions

Source: https://docs.rs/geo/latest/geo/algorithm/dimensions/enum.Dimensions.html

Shows how to use the HasDimensions trait to get the Dimensions of Point, LineString, and Rect, and compare them. Requires importing geo_types and geo::dimensions.

```rust
use geo_types::{Point, Rect, line_string};
use geo::dimensions::{HasDimensions, Dimensions};

let point = Point::new(0.0, 5.0);
let line_string = line_string![(x: 0.0, y: 0.0), (x: 5.0, y: 5.0), (x: 0.0, y: 5.0)];
let rect = Rect::new((0.0, 0.0), (10.0, 10.0));
assert_eq!(Dimensions::ZeroDimensional, point.dimensions());
assert_eq!(Dimensions::OneDimensional, line_string.dimensions());
assert_eq!(Dimensions::TwoDimensional, rect.dimensions());

assert!(point.dimensions() < line_string.dimensions());
assert!(rect.dimensions() > line_string.dimensions());
```

--------------------------------

### Using PreparedGeometry with Relate

Source: https://docs.rs/geo/latest/geo/algorithm/indexed/prepared_geometry/struct.PreparedGeometry.html

Example usage showing how to create a PreparedGeometry from a polygon and use the relate method to check topological relationships with lines. The example uses the wkt! macro to define geometries.

```rust
use geo::{Relate, PreparedGeometry, wkt};

let polygon = wkt! { POLYGON((2.0 2.0,2.0 6.0,4.0 6.0)) };
let touching_line = wkt! { LINESTRING(0.0 0.0,2.0 2.0) };
let intersecting_line = wkt! { LINESTRING(0.0 0.0,3.0 3.0) };
let contained_line = wkt! { LINESTRING(2.0 2.0,3.0 5.0) };

let prepared_polygon = PreparedGeometry::from(polygon);
assert!(prepared_polygon.relate(&touching_line).is_touches());
assert!(prepared_polygon.relate(&intersecting_line).is_intersects());
assert!(prepared_polygon.relate(&contained_line).is_contains());
```

--------------------------------

### Using point_at_ratio_from_start with Euclidean and Haversine

Source: https://docs.rs/geo/latest/geo/algorithm/line_measures/trait.InterpolatableLine.html

Example usage of the point_at_ratio_from_start method on a LineString. It uses the Euclidean and Haversine metric spaces to interpolate a point at 25% of the line length. The results are compared with assert_relative_eq, with a custom epsilon for the Haversine case.

```rust
use geo::algorithm::line_measures::{Haversine, Euclidean, InterpolatableLine};
use geo::wkt;

let line_string = wkt!(LINESTRING(0. 0., 0. 10.,10. 10.));
let quarter_distance = line_string.point_at_ratio_from_start(&Euclidean, 0.25).unwrap();
assert_relative_eq!(quarter_distance, wkt!(POINT(0. 5.)));

let quarter_distance = line_string.point_at_ratio_from_start(&Haversine, 0.25).unwrap();
assert_relative_eq!(quarter_distance, wkt!(POINT(0. 4.961924877405399)), epsilon=1e-14);
```

--------------------------------

### point_at_distance_between example

Source: https://docs.rs/geo/latest/geo/algorithm/line_measures/metric_spaces/struct.GeodesicMeasure.html

Rust example using Geodesic.point_at_distance_between to find points at 100,000 and 10,000,000 meters from the start point along a geodesic between p1 and p2. Uses assert_relative_eq! with epsilon 1.0e-2.

```rust
use geo::Point;
use geo::{Geodesic, InterpolatePoint};

let p1 = Point::new(10.0, 20.0);
let p2 = Point::new(125.0, 25.0);

let closer_to_p1 = Geodesic.point_at_distance_between(p1, p2, 100_000.0);
assert_relative_eq!(closer_to_p1, Point::new(10.81, 20.49), epsilon = 1.0e-2);

let closer_to_p2 = Geodesic.point_at_distance_between(p1, p2, 10_000_000.0);
assert_relative_eq!(closer_to_p2, Point::new(112.20, 30.67), epsilon = 1.0e-2);
```

--------------------------------

### point_at_distance_from_start example with Euclidean and Haversine

Source: https://docs.rs/geo/latest/geo/algorithm/line_measures/trait.InterpolateLine.html

Shows how to use Euclidean.point_at_distance_from_start and Haversine.point_at_distance_from_start on a LineString. For Euclidean, distance is in the same units as the points; for Haversine, distance is in meters. The result is asserted with assert_relative_eq!.

```rust
use geo::algorithm::{Haversine, Euclidean, InterpolateLine};
use geo::wkt;

let line_string = wkt!(LINESTRING(0. 0., 0. 10.,10. 10.));

// For Euclidean calculations, distance is in the same units as your points
let near_start = Euclidean.point_at_distance_from_start(&line_string, 0.5).unwrap();
assert_relative_eq!(near_start, wkt!(POINT(0. 0.5)));

// For Haversine calculations, distance is in meters
let near_start = Haversine.point_at_distance_from_start(&line_string, 100_000.0).unwrap();
assert_relative_eq!(near_start, wkt!(POINT(0. 0.899320363724538)), epsilon=1e-14);
```

--------------------------------

### Get y component with Point::y

Source: https://docs.rs/geo/latest/geo/geometry/struct.Point.html

Returns the y/vertical component of the point. The example asserts the y value.

```rust
use geo_types::Point;

let p = Point::new(1.234, 2.345);

assert_eq!(p.y(), 2.345);
```

--------------------------------

### Example: simplify_idx usage

Source: https://docs.rs/geo/latest/geo/algorithm/simplify/trait.SimplifyIdx.html

Shows how to use SimplifyIdx on a LineString to get simplified indices. The example creates a line_string and calls simplify_idx(1.0), expecting indices [0, 1, 2, 4].

```rust
use geo::SimplifyIdx;
use geo::line_string;

let line_string = line_string![
    (x: 0.0, y: 0.0),
    (x: 5.0, y: 4.0),
    (x: 11.0, y: 5.5),
    (x: 17.3, y: 3.2),
    (x: 27.8, y: 0.1),
];

let simplified = line_string.simplify_idx(1.0);

let expected = vec![
    0_usize,
    1_usize,
    2_usize,
    4_usize,
];

assert_eq!(expected, simplified);
```

--------------------------------

### Example: Using approx::assert_ulps_eq! and assert_ulps_ne! with Geometry

Source: https://docs.rs/geo/latest/geo/geometry/enum.Geometry.html

Shows how to compare two Geometry values using ULPs-based approximate equality. The example creates two Point geometries that differ by 4 * f64::EPSILON and asserts equality with default max_ulps, inequality with max_ulps=3, and equality with max_ulps=5.

```rust
use geo_types::{Geometry, Point};

let a: Geometry = Point::new(1.0, 1.0).into();
let b: Geometry = Point::new(1.0 + 4.0 * f64::EPSILON, 1.0 + 4.0 * f64::EPSILON).into();

approx::assert_ulps_eq!(a, b);
approx::assert_ulps_ne!(a, b, max_ulps=3);
approx::assert_ulps_eq!(a, b, max_ulps=5);
```

--------------------------------

### Dimensions enum definition with doc example

Source: https://docs.rs/geo/latest/src/geo/algorithm/dimensions.rs.html

Defines the `Dimensions` enum with variants for empty, zero-, one-, and two-dimensional geometries. The doc example shows how to get dimensions of Point, LineString, and Rect, and compare them.

```rust
use crate::Orientation::Collinear;
use crate::geometry::*;
use crate::monotone_chain::geometry::*;
use crate::{CoordNum, GeoNum, GeometryCow};

/// Geometries can have 0, 1, or two dimensions. Or, in the case of an [`empty`](#is_empty)
/// geometry, a special `Empty` dimensionality.
///
/// # Examples
///
/// ```
/// use geo_types::{Point, Rect, line_string};
/// use geo::dimensions::{HasDimensions, Dimensions};
///
/// let point = Point::new(0.0, 5.0);
/// let line_string = line_string![(x: 0.0, y: 0.0), (x: 5.0, y: 5.0), (x: 0.0, y: 5.0)];
/// let rect = Rect::new((0.0, 0.0), (10.0, 10.0));
/// assert_eq!(Dimensions::ZeroDimensional, point.dimensions());
/// assert_eq!(Dimensions::OneDimensional, line_string.dimensions());
/// assert_eq!(Dimensions::TwoDimensional, rect.dimensions());
///
/// assert!(point.dimensions() < line_string.dimensions());
/// assert!(rect.dimensions() > line_string.dimensions());
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd)]
pub enum Dimensions {
    /// Some geometries, like a `MultiPoint` or `GeometryCollection` may have no elements - thus no
    /// dimensions. Note that this is distinct from being `ZeroDimensional`, like a `Point`.
    Empty,
    /// Dimension of a point
    ZeroDimensional,
    /// Dimension of a line or curve
    OneDimensional,
    /// Dimension of a surface
    TwoDimensional,
}
```

--------------------------------

### Translate example using line_string!

Source: https://docs.rs/geo/latest/geo/algorithm/translate/trait.Translate.html

Shows how to use the translate method on a LineString, translating it by (1.5, 3.5) and asserting the result.

```rust
use geo::Translate;
use geo::line_string;

let ls = line_string![
    (x: 0.0, y: 0.0),
    (x: 5.0, y: 5.0),
    (x: 10.0, y: 10.0),
];

let translated = ls.translate(1.5, 3.5);

assert_eq!(translated, line_string![
    (x: 1.5, y: 3.5),
    (x: 6.5, y: 8.5),
    (x: 11.5, y: 13.5),
]);
```

--------------------------------

### Get intersection dimensions with IntersectionMatrix::get

Source: https://docs.rs/geo/latest/src/geo/algorithm/relate/geomgraph/intersection_matrix.rs.html

Shows how to use the get method on an IntersectionMatrix to retrieve the dimension of the intersection between the boundaries of two geometries. The example uses a polygon and a linestring, and asserts the result is Dimensions::Empty.

```rust
///   <rect x="0" y="0" width="4" height="4" fill="#8888FF" stroke-width="0.1" stroke="black" stroke-dasharray="0.15" />
///   <text x="0.25" y="1">A</text>
///   <text x="5" y="1.8">B</text>
///   <!-- yellow line sticking into the square -->
///   <line x1="2" y1="2" x2="6" y2="2" stroke="#EEEE00" stroke-width="0.2" />
///   <circle cx="2" cy="2" r="0.3" stroke-width="0.1" stroke="black" stroke-dasharray="0.15" fill="none" />
///   <circle cx="6" cy="2" r="0.3" stroke-width="0.1" stroke="black" stroke-dasharray="0.15" fill="none" />
/// </svg>
///
/// ```rust
/// # use geo::wkt;
/// # use geo::relate::{Relate, IntersectionMatrix};
/// # use geo::coordinate_position::CoordPos;
/// # use geo::dimensions::Dimensions;
/// #
/// # let a = wkt!(POLYGON((0. 0.,0. 4.,4. 4.,4. 0., 0. 0.)));
/// # let b = wkt!(LINESTRING(2. 2.,6. 2.));
/// # let intersection_matrix = a.relate(&b);
/// let intersection = intersection_matrix.get(
///    // The boundary of A...
///    CoordPos::OnBoundary,
///    // ...and the boundary of B...
///    CoordPos::OnBoundary
/// );
/// // ...do not intersect.
/// assert_eq!(intersection, Dimensions::Empty)
/// ```
```

--------------------------------

### Creating a Point with various methods

Source: https://docs.rs/geo/latest/geo/geometry/struct.Point.html

Shows multiple ways to construct a Point: using Point::new, the point! macro, From conversions from tuples and Coord.

```rust
use geo_types::{coord, point, Point};

let p1 = Point::new(0., 1.);

let p2 = point! { x: 1000.0, y: 2000.0 };

let p3: Point = (0., 1.).into();

let c = coord! { x: 10., y: 20. };
let p4: Point = c.into();
```

--------------------------------

### Create default round and square/miter BufferStyle examples

Source: https://docs.rs/geo/latest/geo/algorithm/buffer/struct.BufferStyle.html

Example from the struct documentation showing how to create a default round style and a style with square caps and mitered joins.

```rust
use geo::algorithm::buffer::{BufferStyle, LineCap, LineJoin};

// Default round style
let round_style = BufferStyle::new(2.0);

// Square caps with mitered joins
let square_style = BufferStyle::new(2.0)
    .line_cap(LineCap::Square)
    .line_join(LineJoin::Miter(1.0));
```

--------------------------------

### Get first coordinate with minimum y

Source: https://docs.rs/geo/latest/src/geo/algorithm/k_nearest_concave_hull.rs.html

Finds the coordinate with the smallest y value in the RTree, used as the starting point for the hull.

```rust
fn get_first_coord<T>(coord_set: &rstar::RTree<Coord<T>>) -> Coord<T>
where
    T: GeoFloat + RTreeNum,
{
    let mut min_y = Float::max_value();
    let mut result = coord_set
        .iter()
        .next()
        .expect("We checked that there are more then 3 coords in the set before.");

    for coord in coord_set.iter() {
        if coord.y < min_y {
            min_y = coord.y;
            result = coord;
        }
    }

    *result
}
```

--------------------------------

### Get x component with Point::x

Source: https://docs.rs/geo/latest/geo/geometry/struct.Point.html

Returns the x/horizontal component of the point. The example asserts the x value.

```rust
use geo_types::Point;

let p = Point::new(1.234, 2.345);

assert_eq!(p.x(), 1.234);
```

--------------------------------

### Example: Using haversine_intermediate

Source: https://docs.rs/geo/latest/geo/algorithm/haversine_intermediate/trait.HaversineIntermediate.html

Shows how to use the haversine_intermediate method to interpolate points between two points at given ratios. The example uses assert_relative_eq with an epsilon of 0.2.

```rust
use geo::HaversineIntermediate;
use geo::Point;

let p1 = Point::new(10.0, 20.0);
let p2 = Point::new(125.0, 25.0);

let i20 = p1.haversine_intermediate(&p2, 0.2);
assert_relative_eq!(i20, Point::new(29.8, 29.9), epsilon = 0.2);

let i80 = p1.haversine_intermediate(&p2, 0.8);
assert_relative_eq!(i80, Point::new(103.5, 33.5), epsilon = 0.2);
```

--------------------------------

### Example: Using earcut_triangles_raw

Source: https://docs.rs/geo/latest/geo/algorithm/triangulate_earcut/trait.TriangulateEarcut.html

Shows how to call earcut_triangles_raw on a square polygon and assert the resulting RawTriangulation. The example uses the geo crate's polygon! macro and expects the vertices and triangle indices as shown.

```rust
use geo::{coord, polygon, Triangle, TriangulateEarcut};
use geo::triangulate_earcut::RawTriangulation;

let square_polygon = polygon![
    (x: 0., y: 0.), // SW
    (x: 10., y: 0.), // SE
    (x: 10., y: 10.), // NE
    (x: 0., y: 10.), // NW
    (x: 0., y: 0.), // SW
];

let mut triangles_raw = square_polygon.earcut_triangles_raw();

assert_eq!(
    RawTriangulation {
        vertices: vec![
            [0., 0.], // SW
            [10., 0.], // SE
            [10., 10.], // NE
            [0., 10.], // NW
        ],
        triangle_indices: vec![
            2, 3, 0, // NE-NW-SW
            0, 1, 2, // SW-SE-NE
        ],
    },
    triangles_raw,
);
```

--------------------------------

### Get the minimum coordinate of a Rect

Source: https://docs.rs/geo/latest/geo/geometry/struct.Rect.html

Example from the `min` method documentation showing how to retrieve the minimum coordinate of a `Rect`.

```rust
use geo_types::{coord, Rect};

let rect = Rect::new(
    coord! { x: 5., y: 5. },
    coord! { x: 15., y: 15. },
);

assert_eq!(rect.min(), coord! { x: 5., y: 5. });
```

--------------------------------

### x_y: Get x and y as tuple

Source: https://docs.rs/geo/latest/geo/geometry/struct.Point.html

Returns a tuple containing the x and y components. The example destructures the tuple and asserts both values.

```rust
use geo_types::Point;

let mut p = Point::new(1.234, 2.345);
let (x, y) = p.x_y();

assert_eq!(y, 2.345);
assert_eq!(x, 1.234);
```

--------------------------------

### Example: orienting a polygon with Direction::Default

Source: https://docs.rs/geo/latest/geo/algorithm/orient/trait.Orient.html

Shows how to use `Orient` to orient a polygon's rings. The example creates a diamond polygon with exterior clockwise and interior counter-clockwise, then orients it with `Direction::Default` and asserts the expected result.

```rust
use geo::orient::{Direction, Orient};
use geo::polygon;

// a diamond shape
let polygon = polygon![
    // exterior oriented clockwise
    exterior: [
        (x: 1.0, y: 0.0),
        (x: 0.0, y: 1.0),
        (x: 1.0, y: 2.0),
        (x: 2.0, y: 1.0),
        (x: 1.0, y: 0.0),
    ],
    // interior oriented counter-clockwise
    interiors: [
        [
            (x: 1.0, y: 0.5),
            (x: 1.5, y: 1.0),
            (x: 1.0, y: 1.5),
            (x: 0.5, y: 1.0),
            (x: 1.0, y: 0.5),
        ],
    ],
];

let oriented = polygon.orient(Direction::Default);

// a diamond shape
let expected = polygon![
    // exterior oriented counter-clockwise
    exterior: [
        (x: 1.0, y: 0.0),
        (x: 2.0, y: 1.0),
        (x: 1.0, y: 2.0),
        (x: 0.0, y: 1.0),
        (x: 1.0, y: 0.0),
    ],
    // interior oriented clockwise
    interiors: [
        [
            (x: 1.0, y: 0.5),
            (x: 0.5, y: 1.0),
            (x: 1.0, y: 1.5),
            (x: 1.5, y: 1.0),
            (x: 1.0, y: 0.5),
        ],
    ],
];

assert_eq!(expected, oriented);
```

--------------------------------

### Example: Segmenting a LineString into 6 parts

Source: https://docs.rs/geo/latest/geo/algorithm/linestring_segment/trait.LineStringSegmentize.html

Shows how to use the line_segmentize method on a LineString. It creates a simple line string, segments it into 6 LineStrings, and asserts the resulting MultiLineString has 6 elements.

```rust
use geo::{LineString, MultiLineString, LineStringSegmentize};
// Create a simple line string
let lns: LineString<f64> = vec![[0.0, 0.0], [1.0, 2.0], [3.0, 6.0]].into();
// Segment it into 6 LineStrings inside of a MultiLineString
let segmentized = lns.line_segmentize(6).unwrap();
// Compare the number of elements
assert_eq!(6, segmentized.0.len());
```

--------------------------------

### point_at_ratio_from_end example with Euclidean and Haversine

Source: https://docs.rs/geo/latest/geo/algorithm/line_measures/trait.InterpolatableLine.html

Shows how to use `point_at_ratio_from_end` with `Euclidean` and `Haversine` metric spaces. The ratio is bounded between 0 and 1, where 0.0 returns the end and 1.0 returns the start. The example uses `assert_relative_eq!` with a custom epsilon for the Haversine case.

```rust
use geo::algorithm::line_measures::{Haversine, Euclidean, InterpolatableLine};
use geo::wkt;

let line_string = wkt!(LINESTRING(0. 0., 0. 10.,10. 10.));
let quarter_distance = line_string.point_at_ratio_from_end(&Euclidean, 0.25).unwrap();
assert_relative_eq!(quarter_distance, wkt!(POINT(5. 10.0)));

let quarter_distance = line_string.point_at_ratio_from_end(&Haversine, 0.25).unwrap();
assert_relative_eq!(quarter_distance, wkt!(POINT(4.961333045966285 10.037420806650719)), epsilon=1e-14);
```

--------------------------------

### Example: using BoundingRect with line_string

Source: https://docs.rs/geo/latest/geo/algorithm/bounding_rect/trait.BoundingRect.html

Shows how to use the BoundingRect trait on a line_string to get its bounding rectangle and assert the min and max coordinates.

```rust
use geo::BoundingRect;
use geo::line_string;

let line_string = line_string![
    (x: 40.02f64, y: 116.34),
    (x: 42.02f64, y: 116.34),
    (x: 42.02f64, y: 118.34),
];

let bounding_rect = line_string.bounding_rect().unwrap();

assert_eq!(40.02f64, bounding_rect.min().x);
assert_eq!(42.02f64, bounding_rect.max().x);
assert_eq!(116.34, bounding_rect.min().y);
assert_eq!(118.34, bounding_rect.max().y);
```

--------------------------------

### Create a Rect and compute its center

Source: https://docs.rs/geo/latest/geo/geometry/struct.Rect.html

Example from the struct-level documentation showing how to create a `Rect` using `Rect::new` with two coordinates, then verify its width, height, and center.

```rust
use geo_types::{coord, Rect};

let rect = Rect::new(
    coord! { x: 0., y: 4.},
    coord! { x: 3., y: 10.},
);

assert_eq!(3., rect.width());
assert_eq!(6., rect.height());
assert_eq!(
    coord! { x: 1.5, y: 7. },
    rect.center()
);
```

--------------------------------

### Rust example: point_at_distance_from_start with Euclidean and Haversine

Source: https://docs.rs/geo/latest/geo/algorithm/line_measures/trait.InterpolatableLine.html

Shows how to use `point_at_distance_from_start` with `Euclidean` and `Haversine` metric spaces. For Euclidean, distance is in the same units as the points; for Haversine, distance is in meters. The returned point is clamped to the line.

```rust
use geo::algorithm::line_measures::{Haversine, Euclidean, InterpolatableLine};
use geo::wkt;

let line_string = wkt!(LINESTRING(0. 0., 0. 10.,10. 10.));

// For Euclidean calculations, distance is in the same units as your points
let near_start = line_string.point_at_distance_from_start(&Euclidean, 0.5).unwrap();
assert_relative_eq!(near_start, wkt!(POINT(0. 0.5)));

// For Haversine calculations, distance is in meters
let near_start = line_string.point_at_distance_from_start(&Haversine, 100_000.0).unwrap();
assert_relative_eq!(near_start, wkt!(POINT(0. 0.899320363724538)), epsilon=1e-14);
```

--------------------------------

### Iterate over line segments in reverse with LineString::rev_lines

Source: https://docs.rs/geo/latest/geo/geometry/struct.LineString.html

Returns an iterator yielding one Line for each line segment, starting from the end point and working towards the start. The sequence and orientation of segments are reversed compared to lines(). The example asserts the reversed segments.

```rust
use geo_types::{wkt, Line, LineString};

let line_string = wkt!(LINESTRING(0 0,5 0,7 9));
let mut lines = line_string.rev_lines();

assert_eq!(
    Some(Line::new((7, 9), (5, 0))),
    lines.next()
);
assert_eq!(
    Some(Line::new((5, 0), (0, 0))),
    lines.next()
);
assert!(lines.next().is_none());
```

--------------------------------

### Example: Construct MonotoneChainLineString from LineString

Source: https://docs.rs/geo/latest/geo/algorithm/monotone_chain/struct.MonotoneChainLineString.html

Shows how to create a MonotoneChainLineString from a LineString using the line_string! macro and the From trait. The example uses f64 coordinates.

```rust
use geo::{LineString, line_string, MonotoneChainLineString};
let ls: LineString<f64> = line_string![(x: 0., y: 0.), (x: 10., y: 10.)];
let m_ls:MonotoneChainLineString<f64> = (&ls).into();
```

--------------------------------

### Scale a LineString from bounding box center with scale()

Source: https://docs.rs/geo/latest/geo/algorithm/scale/trait.Scale.html

Example for the scale method, which scales a geometry from its bounding box center by a uniform factor. The example creates a LineString and asserts the scaled result.

```Rust
use geo::Scale;
use geo::{LineString, line_string};

let ls: LineString = line_string![(x: 0., y: 0.), (x: 10., y: 10.)];

let scaled = ls.scale(2.);

assert_eq!(scaled, line_string![
    (x: -5., y: -5.),
    (x: 15., y: 15.)
]);
```

--------------------------------

### Rhumb.point_at_distance_between example

Source: https://docs.rs/geo/latest/geo/algorithm/line_measures/metric_spaces/struct.Rhumb.html

Shows how to interpolate a point along a rhumb line at a given distance in meters from the start point. Uses assert_relative_eq! with epsilon 1.0e-2 to verify results.

```rust
use geo::{Rhumb, InterpolatePoint};
use geo::Point;

let p1 = Point::new(10.0, 20.0);
let p2 = Point::new(125.0, 25.0);

let closer_to_p1 = Rhumb.point_at_distance_between(p1, p2, 100_000.0);
assert_relative_eq!(closer_to_p1, Point::new(10.96, 20.04), epsilon = 1.0e-2);

let closer_to_p2 = Rhumb.point_at_distance_between(p1, p2, 10_000_000.0);
assert_relative_eq!(closer_to_p2, Point::new(107.00, 24.23), epsilon = 1.0e-2);
```

--------------------------------

### Create a Rect with two corner coordinates

Source: https://docs.rs/geo/latest/geo/geometry/struct.Rect.html

Example from the `new` method documentation showing how to create a `Rect` from two corner coordinates and verify the minimum and maximum coordinates.

```rust
use geo_types::{coord, Rect};

let rect = Rect::new(
    coord! { x: 10., y: 20. },
    coord! { x: 30., y: 10. }
);
assert_eq!(rect.min(), coord! { x: 10., y: 10. });
assert_eq!(rect.max(), coord! { x: 30., y: 20. });
```

--------------------------------

### Usage syntax for point! macro

Source: https://docs.rs/geo/latest/geo/macro.point.html

Textual syntax examples showing how to call the `point!` macro with tagged coordinates or a single coordinate.

```txt
point! { x: <number>, y: <number> }
point!(<coordinate>)
```

--------------------------------

### Create a Line with Line::new and coord! macro

Source: https://docs.rs/geo/latest/geo/geometry/struct.Line.html

Example from the Line::new method documentation. Creates a line segment from two coordinates and asserts the start and end fields.

```rust
use geo_types::{coord, Line};

let line = Line::new(coord! { x: 0., y: 0. }, coord! { x: 1., y: 2. });

assert_eq!(line.start, coord! { x: 0., y: 0. });
assert_eq!(line.end, coord! { x: 1., y: 2. });
```

--------------------------------

### Rhumb.point_at_ratio_between example

Source: https://docs.rs/geo/latest/geo/algorithm/line_measures/metric_spaces/struct.Rhumb.html

Shows how to interpolate a point along a rhumb line at a given ratio (0.0 to 1.0) from the start point. Includes assertions for ratios 0.1, 0.9, and 0.5 (midpoint).

```rust
use geo::{Rhumb, InterpolatePoint};
use geo::Point;

let p1 = Point::new(10.0, 20.0);
let p2 = Point::new(125.0, 25.0);

let closer_to_p1 = Rhumb.point_at_ratio_between(p1, p2, 0.1);
assert_relative_eq!(closer_to_p1, Point::new(21.32, 20.50), epsilon = 1.0e-2);

let closer_to_p2 = Rhumb.point_at_ratio_between(p1, p2, 0.9);
assert_relative_eq!(closer_to_p2, Point::new(113.31, 24.50), epsilon = 1.0e-2);

let midpoint = Rhumb.point_at_ratio_between(p1, p2, 0.5);
assert_relative_eq!(midpoint, Point::new(66.98, 22.50), epsilon = 1.0e-2);
```
Tokens:
Raw