pub struct Geometry<'a> { /* private fields */ }
Expand description
Representation of a GEOS geometry.
§Example
use geos::{Geom, Geometry};
let point_geom = Geometry::new_from_wkt("POINT (2.5 3.5)")
.expect("Invalid geometry");
assert_eq!(point_geom.get_x(), Ok(2.5));
assert_eq!(point_geom.get_y(), Ok(3.5));
Implementations§
source§impl<'a> Geometry<'a>
impl<'a> Geometry<'a>
sourcepub fn new_from_wkt(wkt: &str) -> GResult<Geometry<'a>>
pub fn new_from_wkt(wkt: &str) -> GResult<Geometry<'a>>
Creates a Geometry
from the WKT format.
§Example
use geos::Geometry;
let point_geom = Geometry::new_from_wkt("POINT (2.5 2.5)").expect("Invalid geometry");
Examples found in repository?
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
fn fun() -> Result<(), Error> {
println!(
"geos_c version: {}",
version().expect("failed to get version")
);
let g1 = Geometry::new_from_wkt("POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))")?;
println!("Geometry 1 created");
println!("Area : {}", g1.area()?);
println!("Is Geom1 simple : {:?}", g1.is_simple()?);
let g2 = Geometry::new_from_wkt("POLYGON ((1 1, 1 3, 5 5, 5 0, 1 1))")?;
println!("Geometry 2 created");
println!("Geom1 intersects geom2 : {:?}\n", g1.intersects(&g2)?);
let g3 = g1.buffer(100.0, 8)?;
println!("Previous area = {} \nNew area = {}", g2.area()?, g3.area()?);
let result = g1.within(&g2)?;
println!("Geom1 within geom2 : {:?}\n", result);
println!("Geom1 to wkt : {:?}", g1.to_wkt());
let g5 = Geometry::new_from_wkt("LINESTRING(0.0 0.0, 7.0 7.0, 45.0 50.5, 100.0 100.0)")?;
println!("Geom5 (linestring) : {:?}", g5.geometry_type());
let g6 = g5.buffer(20.0, 10)?;
println!("Geom6 (polygon) : {:?}", g6.geometry_type());
let g4 = g1.get_centroid()?;
println!("Centroid of g1 : {:?}", g4.to_wkt());
println!(
"Centroid of g1 with round precision of 1: {:?}",
g4.to_wkt_precision(1)
);
println!("Geom4 contains centroid of geom1 : {:?}", g3.contains(&g4)?);
println!("Geom4 is valid ? : {}", g3.is_valid());
Ok(())
}
sourcepub fn new_from_hex(hex: &[u8]) -> GResult<Geometry<'a>>
pub fn new_from_hex(hex: &[u8]) -> GResult<Geometry<'a>>
Create a new Geometry
from the HEX format.
§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 HEX failed");
// The interesting part is here:
let new_geom = Geometry::new_from_hex(hex_buf.as_ref())
.expect("conversion from HEX failed");
assert_eq!(point_geom.equals(&new_geom), Ok(true));
sourcepub fn new_from_wkb(wkb: &[u8]) -> GResult<Geometry<'a>>
pub fn new_from_wkb(wkb: &[u8]) -> GResult<Geometry<'a>>
Create a new Geometry
from the WKB format.
§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");
// The interesting part is here:
let new_geom = Geometry::new_from_wkb(wkb_buf.as_ref())
.expect("conversion from WKB failed");
assert_eq!(point_geom.equals(&new_geom), Ok(true));
sourcepub fn build_area(&self) -> GResult<Geometry<'a>>
pub fn build_area(&self) -> GResult<Geometry<'a>>
Creates an areal geometry formed by the constituent linework of given geometry.
You can find new illustrations on postgis documentation.
Available using the v3_8_0
feature.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("GEOMETRYCOLLECTION( \
POLYGON((0 0, 4 0, 4 4, 0 4, 0 0)), \
POLYGON((1 1, 1 3, 3 3, 3 1, 1 1)))")
.expect("Invalid geometry");
let build_area_geom = geom.build_area().expect("build_area failed");
// Square polygon with square hole.
assert_eq!(build_area_geom.to_wkt_precision(0).unwrap(),
"POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0), (1 1, 3 1, 3 3, 1 3, 1 1))");
sourcepub fn polygonize<T: Borrow<Geometry<'a>>>(
geometries: &[T]
) -> GResult<Geometry<'a>>
pub fn polygonize<T: Borrow<Geometry<'a>>>( geometries: &[T] ) -> GResult<Geometry<'a>>
Description from postgis:
Creates a GeometryCollection containing possible polygons formed from the constituent linework of a set of geometries.
§Example:
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POLYGON((-71.040878 42.285678,\
-71.040943 42.2856,\
-71.04096 42.285752,\
-71.040878 42.285678))")
.expect("Failed to create geometry");
let geom2 = Geometry::new_from_wkt("POLYGON((-71.17166 42.353675,\
-71.172026 42.354044,\
-71.17239 42.354358,\
-71.171794 42.354971,\
-71.170511 42.354855,\
-71.17112 42.354238,\
-71.17166 42.353675))")
.expect("Failed to create geometry");
let polygonized = Geometry::polygonize(&[geom1, geom2]).expect("polygonize failed");
assert_eq!(polygonized.to_wkt().unwrap(),
"GEOMETRYCOLLECTION (POLYGON ((-71.0408780000000064 42.2856779999999972, \
-71.0409429999999986 42.2856000000000023, \
-71.0409599999999983 42.2857520000000022, \
-71.0408780000000064 42.2856779999999972)), \
POLYGON ((-71.1716600000000028 42.3536750000000026, \
-71.1720260000000025 42.3540440000000018, \
-71.1723899999999929 42.3543579999999977, \
-71.1717940000000056 42.3549709999999990, \
-71.1705110000000047 42.3548550000000006, \
-71.1711200000000019 42.3542380000000023, \
-71.1716600000000028 42.3536750000000026)))");
pub fn polygonizer_get_cut_edges<T: Borrow<Geometry<'a>>>( &self, geometries: &[T] ) -> GResult<Geometry<'a>>
sourcepub fn line_merge(&self) -> GResult<Geometry<'a>>
pub fn line_merge(&self) -> GResult<Geometry<'a>>
Merges Multi Line String
geometry into a (set of) Line String
.
§Warning
If you use this function on something else than a Multi Line String
or a
Line String
, it’ll return an empty Geometry collection
.
§Example
use geos::{Geom, Geometry};
let lines = Geometry::new_from_wkt("MULTILINESTRING((-29 -27,-30 -29.7,-36 -31,-45 -33),\
(-45 -33,-46 -32))")
.expect("Invalid geometry");
let lines_merged = lines.line_merge().expect("line merge failed");
assert_eq!(
lines_merged.to_wkt_precision(1).unwrap(),
"LINESTRING (-29.0 -27.0, -30.0 -29.7, -36.0 -31.0, -45.0 -33.0, -46.0 -32.0)",
);
sourcepub fn reverse(&self) -> GResult<Geometry<'a>>
pub fn reverse(&self) -> GResult<Geometry<'a>>
Reverses the order of the vertexes.
Available using the v3_7_0
feature.
§Example
use geos::{Geom, Geometry};
let line = Geometry::new_from_wkt("LINESTRING(1 10,1 2)")
.expect("invalid geometry");
let reversed_line = line.reverse().expect("reverse failed");
assert_eq!(
reversed_line.to_wkt_precision(1).unwrap(),
"LINESTRING (1.0 2.0, 1.0 10.0)",
);
sourcepub fn simplify(&self, tolerance: f64) -> GResult<Geometry<'a>>
pub fn simplify(&self, tolerance: f64) -> GResult<Geometry<'a>>
Returns a simplified version of the given geometry.
sourcepub fn topology_preserve_simplify(
&self,
tolerance: f64
) -> GResult<Geometry<'a>>
pub fn topology_preserve_simplify( &self, tolerance: f64 ) -> GResult<Geometry<'a>>
Returns a simplified version of the given geometry. It will avoid creating invalid derived geometries.
sourcepub fn set_srid(&mut self, srid: usize)
pub fn set_srid(&mut self, srid: usize)
Set 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));
sourcepub fn normalize(&mut self) -> GResult<()>
pub fn normalize(&mut self) -> GResult<()>
Normalizes self
in its normalized/canonical form. May reorder vertices in polygon rings,
rings in a polygon, elements in a multi-geometry complex.
§Example
use geos::{Geom, Geometry};
let mut geom = Geometry::new_from_wkt(
"GEOMETRYCOLLECTION(POINT(2 3), MULTILINESTRING((0 0, 1 1),(2 2, 3 3)))",
).expect("Invalid geometry");
geom.normalize().expect("normalize failed");
assert_eq!(geom.to_wkt_precision(1).unwrap(),
"GEOMETRYCOLLECTION (MULTILINESTRING ((2.0 2.0, 3.0 3.0), (0.0 0.0, 1.0 1.0)), \
POINT (2.0 3.0))");
sourcepub fn create_empty_polygon() -> GResult<Geometry<'a>>
pub fn create_empty_polygon() -> GResult<Geometry<'a>>
Creates an empty polygon geometry.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::create_empty_polygon().expect("Failed to build empty polygon");
assert_eq!(geom.to_wkt().unwrap(), "POLYGON EMPTY");
sourcepub fn create_empty_point() -> GResult<Geometry<'a>>
pub fn create_empty_point() -> GResult<Geometry<'a>>
Creates an empty point geometry.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::create_empty_point().expect("Failed to build empty point");
assert_eq!(geom.to_wkt().unwrap(), "POINT EMPTY");
sourcepub fn create_empty_line_string() -> GResult<Geometry<'a>>
pub fn create_empty_line_string() -> GResult<Geometry<'a>>
Creates an empty line string geometry.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::create_empty_line_string().expect("Failed to build empty line string");
assert_eq!(geom.to_wkt().unwrap(), "LINESTRING EMPTY");
sourcepub fn create_empty_collection(type_: GeometryTypes) -> GResult<Geometry<'a>>
pub fn create_empty_collection(type_: GeometryTypes) -> GResult<Geometry<'a>>
Creates an empty collection.
The type_
must be one of:
GeometryTypes::GeometryCollection
GeometryTypes::MultiPoint
GeometryTypes::MultiLineString
GeometryTypes::MultiPolygon
§Example
use geos::{Geom, Geometry, GeometryTypes};
let geom = Geometry::create_empty_collection(GeometryTypes::MultiPolygon)
.expect("Failed to build empty collection");
assert_eq!(geom.to_wkt().unwrap(), "MULTIPOLYGON EMPTY");
sourcepub fn create_polygon<'b>(
exterior: Geometry<'a>,
interiors: Vec<Geometry<'b>>
) -> GResult<Geometry<'a>>
pub fn create_polygon<'b>( exterior: Geometry<'a>, interiors: Vec<Geometry<'b>> ) -> GResult<Geometry<'a>>
Creates a polygon formed by the given shell and array of holes.
§Note
exterior
must be a LinearRing
.
§Example
use geos::{Geom, Geometry};
let geom = Geometry::new_from_wkt("LINEARRING(75.15 29.53,77 29,77.6 29.5, 75.15 29.53)")
.expect("Invalid geometry");
let polygon_geom = Geometry::create_polygon(geom, vec![])
.expect("create_polygon failed");
assert_eq!(
polygon_geom.to_wkt_precision(1).unwrap(),
"POLYGON ((75.2 29.5, 77.0 29.0, 77.6 29.5, 75.2 29.5))",
);
sourcepub fn create_geometry_collection(
geoms: Vec<Geometry<'a>>
) -> GResult<Geometry<'a>>
pub fn create_geometry_collection( geoms: Vec<Geometry<'a>> ) -> GResult<Geometry<'a>>
Create a geometry collection.
§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 (3.0 4.0)").expect("Invalid geometry");
let geom = Geometry::create_geometry_collection(vec![geom1, geom2])
.expect("Failed to build multipolygon");
assert_eq!(geom.to_wkt_precision(1).unwrap(),
"GEOMETRYCOLLECTION (POLYGON ((0.0 0.0, 10.0 0.0, 10.0 6.0, 0.0 6.0, 0.0 0.0)), \
POINT (3.0 4.0))");
sourcepub fn create_multipolygon(polygons: Vec<Geometry<'a>>) -> GResult<Geometry<'a>>
pub fn create_multipolygon(polygons: Vec<Geometry<'a>>) -> GResult<Geometry<'a>>
Create a multi polygon 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");
let geom2 = Geometry::new_from_wkt("POLYGON((3 3, 10 3, 10 6, 3 6, 3 3))")
.expect("Invalid geometry");
let geom = Geometry::create_multipolygon(vec![geom1, geom2])
.expect("Failed to build multipolygon");
assert_eq!(geom.to_wkt_precision(1).unwrap(),
"MULTIPOLYGON (((0.0 0.0, 10.0 0.0, 10.0 6.0, 0.0 6.0, 0.0 0.0)), \
((3.0 3.0, 10.0 3.0, 10.0 6.0, 3.0 6.0, 3.0 3.0)))");
sourcepub fn create_multiline_string(
linestrings: Vec<Geometry<'a>>
) -> GResult<Geometry<'a>>
pub fn create_multiline_string( linestrings: Vec<Geometry<'a>> ) -> GResult<Geometry<'a>>
Create a multiline string geometry.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("LINESTRING (1.0 2.0, 3.0 4.0)").expect("invalid geometry");
let geom2 = Geometry::new_from_wkt("LINESTRING (5.0 6.0, 7.0 8.0)").expect("invalid geometry");
let geom = Geometry::create_multiline_string(vec![geom1, geom2])
.expect("Failed to build multiline string");
assert_eq!(geom.to_wkt_precision(1).unwrap(),
"MULTILINESTRING ((1.0 2.0, 3.0 4.0), (5.0 6.0, 7.0 8.0))");
sourcepub fn create_multipoint(points: Vec<Geometry<'a>>) -> GResult<Geometry<'a>>
pub fn create_multipoint(points: Vec<Geometry<'a>>) -> GResult<Geometry<'a>>
Creates a multi point geometry.
§Example
use geos::{Geom, Geometry};
let geom1 = Geometry::new_from_wkt("POINT (1.0 2.0)").expect("Invalid geometry");
let geom2 = Geometry::new_from_wkt("POINT (3.0 4.0)").expect("Invalid geometry");
let geom = Geometry::create_multipoint(vec![geom1, geom2])
.expect("Failed to build multipoint");
assert_eq!(geom.to_wkt_precision(1).unwrap(), "MULTIPOINT (1.0 2.0, 3.0 4.0)");
sourcepub fn create_point(s: CoordSeq<'a>) -> GResult<Geometry<'a>>
pub fn create_point(s: CoordSeq<'a>) -> GResult<Geometry<'a>>
Creates a point geometry.
§Example
use geos::{CoordDimensions, CoordSeq, Geom, Geometry};
let coords = CoordSeq::new_from_vec(&[&[1., 2.]])
.expect("failed to create CoordSeq");
let geom = Geometry::create_point(coords).expect("Failed to create a point");
assert_eq!(geom.to_wkt_precision(1).unwrap(), "POINT (1.0 2.0)");
sourcepub fn create_line_string(s: CoordSeq<'a>) -> GResult<Geometry<'a>>
pub fn create_line_string(s: CoordSeq<'a>) -> GResult<Geometry<'a>>
Creates a line string geometry.
§Example
use geos::{CoordDimensions, CoordSeq, Geom, Geometry};
let coords = CoordSeq::new_from_vec(&[&[1., 2.], &[3., 4.]])
.expect("failed to create CoordSeq");
let geom = Geometry::create_line_string(coords).expect("Failed to create a line string");
assert_eq!(geom.to_wkt_precision(1).unwrap(), "LINESTRING (1.0 2.0, 3.0 4.0)");
sourcepub fn create_linear_ring(s: CoordSeq<'a>) -> GResult<Geometry<'a>>
pub fn create_linear_ring(s: CoordSeq<'a>) -> GResult<Geometry<'a>>
Creates a linear ring geometry.
§Example
use geos::{CoordDimensions, CoordSeq, Geom, Geometry};
let coords = CoordSeq::new_from_vec(&[&[75.15, 29.53],
&[77., 29.],
&[77.6, 29.5],
&[75.15, 29.53]])
.expect("failed to create CoordSeq");
let geom = Geometry::create_linear_ring(coords)
.expect("Failed to create a linea ring");
assert_eq!(geom.to_wkt_precision(1).unwrap(),
"LINEARRING (75.2 29.5, 77.0 29.0, 77.6 29.5, 75.2 29.5)");
Trait Implementations§
source§impl<'a> ContextHandling for Geometry<'a>
impl<'a> ContextHandling for Geometry<'a>
type Context = Arc<ContextHandle<'a>>
fn clone_context(&self) -> Arc<ContextHandle<'a>>
source§impl<'a> ContextInteractions<'a> for Geometry<'a>
impl<'a> ContextInteractions<'a> for Geometry<'a>
source§fn set_context_handle(&mut self, context: ContextHandle<'a>)
fn set_context_handle(&mut self, context: ContextHandle<'a>)
Set the context handle to the geometry.
use geos::{ContextInteractions, ContextHandle, Geometry};
let context_handle = ContextHandle::init().expect("invalid init");
context_handle.set_notice_message_handler(Some(Box::new(|s| println!("new message: {}", s))));
let mut point_geom = Geometry::new_from_wkt("POINT (2.5 2.5)").expect("Invalid geometry");
point_geom.set_context_handle(context_handle);
source§fn get_context_handle(&self) -> &ContextHandle<'a>
fn get_context_handle(&self) -> &ContextHandle<'a>
Get the context handle of the geometry.
use geos::{ContextInteractions, Geometry};
let point_geom = Geometry::new_from_wkt("POINT (2.5 2.5)").expect("Invalid geometry");
let context = point_geom.get_context_handle();
context.set_notice_message_handler(Some(Box::new(|s| println!("new message: {}", s))));
source§fn get_last_error(&self) -> Option<String>
fn get_last_error(&self) -> Option<String>
ContextHandle
held by this object. Read moresource§fn get_last_notification(&self) -> Option<String>
fn get_last_notification(&self) -> Option<String>
ContextHandle
held by this object. Read moresource§impl<'a> Geom<'a> for Geometry<'a>
impl<'a> Geom<'a> for Geometry<'a>
fn geometry_type(&self) -> GeometryTypes
source§fn is_valid_reason(&self) -> GResult<String>
fn is_valid_reason(&self) -> GResult<String>
source§fn get_coord_seq(&self) -> GResult<CoordSeq<'a>>
fn get_coord_seq(&self) -> GResult<CoordSeq<'a>>
source§fn area(&self) -> GResult<f64>
fn area(&self) -> GResult<f64>
source§fn to_wkt_precision(&self, precision: u32) -> GResult<String>
fn to_wkt_precision(&self, precision: u32) -> GResult<String>
precision
. It is a wrapper
around WKTWriter::set_rounding_precision
. Read moresource§fn touches<'b, G: Geom<'b>>(&self, other: &G) -> GResult<bool>
fn touches<'b, G: Geom<'b>>(&self, other: &G) -> GResult<bool>
true
if the only points in common between self
and other
lie in the union of
the boundaries of self
and other
. Read moresource§fn buffer(&self, width: f64, quadsegs: i32) -> GResult<Geometry<'a>>
fn buffer(&self, width: f64, quadsegs: i32) -> GResult<Geometry<'a>>
self
is less than or
equal to distance. Read moresource§fn buffer_with_params(
&self,
width: f64,
buffer_params: &BufferParams<'_>
) -> GResult<Geometry<'a>>
fn buffer_with_params( &self, width: f64, buffer_params: &BufferParams<'_> ) -> GResult<Geometry<'a>>
self
is less than or
equal to distance. Read moresource§fn buffer_with_style(
&self,
width: f64,
quadsegs: i32,
end_cap_style: CapStyle,
join_style: JoinStyle,
mitre_limit: f64
) -> GResult<Geometry<'a>>
fn buffer_with_style( &self, width: f64, quadsegs: i32, end_cap_style: CapStyle, join_style: JoinStyle, mitre_limit: f64 ) -> GResult<Geometry<'a>>
self
is less than or
equal to distance. Read moresource§fn is_simple(&self) -> GResult<bool>
fn is_simple(&self) -> GResult<bool>
source§fn envelope(&self) -> GResult<Geometry<'a>>
fn envelope(&self) -> GResult<Geometry<'a>>
source§fn union<'b, G: Geom<'b>>(&self, other: &G) -> GResult<Geometry<'a>>
fn union<'b, G: Geom<'b>>(&self, other: &G) -> GResult<Geometry<'a>>
source§fn get_centroid(&self) -> GResult<Geometry<'a>>
fn get_centroid(&self) -> GResult<Geometry<'a>>
source§fn voronoi<'b, G: Geom<'b>>(
&self,
envelope: Option<&G>,
tolerance: f64,
only_edges: bool
) -> GResult<Geometry<'a>>
fn voronoi<'b, G: Geom<'b>>( &self, envelope: Option<&G>, tolerance: f64, only_edges: bool ) -> GResult<Geometry<'a>>
source§fn boundary(&self) -> GResult<Geometry<'a>>
fn boundary(&self) -> GResult<Geometry<'a>>
self
. Read moresource§fn is_closed(&self) -> GResult<bool>
fn is_closed(&self) -> GResult<bool>
true
if start and end point are coincident. Read moresource§fn length(&self) -> GResult<f64>
fn length(&self) -> GResult<f64>
self
. The unit depends of the SRID. Read moresource§fn hausdorff_distance_densify<'b, G: Geom<'b>>(
&self,
other: &G,
distance_frac: f64
) -> GResult<f64>
fn hausdorff_distance_densify<'b, G: Geom<'b>>( &self, other: &G, distance_frac: f64 ) -> GResult<f64>
source§fn frechet_distance_densify<'b, G: Geom<'b>>(
&self,
other: &G,
distance_frac: f64
) -> GResult<f64>
fn frechet_distance_densify<'b, G: Geom<'b>>( &self, other: &G, distance_frac: f64 ) -> GResult<f64>
source§fn extract_unique_points(&self) -> GResult<Geometry<'a>>
fn extract_unique_points(&self) -> GResult<Geometry<'a>>
self
.fn nearest_points<'b, G: Geom<'b>>(&self, other: &G) -> GResult<CoordSeq<'a>>
source§fn get_point_n(&self, n: usize) -> GResult<Geometry<'a>>
fn get_point_n(&self, n: usize) -> GResult<Geometry<'a>>
source§fn get_num_interior_rings(&self) -> GResult<usize>
fn get_num_interior_rings(&self) -> GResult<usize>
source§fn get_num_coordinates(&self) -> GResult<usize>
fn get_num_coordinates(&self) -> GResult<usize>
self
. Read moresource§fn get_num_dimensions(&self) -> GResult<usize>
fn get_num_dimensions(&self) -> GResult<usize>
self
. Read moresource§fn get_coordinate_dimension(&self) -> GResult<Dimensions>
fn get_coordinate_dimension(&self) -> GResult<Dimensions>
source§fn make_valid(&self) -> GResult<Geometry<'a>>
fn make_valid(&self) -> GResult<Geometry<'a>>
self
. Read moresource§fn set_precision(
&self,
grid_size: f64,
flags: Precision
) -> GResult<Geometry<'a>>
fn set_precision( &self, grid_size: f64, flags: Precision ) -> GResult<Geometry<'a>>
self
. Read moresource§fn minimum_clearance(&self) -> GResult<f64>
fn minimum_clearance(&self) -> GResult<f64>
self
could be moved to produce an
invalid geometry. Read moresource§fn minimum_clearance_line(&self) -> GResult<Geometry<'a>>
fn minimum_clearance_line(&self) -> GResult<Geometry<'a>>
self
’s minimum clearance. Read moresource§fn minimum_rotated_rectangle(&self) -> GResult<Geometry<'a>>
fn minimum_rotated_rectangle(&self) -> GResult<Geometry<'a>>
self
. Read moresource§fn minimum_width(&self) -> GResult<Geometry<'a>>
fn minimum_width(&self) -> GResult<Geometry<'a>>
self
. Read more