pub trait Geom: AsRaw<RawType = GEOSGeometry> + ContextHandling<Context = Arc<ContextHandle>> {
Show 89 methods
// Required methods
fn get_type(&self) -> GResult<String>;
fn geometry_type(&self) -> GeometryTypes;
fn is_valid(&self) -> bool;
fn is_valid_reason(&self) -> GResult<String>;
fn get_coord_seq(&self) -> GResult<CoordSeq>;
fn area(&self) -> GResult<f64>;
fn to_wkt(&self) -> GResult<String>;
fn to_wkt_precision(&self, precision: u32) -> GResult<String>;
fn is_ring(&self) -> GResult<bool>;
fn intersects<G: Geom>(&self, other: &G) -> GResult<bool>;
fn crosses<G: Geom>(&self, other: &G) -> GResult<bool>;
fn disjoint<G: Geom>(&self, other: &G) -> GResult<bool>;
fn touches<G: Geom>(&self, other: &G) -> GResult<bool>;
fn overlaps<G: Geom>(&self, other: &G) -> GResult<bool>;
fn within<G: Geom>(&self, other: &G) -> GResult<bool>;
fn equals<G: Geom>(&self, other: &G) -> GResult<bool>;
fn equals_exact<G: Geom>(&self, other: &G, precision: f64) -> GResult<bool>;
fn covers<G: Geom>(&self, other: &G) -> GResult<bool>;
fn covered_by<G: Geom>(&self, other: &G) -> GResult<bool>;
fn contains<G: Geom>(&self, other: &G) -> GResult<bool>;
fn buffer(&self, width: f64, quadsegs: i32) -> GResult<Geometry>;
fn buffer_with_params(
&self,
width: f64,
buffer_params: &BufferParams
) -> GResult<Geometry>;
fn buffer_with_style(
&self,
width: f64,
quadsegs: i32,
end_cap_style: CapStyle,
join_style: JoinStyle,
mitre_limit: f64
) -> GResult<Geometry>;
fn is_empty(&self) -> GResult<bool>;
fn is_simple(&self) -> GResult<bool>;
fn difference<G: Geom>(&self, other: &G) -> GResult<Geometry>;
fn envelope(&self) -> GResult<Geometry>;
fn sym_difference<G: Geom>(&self, other: &G) -> GResult<Geometry>;
fn union<G: Geom>(&self, other: &G) -> GResult<Geometry>;
fn get_centroid(&self) -> GResult<Geometry>;
fn unary_union(&self) -> GResult<Geometry>;
fn voronoi<G: Geom>(
&self,
envelope: Option<&G>,
tolerance: f64,
only_edges: bool
) -> GResult<Geometry>;
fn intersection<G: Geom>(&self, other: &G) -> GResult<Geometry>;
fn convex_hull(&self) -> GResult<Geometry>;
fn boundary(&self) -> GResult<Geometry>;
fn has_z(&self) -> GResult<bool>;
fn is_closed(&self) -> GResult<bool>;
fn length(&self) -> GResult<f64>;
fn distance<G: Geom>(&self, other: &G) -> GResult<f64>;
fn distance_indexed<G: Geom>(&self, other: &G) -> GResult<f64>;
fn hausdorff_distance<G: Geom>(&self, other: &G) -> GResult<f64>;
fn hausdorff_distance_densify<G: Geom>(
&self,
other: &G,
distance_frac: f64
) -> GResult<f64>;
fn frechet_distance<G: Geom>(&self, other: &G) -> GResult<f64>;
fn frechet_distance_densify<G: Geom>(
&self,
other: &G,
distance_frac: f64
) -> GResult<f64>;
fn get_length(&self) -> GResult<f64>;
fn snap<G: Geom>(&self, other: &G, tolerance: f64) -> GResult<Geometry>;
fn extract_unique_points(&self) -> GResult<Geometry>;
fn nearest_points<G: Geom>(&self, other: &G) -> GResult<CoordSeq>;
fn get_x(&self) -> GResult<f64>;
fn get_y(&self) -> GResult<f64>;
fn get_z(&self) -> GResult<f64>;
fn get_point_n(&self, n: usize) -> GResult<Geometry>;
fn get_start_point(&self) -> GResult<Geometry>;
fn get_end_point(&self) -> GResult<Geometry>;
fn get_num_points(&self) -> GResult<usize>;
fn get_num_interior_rings(&self) -> GResult<usize>;
fn get_num_coordinates(&self) -> GResult<usize>;
fn get_num_dimensions(&self) -> GResult<usize>;
fn get_coordinate_dimension(&self) -> GResult<Dimensions>;
fn make_valid(&self) -> GResult<Geometry>;
fn get_num_geometries(&self) -> GResult<usize>;
fn get_srid(&self) -> GResult<usize>;
fn get_precision(&self) -> GResult<f64>;
fn set_precision(
&self,
grid_size: f64,
flags: Precision
) -> GResult<Geometry>;
fn get_x_max(&self) -> GResult<f64>;
fn get_x_min(&self) -> GResult<f64>;
fn get_y_max(&self) -> GResult<f64>;
fn get_y_min(&self) -> GResult<f64>;
fn minimum_clearance(&self) -> GResult<f64>;
fn minimum_clearance_line(&self) -> GResult<Geometry>;
fn minimum_rotated_rectangle(&self) -> GResult<Geometry>;
fn minimum_width(&self) -> GResult<Geometry>;
fn delaunay_triangulation(
&self,
tolerance: f64,
only_edges: bool
) -> GResult<Geometry>;
fn interpolate(&self, d: f64) -> GResult<Geometry>;
fn interpolate_normalized(&self, d: f64) -> GResult<Geometry>;
fn project<G: Geom>(&self, p: &G) -> GResult<f64>;
fn project_normalized<G: Geom>(&self, p: &G) -> GResult<f64>;
fn node(&self) -> GResult<Geometry>;
fn offset_curve(
&self,
width: f64,
quadrant_segments: i32,
join_style: JoinStyle,
mitre_limit: f64
) -> GResult<Geometry>;
fn point_on_surface(&self) -> GResult<Geometry>;
fn polygonize_full(
&self
) -> GResult<(Geometry, Option<Geometry>, Option<Geometry>, Option<Geometry>)>;
fn shared_paths<G: Geom>(&self, other: &G) -> GResult<Geometry>;
fn to_hex(&self) -> GResult<CVec<u8>>;
fn to_wkb(&self) -> GResult<CVec<u8>>;
fn to_prepared_geom<'c>(&'c self) -> GResult<PreparedGeometry>;
fn clone(&self) -> Geometry;
fn get_geometry_n(&self, n: usize) -> GResult<ConstGeometry<'_>>;
fn get_interior_ring_n(&self, n: u32) -> GResult<ConstGeometry<'_>>;
fn get_exterior_ring(&self) -> GResult<ConstGeometry<'_>>;
}
Required Methods§
sourcefn get_type(&self) -> GResult<String>
fn get_type(&self) -> GResult<String>
Returns the type of the geometry.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POLYGON((0 0, 1 1, 1 2, 1 1, 0 0))")
.expect("Invalid geometry");
assert_eq!(geom.get_type(), Ok("Polygon".to_owned()));
fn geometry_type(&self) -> GeometryTypes
sourcefn is_valid(&self) -> bool
fn is_valid(&self) -> bool
Checks if the geometry is valid.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POLYGON((0 0, 1 1, 1 2, 1 1, 0 0))")
.expect("Invalid geometry");
assert!(geom.is_valid() == false);
sourcefn is_valid_reason(&self) -> GResult<String>
fn is_valid_reason(&self) -> GResult<String>
Returns an explanation on why the geometry is invalid.
§Example
use geos::{Geom, Geometry};
// Bowtie polygon with self-intersection
let geom = Geometry::new_from_wkt("POLYGON((0 0, 2 2, 2 0, 0 2, 0 0))")
.expect("Invalid geometry");
assert_eq!(
geom.is_valid_reason(),
Ok("Self-intersection[1 1]".to_owned()),
);
sourcefn get_coord_seq(&self) -> GResult<CoordSeq>
fn get_coord_seq(&self) -> GResult<CoordSeq>
Get the underlying geos CoordSeq object from the geometry
Note: this clones the underlying CoordSeq to avoid double free (because CoordSeq handles the object ptr and the CoordSeq is still owned by the geos geometry) if this method’s performance becomes a bottleneck, feel free to open an issue, we could skip this clone with cleaner code.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POINT (2 3)")
.expect("Invalid geometry");
let coord_seq = geom.get_coord_seq().expect("get_coord_seq failed");
assert_eq!(coord_seq.get_x(0), Ok(2.));
assert_eq!(coord_seq.get_y(0), Ok(3.));
sourcefn area(&self) -> GResult<f64>
fn area(&self) -> GResult<f64>
Returns the area of the geometry. Units are specified by the SRID of the given geometry.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POLYGON((0 0, 10 0, 10 6, 0 6, 0 0))")
.expect("Invalid geometry");
assert_eq!(geom1.area(), Ok(60.));
sourcefn to_wkt(&self) -> GResult<String>
fn to_wkt(&self) -> GResult<String>
Returns a WKT representation of the geometry. It defaults to 2 dimensions output. Use
WKTWriter
type directly if you want more control.
§Examples
use geos::{Geom, Geometry, OutputDimension, WKTWriter};
let point_geom = Geometry::new_from_wkt("POINT (2.5 2.5)")
.expect("Invalid geometry");
assert_eq!(
point_geom.to_wkt().unwrap(),
"POINT (2.5000000000000000 2.5000000000000000)",
);
// A three dimension point will be output just as a 2 dimension:
let point_geom = Geometry::new_from_wkt("POINT (2.5 2.5 3)")
.expect("Invalid geometry");
assert_eq!(
point_geom.to_wkt().unwrap(),
"POINT (2.5000000000000000 2.5000000000000000)",
);
// To "fix" it, use `WKTWriter` instead:
let mut wkt_writer = WKTWriter::new()
.expect("Failed to create WKTWriter");
wkt_writer.set_output_dimension(OutputDimension::ThreeD);
assert_eq!(
wkt_writer.write(&point_geom).unwrap(),
"POINT Z (2.5000000000000000 2.5000000000000000 3.0000000000000000)",
);
sourcefn to_wkt_precision(&self, precision: u32) -> GResult<String>
fn to_wkt_precision(&self, precision: u32) -> GResult<String>
Returns a WKT representation of the geometry with the given precision
. It is a wrapper
around WKTWriter::set_rounding_precision
.
§Example
use geos::{Geom, Geometry, WKTWriter};
let point_geom = Geometry::new_from_wkt("POINT (2.5 2.5)").expect("Invalid geometry");
assert_eq!(point_geom.to_wkt_precision(2).unwrap(), "POINT (2.50 2.50)");
// It is a wrapper around:
let mut writer = WKTWriter::new().expect("Failed to create WKTWriter");
writer.set_rounding_precision(2);
assert_eq!(writer.write(&point_geom).unwrap(), "POINT (2.50 2.50)");
sourcefn is_ring(&self) -> GResult<bool>
fn is_ring(&self) -> GResult<bool>
Returns true
if the geometry is a ring.
§Example
use geos::{Geom, Geometry};
let circle = Geometry::new_from_wkt("LINESTRING(0 0, 0 1, 1 1, 0 0)").expect("Invalid geometry");
assert_eq!(circle.is_ring(), Ok(true));
sourcefn intersects<G: Geom>(&self, other: &G) -> GResult<bool>
fn intersects<G: Geom>(&self, other: &G) -> GResult<bool>
Returns true
if self
shares any portion of space with other
. So if any of this is
true
:
self
overlapsother
self
touchesother
self
is withinother
Then intersects
will return true
as well.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POINT(0 0)").expect("invalid geometry");
let geom2 = Geometry::new_from_wkt("LINESTRING(2 0, 0 2)").expect("invalid geometry");
let geom3 = Geometry::new_from_wkt("LINESTRING(0 0, 0 2)").expect("invalid geometry");
assert_eq!(geom1.intersects(&geom2), Ok(false));
assert_eq!(geom1.intersects(&geom3), Ok(true));
sourcefn crosses<G: Geom>(&self, other: &G) -> GResult<bool>
fn crosses<G: Geom>(&self, other: &G) -> GResult<bool>
Returns true
if self
and other
have at least one interior into each other.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("LINESTRING(1 1,2 2)").expect("invalid geometry");
let geom2 = Geometry::new_from_wkt("LINESTRING(2 1,1 2)").expect("invalid geometry");
assert_eq!(geom1.crosses(&geom2), Ok(true));
sourcefn disjoint<G: Geom>(&self, other: &G) -> GResult<bool>
fn disjoint<G: Geom>(&self, other: &G) -> GResult<bool>
Returns true
if self
doesn’t:
- Overlap
other
- Touch
other
- Is within
other
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POINT(0 0)").expect("invalid geometry");
let geom2 = Geometry::new_from_wkt("LINESTRING(2 0, 0 2)").expect("invalid geometry");
let geom3 = Geometry::new_from_wkt("LINESTRING(0 0, 0 2)").expect("invalid geometry");
assert_eq!(geom1.disjoint(&geom2), Ok(true));
assert_eq!(geom1.disjoint(&geom3), Ok(false));
sourcefn touches<G: Geom>(&self, other: &G) -> GResult<bool>
fn touches<G: Geom>(&self, other: &G) -> GResult<bool>
Returns true
if the only points in common between self
and other
lie in the union of
the boundaries of self
and other
.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("LINESTRING(0 0, 1 1, 0 2)").expect("invalid geometry");
let geom2 = Geometry::new_from_wkt("POINT(1 1)").expect("invalid geometry");
assert_eq!(geom1.touches(&geom2), Ok(false));
let geom2 = Geometry::new_from_wkt("POINT(0 2)").expect("invalid geometry");
assert_eq!(geom1.touches(&geom2), Ok(true));
sourcefn overlaps<G: Geom>(&self, other: &G) -> GResult<bool>
fn overlaps<G: Geom>(&self, other: &G) -> GResult<bool>
Returns true
if self
spatially overlaps other
.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POINT(1 0.5)").expect("invalid geometry");
let geom2 = Geometry::new_from_wkt("LINESTRING(1 0, 1 1, 3 5)").expect("invalid geometry");
assert_eq!(geom1.overlaps(&geom2), Ok(false));
let geom1 = geom1.buffer(3., 8).expect("buffer failed");
let geom2 = geom2.buffer(0.5, 8).expect("buffer failed");
assert_eq!(geom1.overlaps(&geom2), Ok(true));
sourcefn within<G: Geom>(&self, other: &G) -> GResult<bool>
fn within<G: Geom>(&self, other: &G) -> GResult<bool>
Returns true
if self
is completely inside other
.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POINT(50 50)").expect("invalid geometry");
let small_geom = geom.buffer(20., 8).expect("buffer failed");
let big_geom = geom.buffer(40., 8).expect("buffer failed");
assert_eq!(small_geom.within(&small_geom), Ok(true));
assert_eq!(small_geom.within(&big_geom), Ok(true));
assert_eq!(big_geom.within(&small_geom), Ok(false));
sourcefn equals<G: Geom>(&self, other: &G) -> GResult<bool>
fn equals<G: Geom>(&self, other: &G) -> GResult<bool>
Checks if the two Geometry
objects are equal.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POINT (2.5 2.5)").expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("POINT (3.8 3.8)").expect("Invalid geometry");
let geom3 = Geometry::new_from_wkt("POINT (2.5 2.5)").expect("Invalid geometry");
assert!(geom1.equals(&geom2) == Ok(false));
assert!(geom1.equals(&geom3) == Ok(true));
Note that you can also use method through the PartialEq
trait:
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POINT (2.5 2.5)").expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("POINT (3.8 3.8)").expect("Invalid geometry");
let geom3 = Geometry::new_from_wkt("POINT (2.5 2.5)").expect("Invalid geometry");
assert!(geom1 != geom2);
assert!(geom1 == geom3);
sourcefn equals_exact<G: Geom>(&self, other: &G, precision: f64) -> GResult<bool>
fn equals_exact<G: Geom>(&self, other: &G, precision: f64) -> GResult<bool>
Checks if the two Geometry
objects are exactly equal.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POINT (2.5 2.5)").expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("POINT (3.8 3.8)").expect("Invalid geometry");
let geom3 = Geometry::new_from_wkt("POINT (2.5 2.5)").expect("Invalid geometry");
assert_eq!(geom1.equals_exact(&geom2, 0.1), Ok(false));
assert_eq!(geom1.equals_exact(&geom3, 0.1), Ok(true));
sourcefn covers<G: Geom>(&self, other: &G) -> GResult<bool>
fn covers<G: Geom>(&self, other: &G) -> GResult<bool>
Returns true
if no point of other
is outside of self
.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POINT (1 2)").expect("Invalid geometry");
let little_geom = geom.buffer(10., 8).expect("buffer failed");
let big_geom = geom.buffer(20., 8).expect("buffer failed");
assert_eq!(little_geom.covers(&big_geom), Ok(false));
assert_eq!(big_geom.covers(&little_geom), Ok(true));
sourcefn covered_by<G: Geom>(&self, other: &G) -> GResult<bool>
fn covered_by<G: Geom>(&self, other: &G) -> GResult<bool>
Returns true
if no point of self
is outside of other
.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POINT (1 2)").expect("Invalid geometry");
let little_geom = geom.buffer(10., 8).expect("buffer failed");
let big_geom = geom.buffer(20., 8).expect("buffer failed");
assert_eq!(little_geom.covered_by(&big_geom), Ok(true));
assert_eq!(big_geom.covered_by(&little_geom), Ok(false));
sourcefn contains<G: Geom>(&self, other: &G) -> GResult<bool>
fn contains<G: Geom>(&self, other: &G) -> GResult<bool>
Returns true
if no points of the other
geometry is outside the exterior of self
.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POLYGON((0 0, 10 0, 10 6, 0 6, 0 0))").expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("POINT (2.5 2.5)").expect("Invalid geometry");
assert_eq!(geom1.contains(&geom2), Ok(true));
sourcefn buffer(&self, width: f64, quadsegs: i32) -> GResult<Geometry>
fn buffer(&self, width: f64, quadsegs: i32) -> GResult<Geometry>
Returns a geometry which represents all points whose distance from self
is less than or
equal to distance.
You can find nice examples about this in postgis documentation.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POINT(1 3)").expect("Invalid geometry");
let buffer_geom = geom.buffer(50., 2).expect("buffer failed");
assert_eq!(buffer_geom.to_wkt_precision(1).unwrap(),
"POLYGON ((51.0 3.0, 36.4 -32.4, 1.0 -47.0, -34.4 -32.4, -49.0 3.0, -34.4 38.4, \
1.0 53.0, 36.4 38.4, 51.0 3.0))");
sourcefn buffer_with_params(
&self,
width: f64,
buffer_params: &BufferParams
) -> GResult<Geometry>
fn buffer_with_params( &self, width: f64, buffer_params: &BufferParams ) -> GResult<Geometry>
Returns a geometry which represents all points whose distance from self
is less than or
equal to distance.
The explicit buffer_params
argument passing is more efficient than
the otherwise identical (except for the single_sided
option is missing)
buffer_with_style
method when the same BufferParams
is reused.
You can find nice examples and details about the BufferParams
options in this
postgis documentation.
§Example
use geos::{BufferParams, CapStyle, Geom, Geometry, JoinStyle};
let geom = Geometry::new_from_wkt("POINT(1 3)").expect("Invalid geometry");
let params = BufferParams::builder()
.end_cap_style(CapStyle::Round)
.join_style(JoinStyle::Round)
.mitre_limit(5.0)
.quadrant_segments(8)
.single_sided(false)
.build()
.expect("build BufferParams");
let buffer_geom = geom.buffer_with_params(2., ¶ms).expect("buffer_with_params failed");
assert_eq!(buffer_geom.to_wkt_precision(1).unwrap(),
"POLYGON ((3.0 3.0, 3.0 2.6, 2.8 2.2, 2.7 1.9, 2.4 1.6, 2.1 1.3, 1.8 1.2, 1.4 1.0, \
1.0 1.0, 0.6 1.0, 0.2 1.2, -0.1 1.3, -0.4 1.6, -0.7 1.9, -0.8 2.2, -1.0 2.6, \
-1.0 3.0, -1.0 3.4, -0.8 3.8, -0.7 4.1, -0.4 4.4, -0.1 4.7, 0.2 4.8, 0.6 5.0, \
1.0 5.0, 1.4 5.0, 1.8 4.8, 2.1 4.7, 2.4 4.4, 2.7 4.1, 2.8 3.8, 3.0 3.4, \
3.0 3.0))");
sourcefn buffer_with_style(
&self,
width: f64,
quadsegs: i32,
end_cap_style: CapStyle,
join_style: JoinStyle,
mitre_limit: f64
) -> GResult<Geometry>
fn buffer_with_style( &self, width: f64, quadsegs: i32, end_cap_style: CapStyle, join_style: JoinStyle, mitre_limit: f64 ) -> GResult<Geometry>
Returns a geometry which represents all points whose distance from self
is less than or
equal to distance.
If the same paramters are used many times it’s more efficient to use the
buffer_with_params
operation.
You can find nice examples and details about the options in this postgis documentation.
§Example
use geos::{CapStyle, Geom, Geometry, JoinStyle};
let geom = Geometry::new_from_wkt("POINT(1 3)").expect("Invalid geometry");
let buffer_geom = geom.buffer_with_style(
2., 8, CapStyle::Round, JoinStyle::Round, 5.
).expect("buffer_with_style failed");
assert_eq!(buffer_geom.to_wkt_precision(1).unwrap(),
"POLYGON ((3.0 3.0, 3.0 2.6, 2.8 2.2, 2.7 1.9, 2.4 1.6, 2.1 1.3, 1.8 1.2, \
1.4 1.0, 1.0 1.0, 0.6 1.0, 0.2 1.2, -0.1 1.3, -0.4 1.6, -0.7 1.9, -0.8 2.2, \
-1.0 2.6, -1.0 3.0, -1.0 3.4, -0.8 3.8, -0.7 4.1, -0.4 4.4, -0.1 4.7, 0.2 4.8, \
0.6 5.0, 1.0 5.0, 1.4 5.0, 1.8 4.8, 2.1 4.7, 2.4 4.4, 2.7 4.1, 2.8 3.8, \
3.0 3.4, 3.0 3.0))");
sourcefn is_empty(&self) -> GResult<bool>
fn is_empty(&self) -> GResult<bool>
Returns true
if the given geometry is empty.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::create_empty_polygon().expect("Invalid geometry");
assert_eq!(geom.is_empty(), Ok(true));
let geom = Geometry::new_from_wkt("POLYGON EMPTY").expect("Invalid geometry");
assert_eq!(geom.is_empty(), Ok(true));
let geom = Geometry::new_from_wkt("POINT(1 3)").expect("Invalid geometry");
assert_eq!(geom.is_empty(), Ok(false));
sourcefn is_simple(&self) -> GResult<bool>
fn is_simple(&self) -> GResult<bool>
Returns true if the given geometry has no anomalous geometric points, such as self intersection or self tangency.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POINT (2.5 2.5)")
.expect("Invalid geometry");
assert_eq!(geom.is_simple(), Ok(true));
let geom = Geometry::new_from_wkt("LINESTRING(1 1,2 2,2 3.5,1 3,1 2,2 1)")
.expect("Invalid geometry");
assert_eq!(geom.is_simple(), Ok(false));
sourcefn difference<G: Geom>(&self, other: &G) -> GResult<Geometry>
fn difference<G: Geom>(&self, other: &G) -> GResult<Geometry>
Returns a geometry which represents part of self
that doesn’t intersect with other
.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("LINESTRING(50 100, 50 200)").expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("LINESTRING(50 50, 50 150)").expect("Invalid geometry");
let difference_geom = geom1.difference(&geom2).expect("envelope failed");
assert_eq!(difference_geom.to_wkt_precision(1).unwrap(),
"LINESTRING (50.0 150.0, 50.0 200.0)");
sourcefn envelope(&self) -> GResult<Geometry>
fn envelope(&self) -> GResult<Geometry>
Returns the minimum bouding box of the given geometry.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POINT(1 3)").expect("Invalid geometry");
let envelope_geom = geom.envelope().expect("envelope failed");
assert_eq!(envelope_geom.to_wkt_precision(1).unwrap(), "POINT (1.0 3.0)");
let geom = Geometry::new_from_wkt("LINESTRING(0 0, 1 3)").expect("Invalid geometry");
let envelope_geom = geom.envelope().expect("envelope failed");
assert_eq!(envelope_geom.to_wkt_precision(1).unwrap(),
"POLYGON ((0.0 0.0, 1.0 0.0, 1.0 3.0, 0.0 3.0, 0.0 0.0))");
sourcefn sym_difference<G: Geom>(&self, other: &G) -> GResult<Geometry>
fn sym_difference<G: Geom>(&self, other: &G) -> GResult<Geometry>
Returns a geometry which represents the parts of self
and other
that don’t intersect.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("LINESTRING(50 100, 50 200)").expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("LINESTRING(50 50, 50 150)").expect("Invalid geometry");
let sym_diff_geom = geom1.sym_difference(&geom2).expect("sym_difference failed");
assert_eq!(
sym_diff_geom.to_wkt_precision(1).unwrap(),
"MULTILINESTRING ((50.0 150.0, 50.0 200.0), (50.0 50.0, 50.0 100.0))",
);
sourcefn union<G: Geom>(&self, other: &G) -> GResult<Geometry>
fn union<G: Geom>(&self, other: &G) -> GResult<Geometry>
Aggregates the given geometry with another one.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POINT(1 2)").expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("POINT(3 4)").expect("Invalid geometry");
let union_geom = geom1.union(&geom2).expect("union failed");
assert_eq!(union_geom.to_wkt_precision(1).unwrap(), "MULTIPOINT (1.0 2.0, 3.0 4.0)");
sourcefn get_centroid(&self) -> GResult<Geometry>
fn get_centroid(&self) -> GResult<Geometry>
Returns the geometric center or (equivalently) the center of mass of the given geometry as a point.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("MULTIPOINT(-1 0, -1 2, -1 3, -1 4, -1 7, 0 1, 0 3, 1 1)")
.expect("Invalid geometry");
let centroid = geom.get_centroid().expect("failed to get centroid");
assert_eq!(centroid.to_wkt_precision(1).unwrap(), "POINT (-0.5 2.6)");
sourcefn unary_union(&self) -> GResult<Geometry>
fn unary_union(&self) -> GResult<Geometry>
Documentation from postgis:
Unlike ST_Union, ST_UnaryUnion does dissolve boundaries between components of a multipolygon (invalid) and does perform union between the components of a geometrycollection. Each components of the input geometry is assumed to be valid, so you won’t get a valid multipolygon out of a bow-tie polygon (invalid).
You may use this function to node a set of linestrings. You may mix ST_UnaryUnion with ST_Collect to fine-tune how many geometries at once you want to dissolve to be nice on both memory size and CPU time, finding the balance between ST_Union and ST_MemUnion.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POLYGON((0 0, 10 0, 10 6, 0 6, 0 0))")
.expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("POLYGON((1 1, 2 1, 2 5, 1 5, 1 1))")
.expect("Invalid geometry");
let geom = Geometry::create_multipolygon(vec![geom1, geom2])
.expect("Failed to build multipolygon");
let mut union_geom = geom.unary_union().expect("unary_union failed");
union_geom.normalize().expect("normalize failed");
assert_eq!(
union_geom.to_wkt_precision(1).unwrap(),
"POLYGON ((0.0 0.0, 0.0 6.0, 10.0 6.0, 10.0 0.0, 0.0 0.0))",
);
sourcefn voronoi<G: Geom>(
&self,
envelope: Option<&G>,
tolerance: f64,
only_edges: bool
) -> GResult<Geometry>
fn voronoi<G: Geom>( &self, envelope: Option<&G>, tolerance: f64, only_edges: bool ) -> GResult<Geometry>
Create a voronoi diagram.
§Example
use geos::{Geom, Geometry};
let input = Geometry::new_from_wkt("MULTIPOINT(2 2, 4 2)")
.expect("Invalid geometry");
let mut expected = Geometry::new_from_wkt(
"GEOMETRYCOLLECTION (POLYGON ((0 0, 0 4, 3 4, 3 0, 0 0)), POLYGON ((6 4, 6 0, 3 0, 3 4, 6 4)))")
.expect("Invalid geometry");
let mut voronoi = input.voronoi(None::<&Geometry>, 0., false)
.expect("voronoi failed");
expected.normalize().expect("normalize failed");
voronoi.normalize().expect("normalize failed");
assert_eq!(expected.equals(&voronoi), Ok(true));
sourcefn intersection<G: Geom>(&self, other: &G) -> GResult<Geometry>
fn intersection<G: Geom>(&self, other: &G) -> GResult<Geometry>
Returns a geometry representing the intersection between self
and other
.
§Example
use geos::{Geom, Geometry};
let mut geom1 = Geometry::new_from_wkt("POINT(0 0)").expect("Invalid geometry");
let mut geom2 = Geometry::new_from_wkt("LINESTRING(2 0, 0 2)").expect("Invalid geometry");
let intersection_geom = geom1.intersection(&geom2).expect("intersection failed");
// No intersection.
assert_eq!(intersection_geom.is_empty(), Ok(true));
// We slighty change the linestring so we have an intersection:
let mut geom2 = Geometry::new_from_wkt("LINESTRING(0 0, 0 2)").expect("Invalid geometry");
let intersection_geom = geom1.intersection(&geom2).expect("intersection failed");
// Intersection!
assert_eq!(intersection_geom.to_wkt_precision(1).unwrap(), "POINT (0.0 0.0)");
sourcefn convex_hull(&self) -> GResult<Geometry>
fn convex_hull(&self) -> GResult<Geometry>
Documentation from postgis:
The convex hull of a geometry represents the minimum convex geometry that encloses all geometries within the set.
One can think of the convex hull as the geometry you get by wrapping an elastic band around a set of geometries. This is different from a concave hull which is analogous to shrink-wrapping your geometries.
It is usually used with MULTI and Geometry Collections. Although it is not an aggregate - you can use it in conjunction with ST_Collect to get the convex hull of a set of points. ST_ConvexHull(ST_Collect(somepointfield)).
It is often used to determine an affected area based on a set of point observations.
§Example
use geos::{Geom, Geometry};
let mut geom1 = Geometry::new_from_wkt("MULTILINESTRING((100 190,10 8),
(150 10, 20 30))")
.expect("Invalid geometry");
let mut geom2 = Geometry::new_from_wkt("MULTIPOINT(50 5, 150 30, 50 10, 10 10)")
.expect("Invalid geometry");
let geom = geom1.union(&geom2).expect("union failed");
let convex_hull_geom = geom.convex_hull().expect("convex_hull failed");
assert_eq!(convex_hull_geom.to_wkt_precision(1).unwrap(),
"POLYGON ((50.0 5.0, 10.0 8.0, 10.0 10.0, 100.0 190.0, 150.0 30.0, 150.0 10.0, 50.0 5.0))");
sourcefn boundary(&self) -> GResult<Geometry>
fn boundary(&self) -> GResult<Geometry>
Returns the closure of the combinatorial boundary of self
.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("LINESTRING(1 1,0 0, -1 1)").expect("Invalid geometry");
let boundary_geom = geom.boundary().expect("boundary failed");
assert_eq!(boundary_geom.to_wkt_precision(1).unwrap(), "MULTIPOINT (1.0 1.0, -1.0 1.0)");
sourcefn has_z(&self) -> GResult<bool>
fn has_z(&self) -> GResult<bool>
Returns true
if self
has a Z coordinate.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POINT(1 2 3)").expect("Invalid geometry");
assert_eq!(geom.has_z(), Ok(true));
let geom = Geometry::new_from_wkt("POINT(1 2)").expect("Invalid geometry");
assert_eq!(geom.has_z(), Ok(false));
sourcefn is_closed(&self) -> GResult<bool>
fn is_closed(&self) -> GResult<bool>
Returns true
if start and end point are coincident.
Only works on LineString
and MultiLineString
.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("LINESTRING(0 0, 1 1)").expect("Invalid geometry");
assert_eq!(geom.is_closed(), Ok(false));
let geom = Geometry::new_from_wkt("LINESTRING(0 0, 0 1, 1 1, 0 0)").expect("Invalid geometry");
assert_eq!(geom.is_closed(), Ok(true));
let geom = Geometry::new_from_wkt("MULTILINESTRING((0 0, 0 1, 1 1, 0 0),(0 0, 1 1))")
.expect("Invalid geometry");
assert_eq!(geom.is_closed(), Ok(false));
sourcefn length(&self) -> GResult<f64>
fn length(&self) -> GResult<f64>
Returns the length of self
. The unit depends of the SRID.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("LINESTRING(743238 2967416,743238 2967450)")
.expect("Invalid geometry");
assert_eq!(
geom.length().map(|x| format!("{:.2}", x)).unwrap(),
"34.00",
);
sourcefn distance<G: Geom>(&self, other: &G) -> GResult<f64>
fn distance<G: Geom>(&self, other: &G) -> GResult<f64>
Returns the distance between self
and other
. The unit depends of the SRID.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POINT (1 2)").expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("POINT (2 2)").expect("Invalid geometry");
assert_eq!(geom1.distance(&geom2).map(|x| format!("{:.2}", x)).unwrap(), "1.00");
sourcefn distance_indexed<G: Geom>(&self, other: &G) -> GResult<f64>
fn distance_indexed<G: Geom>(&self, other: &G) -> GResult<f64>
Returns the indexed distance between self
and other
. The unit depends of the SRID.
Available using the v3_7_0
feature.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POINT (1 2)").expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("POINT (2 2)").expect("Invalid geometry");
assert_eq!(geom1.distance_indexed(&geom2).map(|x| format!("{:.2}", x)).unwrap(), "1.00");
sourcefn hausdorff_distance<G: Geom>(&self, other: &G) -> GResult<f64>
fn hausdorff_distance<G: Geom>(&self, other: &G) -> GResult<f64>
Returns the hausdorff distance between self
and other
. The unit depends of the SRID.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POINT (1 2)").expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("POINT (2 2)").expect("Invalid geometry");
assert_eq!(geom1.hausdorff_distance(&geom2).map(|x| format!("{:.2}", x)).unwrap(), "1.00");
sourcefn hausdorff_distance_densify<G: Geom>(
&self,
other: &G,
distance_frac: f64
) -> GResult<f64>
fn hausdorff_distance_densify<G: Geom>( &self, other: &G, distance_frac: f64 ) -> GResult<f64>
Returns the hausdorff distance between self
and other
. The unit depends of the SRID.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POINT (1 2)").expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("POINT (2 2)").expect("Invalid geometry");
assert_eq!(geom1.hausdorff_distance_densify(&geom2, 1.).map(|x| format!("{:.2}", x))
.unwrap(), "1.00");
sourcefn frechet_distance<G: Geom>(&self, other: &G) -> GResult<f64>
fn frechet_distance<G: Geom>(&self, other: &G) -> GResult<f64>
Returns the frechet distance between self
and other
. The unit depends of the SRID.
Available using the v3_7_0
feature.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("LINESTRING (0 0, 100 0)").expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("LINESTRING (0 0, 50 50, 100 0)").expect("Invalid geometry");
assert_eq!(geom1.frechet_distance(&geom2).map(|x| format!("{:.2}", x)).unwrap(), "70.71");
sourcefn frechet_distance_densify<G: Geom>(
&self,
other: &G,
distance_frac: f64
) -> GResult<f64>
fn frechet_distance_densify<G: Geom>( &self, other: &G, distance_frac: f64 ) -> GResult<f64>
Returns the frechet distance between self
and other
. The unit depends of the SRID.
Available using the v3_7_0
feature.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("LINESTRING (0 0, 100 0)").expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("LINESTRING (0 0, 50 50, 100 0)").expect("Invalid geometry");
assert_eq!(geom1.frechet_distance_densify(&geom2, 1.).map(|x| format!("{:.2}", x))
.unwrap(), "70.71");
sourcefn get_length(&self) -> GResult<f64>
fn get_length(&self) -> GResult<f64>
Returns the length of the given geometry.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("LINESTRING (1 2, 3 4, 5 6)")
.expect("Invalid geometry");
assert_eq!(geom.get_length().map(|x| format!("{:.2}", x)).unwrap(), "5.66");
sourcefn snap<G: Geom>(&self, other: &G, tolerance: f64) -> GResult<Geometry>
fn snap<G: Geom>(&self, other: &G, tolerance: f64) -> GResult<Geometry>
Documentation from postgis:
Snaps the vertices and segments of a geometry another Geometry’s vertices. A snap distance tolerance is used to control where snapping is performed. The result geometry is the input geometry with the vertices snapped. If no snapping occurs then the input geometry is returned unchanged.
Snapping one geometry to another can improve robustness for overlay operations by eliminating nearly-coincident edges (which cause problems during noding and intersection calculation).
Too much snapping can result in invalid topology being created, so the number and location of snapped vertices is decided using heuristics to determine when it is safe to snap. This can result in some potential snaps being omitted, however.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("MULTIPOLYGON(((26 125, 26 200, 126 200, 126 125, 26 125),
(51 150, 101 150, 76 175, 51 150)),
((151 100, 151 200, 176 175, 151 100)))")
.expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("LINESTRING(5 107, 54 84, 101 100)")
.expect("Invalid geometry");
let distance = geom1.distance(&geom2).expect("distance failed");
let snap_geom = geom1.snap(&geom2, distance * 1.25).expect("snap failed");
assert_eq!(snap_geom.to_wkt_precision(1).unwrap(),
"MULTIPOLYGON (((5.0 107.0, 26.0 200.0, 126.0 200.0, 126.0 125.0, 101.0 100.0, 54.0 84.0, 5.0 107.0), \
(51.0 150.0, 101.0 150.0, 76.0 175.0, 51.0 150.0)), \
((151.0 100.0, 151.0 200.0, 176.0 175.0, 151.0 100.0)))");
sourcefn extract_unique_points(&self) -> GResult<Geometry>
fn extract_unique_points(&self) -> GResult<Geometry>
Returns unique points of self
.
fn nearest_points<G: Geom>(&self, other: &G) -> GResult<CoordSeq>
sourcefn get_x(&self) -> GResult<f64>
fn get_x(&self) -> GResult<f64>
Returns the X position. The given Geometry
must be a Point
, otherwise it’ll fail.
§Example
use geos::{Geom, Geometry};
let point_geom = Geometry::new_from_wkt("POINT (1.5 2.5 3.5)").expect("Invalid geometry");
assert!(point_geom.get_x() == Ok(1.5));
sourcefn get_y(&self) -> GResult<f64>
fn get_y(&self) -> GResult<f64>
Returns the Y position. The given Geometry
must be a Point
, otherwise it’ll fail.
§Example
use geos::{Geom, Geometry};
let point_geom = Geometry::new_from_wkt("POINT (1.5 2.5 3.5)").expect("Invalid geometry");
assert!(point_geom.get_y() == Ok(2.5));
sourcefn get_z(&self) -> GResult<f64>
fn get_z(&self) -> GResult<f64>
Returns the Z position. The given Geometry
must be a Point
, otherwise it’ll fail.
Available using the v3_7_0
feature.
§Example
use geos::{Geom, Geometry};
let point_geom = Geometry::new_from_wkt("POINT (2.5 2.5 4.0)").expect("Invalid geometry");
assert!(point_geom.get_z() == Ok(4.0));
sourcefn get_point_n(&self, n: usize) -> GResult<Geometry>
fn get_point_n(&self, n: usize) -> GResult<Geometry>
Returns the nth point of the given geometry.
The given Geometry
must be a LineString
, otherwise it’ll fail.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("LINESTRING (1 2, 3 4, 5 6)")
.expect("Invalid geometry");
let nth_point = geom.get_point_n(1).expect("get_point_n failed");
assert_eq!(nth_point.to_wkt_precision(1).unwrap(), "POINT (3.0 4.0)");
sourcefn get_start_point(&self) -> GResult<Geometry>
fn get_start_point(&self) -> GResult<Geometry>
Returns the start point of self
.
The given Geometry
must be a LineString
, otherwise it’ll fail.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("LINESTRING (1 2, 3 4)")
.expect("Invalid geometry");
let start_point = geom.get_start_point().expect("get_start_point failed");
assert_eq!(start_point.to_wkt_precision(1).unwrap(), "POINT (1.0 2.0)");
sourcefn get_end_point(&self) -> GResult<Geometry>
fn get_end_point(&self) -> GResult<Geometry>
Returns the end point of self
.
The given Geometry
must be a LineString
, otherwise it’ll fail.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("LINESTRING (1 2, 3 4)")
.expect("Invalid geometry");
let end_point = geom.get_end_point().expect("get_end_point failed");
assert_eq!(end_point.to_wkt_precision(1).unwrap(), "POINT (3.0 4.0)");
sourcefn get_num_points(&self) -> GResult<usize>
fn get_num_points(&self) -> GResult<usize>
Returns the number of points of self
.
The given Geometry
must be a LineString
, otherwise it’ll fail.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("LINESTRING (1 2, 3 4)")
.expect("Invalid geometry");
assert_eq!(geom.get_num_points(), Ok(2));
sourcefn get_num_interior_rings(&self) -> GResult<usize>
fn get_num_interior_rings(&self) -> GResult<usize>
Returns the number of interior rings.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POLYGON((0 0, 10 0, 10 6, 0 6, 0 0),\
(1 1, 2 1, 2 5, 1 5, 1 1),\
(8 5, 8 4, 9 4, 9 5, 8 5))")
.expect("Invalid geometry");
assert_eq!(geom.get_num_interior_rings(), Ok(2));
sourcefn get_num_coordinates(&self) -> GResult<usize>
fn get_num_coordinates(&self) -> GResult<usize>
Returns the number of coordinates inside self
.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POLYGON((0 0, 10 0, 10 6, 0 6, 0 0))")
.expect("Invalid geometry");
assert_eq!(geom.get_num_coordinates(), Ok(5));
sourcefn get_num_dimensions(&self) -> GResult<usize>
fn get_num_dimensions(&self) -> GResult<usize>
Returns the number of dimensions used in self
.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POLYGON((0 0, 10 0, 10 6, 0 6, 0 0))")
.expect("Invalid geometry");
assert_eq!(geom.get_num_dimensions(), Ok(2));
sourcefn get_coordinate_dimension(&self) -> GResult<Dimensions>
fn get_coordinate_dimension(&self) -> GResult<Dimensions>
Return in which coordinate dimension the geometry is.
§Example
use geos::{Dimensions, Geom, Geometry};
let point_geom = Geometry::new_from_wkt("POINT (2.5 2.5 4.0)").expect("Invalid geometry");
assert!(point_geom.get_coordinate_dimension() == Ok(Dimensions::ThreeD));
let point_geom = Geometry::new_from_wkt("POINT (2.5 4.0)").expect("Invalid geometry");
assert!(point_geom.get_coordinate_dimension() == Ok(Dimensions::TwoD));
sourcefn make_valid(&self) -> GResult<Geometry>
fn make_valid(&self) -> GResult<Geometry>
This functions attempts to return a valid representation of self
.
Available using the v3_8_0
feature.
sourcefn get_num_geometries(&self) -> GResult<usize>
fn get_num_geometries(&self) -> GResult<usize>
Returns the number of geometries.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("LINESTRING(77.29 29.07,77.42 29.26,77.27 29.31,77.29 29.07)")
.expect("Invalid geometry");
assert_eq!(geom.get_num_geometries(), Ok(1));
let geom = Geometry::new_from_wkt("GEOMETRYCOLLECTION(MULTIPOINT(-2 3 , -2 2),\
LINESTRING(5 5 ,10 10),\
POLYGON((-7 4.2,-7.1 5,-7.1 4.3,-7 4.2)))")
.expect("Invalid geometry");
assert_eq!(geom.get_num_geometries(), Ok(3));
sourcefn get_srid(&self) -> GResult<usize>
fn get_srid(&self) -> GResult<usize>
Get SRID of self
.
§Example
use geos::{Geom, Geometry};
let mut point_geom = Geometry::new_from_wkt("POINT (2.5 2.5 4.0)")
.expect("Invalid geometry");
point_geom.set_srid(4326);
assert_eq!(point_geom.get_srid(), Ok(4326));
sourcefn get_precision(&self) -> GResult<f64>
fn get_precision(&self) -> GResult<f64>
Returns the precision of self
.
Available using the v3_6_0
feature.
§Example
use geos::{Geom, Geometry};
let point_geom = Geometry::new_from_wkt("POINT (2.5 2.5 4.0)").expect("Invalid geometry");
assert_eq!(point_geom.get_precision().map(|x| format!("{:.2}", x)).unwrap(), "0.00");
sourcefn set_precision(&self, grid_size: f64, flags: Precision) -> GResult<Geometry>
fn set_precision(&self, grid_size: f64, flags: Precision) -> GResult<Geometry>
Returns the precision of self
.
Available using the v3_6_0
feature.
§Example
use geos::{Geom, Geometry, Precision};
let point_geom = Geometry::new_from_wkt("POINT (2.5 2.5 4.0)").expect("Invalid geometry");
point_geom.set_precision(1., Precision::KeepCollapsed);
assert_eq!(point_geom.get_precision().map(|x| format!("{:.2}", x)).unwrap(), "0.00");
sourcefn get_x_max(&self) -> GResult<f64>
fn get_x_max(&self) -> GResult<f64>
Returns the biggest X of the geometry.
Available using the v3_7_0
feature.
§Example
use geos::{Geom, Geometry};
let line = Geometry::new_from_wkt("LINESTRING(1 3 4, 5 6 7)").expect("Invalid WKT");
assert_eq!(line.get_x_max(), Ok(5.));
sourcefn get_x_min(&self) -> GResult<f64>
fn get_x_min(&self) -> GResult<f64>
Returns the smallest X of the geometry.
Available using the v3_7_0
feature.
§Example
use geos::{Geom, Geometry};
let line = Geometry::new_from_wkt("LINESTRING(1 3 4, 5 6 7)").expect("Invalid WKT");
assert_eq!(line.get_x_min(), Ok(1.));
sourcefn get_y_max(&self) -> GResult<f64>
fn get_y_max(&self) -> GResult<f64>
Returns the biggest Y of the geometry.
Available using the v3_7_0
feature.
§Example
use geos::{Geom, Geometry};
let line = Geometry::new_from_wkt("LINESTRING(1 3 4, 5 6 7)").expect("Invalid WKT");
assert_eq!(line.get_y_max(), Ok(6.));
sourcefn get_y_min(&self) -> GResult<f64>
fn get_y_min(&self) -> GResult<f64>
Returns the smallest Y of the geometry.
Available using the v3_7_0
feature.
§Example
use geos::{Geom, Geometry};
let line = Geometry::new_from_wkt("LINESTRING(1 3 4, 5 6 7)").expect("Invalid WKT");
assert_eq!(line.get_y_min(), Ok(3.));
sourcefn minimum_clearance(&self) -> GResult<f64>
fn minimum_clearance(&self) -> GResult<f64>
Returns the smallest distance by which a vertex of self
could be moved to produce an
invalid geometry.
Available using the v3_6_0
feature.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("LINESTRING(1 3 4, 5 6 7)").expect("Invalid WKT");
assert_eq!(geom.minimum_clearance().map(|x| format!("{:.8}", x)).unwrap(), "5.00000000");
sourcefn minimum_clearance_line(&self) -> GResult<Geometry>
fn minimum_clearance_line(&self) -> GResult<Geometry>
Returns the two-point LineString spanning of self
’s minimum clearance.
Available using the v3_6_0
feature.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POLYGON ((0 0, 1 0, 1 1, 0.5 3.2e-4, 0 0))")
.expect("Invalid WKT");
let line = geom.minimum_clearance_line().expect("minimum_clearance_line failed");
assert_eq!(line.to_wkt_precision(1).unwrap(), "LINESTRING (0.5 0.0, 0.5 0.0)");
sourcefn minimum_rotated_rectangle(&self) -> GResult<Geometry>
fn minimum_rotated_rectangle(&self) -> GResult<Geometry>
Returns the minimum rotated rectangle inside of self
.
Available using the v3_6_0
feature.
sourcefn minimum_width(&self) -> GResult<Geometry>
fn minimum_width(&self) -> GResult<Geometry>
Returns the minimum width inside of self
.
Available using the v3_6_0
feature.
sourcefn delaunay_triangulation(
&self,
tolerance: f64,
only_edges: bool
) -> GResult<Geometry>
fn delaunay_triangulation( &self, tolerance: f64, only_edges: bool ) -> GResult<Geometry>
Returns a delaunay triangulation
around the vertices of self
.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POLYGON((175 150, 20 40, 50 60, 125 100, 175 150))")
.expect("Invalid WKT");
let geom2 = Geometry::new_from_wkt("POINT(110 170)").expect("Invalid WKT");
let geom2 = geom2.buffer(20., 8).expect("buffer failed");
let geom = geom1.union(&geom2).expect("union failed");
let final_geom = geom.delaunay_triangulation(0.001, false).expect("delaunay_triangulation failed");
fn interpolate(&self, d: f64) -> GResult<Geometry>
fn interpolate_normalized(&self, d: f64) -> GResult<Geometry>
fn project<G: Geom>(&self, p: &G) -> GResult<f64>
fn project_normalized<G: Geom>(&self, p: &G) -> GResult<f64>
fn node(&self) -> GResult<Geometry>
sourcefn offset_curve(
&self,
width: f64,
quadrant_segments: i32,
join_style: JoinStyle,
mitre_limit: f64
) -> GResult<Geometry>
fn offset_curve( &self, width: f64, quadrant_segments: i32, join_style: JoinStyle, mitre_limit: f64 ) -> GResult<Geometry>
Return an offset line at a given distance and side from an input line. All points of the returned geometries are not further than the given distance from the input geometry.
§Parameters description:
§width
- If
width
is positive, the offset will be at the left side of the input line and retain the same direction. - If
width
is negative, it’ll be at the right side and in the opposite direction.
§quadrant_segments
- If
quadrant_segments
is >= 1, joins are round, andquadrant_segments
indicates the number of segments to use to approximate a quarter-circle. - If
quadrant_segments
== 0, joins are bevelled (flat). - If
quadrant_segments
< 0, joins are mitred, and the value ofquadrant_segments
indicates the mitre ration limit asmitre_limit = |quadrant_segments|
§mitre_limit
The mitre ratio is the ratio of the distance from the corner to the end of the mitred offset corner. When two line segments meet at a sharp angle, a miter join will extend far beyond the original geometry (and in the extreme case will be infinitely far). To prevent unreasonable geometry, the mitre limit allows controlling the maximum length of the join corner. Corners with a ratio which exceed the limit will be beveled.
fn point_on_surface(&self) -> GResult<Geometry>
sourcefn polygonize_full(
&self
) -> GResult<(Geometry, Option<Geometry>, Option<Geometry>, Option<Geometry>)>
fn polygonize_full( &self ) -> GResult<(Geometry, Option<Geometry>, Option<Geometry>, Option<Geometry>)>
Returns, in the tuple elements order:
- The polygonized geometry.
- The cuts geometries collection.
- The dangles geometries collection.
- The invalid geometries collection.
sourcefn to_hex(&self) -> GResult<CVec<u8>>
fn to_hex(&self) -> GResult<CVec<u8>>
Converts a Geometry
to the HEX format. For more control over the generated output,
use the WKBWriter
type.
§Example
use geos::{Geom, Geometry};
let point_geom = Geometry::new_from_wkt("POINT (2.5 2.5)")
.expect("Invalid geometry");
let hex_buf = point_geom.to_hex().expect("conversion to WKB failed");
sourcefn to_wkb(&self) -> GResult<CVec<u8>>
fn to_wkb(&self) -> GResult<CVec<u8>>
Converts a Geometry
to the WKB format. For more control over the generated output,
use the WKBWriter
type.
§Example
use geos::{Geom, Geometry};
let point_geom = Geometry::new_from_wkt("POINT (2.5 2.5)")
.expect("Invalid geometry");
let wkb_buf = point_geom.to_wkb().expect("conversion to WKB failed");
sourcefn to_prepared_geom<'c>(&'c self) -> GResult<PreparedGeometry>
fn to_prepared_geom<'c>(&'c self) -> GResult<PreparedGeometry>
Creates a new PreparedGeometry
from the current Geometry
.
§Example
use geos::{Geom, Geometry};
let point_geom = Geometry::new_from_wkt("POINT (2.5 2.5)")
.expect("Invalid geometry");
let prepared_geom = point_geom.to_prepared_geom().expect("failed to create prepared geom");
sourcefn get_geometry_n(&self, n: usize) -> GResult<ConstGeometry<'_>>
fn get_geometry_n(&self, n: usize) -> GResult<ConstGeometry<'_>>
Returns the 1-based nth geometry.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("MULTIPOINT(1 1, 2 2, 3 3, 4 4)")
.expect("Invalid geometry");
let point_nb3 = geom
.get_geometry_n(2)
.expect("failed to get third point");
assert_eq!(
point_nb3.to_wkt().unwrap(),
"POINT (3.0000000000000000 3.0000000000000000)",
);
sourcefn get_interior_ring_n(&self, n: u32) -> GResult<ConstGeometry<'_>>
fn get_interior_ring_n(&self, n: u32) -> GResult<ConstGeometry<'_>>
Returns the nth interior ring.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("POLYGON((0 0, 10 0, 10 6, 0 6, 0 0),\
(1 1, 2 1, 2 5, 1 5, 1 1),\
(8 5, 8 4, 9 4, 9 5, 8 5))")
.expect("Invalid geometry");
let interior = geom
.get_interior_ring_n(0)
.expect("failed to get interior ring");
assert_eq!(interior.to_wkt().unwrap(),
"LINEARRING (1.0000000000000000 1.0000000000000000, \
2.0000000000000000 1.0000000000000000, \
2.0000000000000000 5.0000000000000000, \
1.0000000000000000 5.0000000000000000, \
1.0000000000000000 1.0000000000000000)");
sourcefn get_exterior_ring(&self) -> GResult<ConstGeometry<'_>>
fn get_exterior_ring(&self) -> GResult<ConstGeometry<'_>>
Returns the exterior ring.
§Example
use geos::{Geom, Geometry};
let point_geom = Geometry::new_from_wkt("POLYGON((0 0, 10 0, 10 6, 0 6, 0 0),\
(1 1, 2 1, 2 5, 1 5, 1 1))")
.expect("Invalid geometry");
let exterior = point_geom
.get_exterior_ring()
.expect("failed to get exterior ring");
assert_eq!(exterior.to_wkt().unwrap(),
"LINEARRING (0.0000000000000000 0.0000000000000000, \
10.0000000000000000 0.0000000000000000, \
10.0000000000000000 6.0000000000000000, \
0.0000000000000000 6.0000000000000000, \
0.0000000000000000 0.0000000000000000)");