+use crate::{+    CoordinateType, Geometry, GeometryCollection, Line, LineString, MultiLineString, MultiPoint,+    MultiPolygon, Point, Polygon, Rect, Triangle,+};++/// 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::algorithm::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.get_dimensions());+/// assert_eq!(Dimensions::OneDimensional, line_string.get_dimensions());+/// assert_eq!(Dimensions::TwoDimensional, rect.get_dimensions());+///+/// assert!(point.get_dimensions() < line_string.get_dimensions());+/// assert!(rect.get_dimensions() > line_string.get_dimensions());+/// ```+#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd)]+pub enum Dimensions {+    /// Some geometries, like a `MultiPoint` or `GeometryColletion` 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,+}++/// Operate on the dimensionality of geometries.+pub trait HasDimensions {+    /// Some geometries, like a `MultiPoint`, can have zero coordinates - we call these `empty`.+    ///+    /// Types like `Point` and `Rect`, which have at least one coordinate by construction, can+    /// never be considered empty.+    /// ```+    /// use geo_types::{Point, Coordinate, LineString};+    /// use geo::algorithm::dimensions::HasDimensions;+    ///+    /// let line_string = LineString(vec![+    ///     Coordinate { x: 0., y: 0. },+    ///     Coordinate { x: 10., y: 0. },+    /// ]);+    /// assert!(!line_string.is_empty());+    ///+    /// let empty_line_string: LineString<f64> = LineString(vec![]);+    /// assert!(empty_line_string.is_empty());+    ///+    /// let point = Point::new(0.0, 0.0);+    /// assert!(!point.is_empty());+    /// ```+    fn is_empty(&self) -> bool;++    /// The dimensions of some geometries are fixed, e.g. a Point always has 0 dimensions. However+    /// for others, the dimensionality depends on the specific geometry instance - for example+    /// typical `Rect`s are 2-dimensional, but it's possible to create degenerate `Rect`s which+    /// have either 1 or 0 dimensions.+    ///+    /// ## Examples+    ///+    /// ```+    /// use geo_types::{GeometryCollection, Rect, Point};+    /// use geo::algorithm::dimensions::{Dimensions, HasDimensions};+    ///+    /// // normal rectangle+    /// let rect = Rect::new((0.0, 0.0), (10.0, 10.0));+    /// assert_eq!(Dimensions::TwoDimensional, rect.get_dimensions());+    ///+    /// // "rectangle" with zero height degenerates to a line+    /// let degenerate_line_rect = Rect::new((0.0, 10.0), (10.0, 10.0));+    /// assert_eq!(Dimensions::OneDimensional, degenerate_line_rect.get_dimensions());+    ///+    /// // "rectangle" with zero height and zero width degenerates to a point+    /// let degenerate_point_rect = Rect::new((10.0, 10.0), (10.0, 10.0));+    /// assert_eq!(Dimensions::ZeroDimensional, degenerate_point_rect.get_dimensions());+    ///+    /// // collections inherit the greatest dimensionality of their elements+    /// let geometry_collection = GeometryCollection(vec![degenerate_line_rect.into(), degenerate_point_rect.into()]);+    /// assert_eq!(Dimensions::OneDimensional, geometry_collection.get_dimensions());+    ///+    /// let point = Point::new(10.0, 10.0);+    /// assert_eq!(Dimensions::ZeroDimensional, point.get_dimensions());+    ///+    /// // An `Empty` dimensionality is distinct from, and less than, being 0-dimensional+    /// let empty_collection = GeometryCollection::<f32>(vec![]);+    /// assert_eq!(Dimensions::Empty, empty_collection.get_dimensions());+    /// assert!(empty_collection.get_dimensions() < point.get_dimensions());+    /// ```+    fn get_dimensions(&self) -> Dimensions;++    /// The dimensions of the `Geometry`'s boundary, as used by OGC-SFA.+    ///+    /// ## Examples+    ///+    /// ```+    /// use geo_types::{GeometryCollection, Rect, Point};+    /// use geo::algorithm::dimensions::{Dimensions, HasDimensions};+    ///+    /// // a point has no boundary+    /// let point = Point::new(10.0, 10.0);+    /// assert_eq!(Dimensions::Empty, point.get_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.get_boundary_dimensions());+    ///+    /// // a "rectangle" with zero height degenerates to a line, whose boundary is two points+    /// let degenerate_line_rect = Rect::new((0.0, 10.0), (10.0, 10.0));+    /// assert_eq!(Dimensions::ZeroDimensional, degenerate_line_rect.get_boundary_dimensions());+    ///+    /// // a "rectangle" with zero height and zero width degenerates to a point,+    /// // and points have no boundary+    /// let degenerate_point_rect = Rect::new((10.0, 10.0), (10.0, 10.0));+    /// assert_eq!(Dimensions::Empty, degenerate_point_rect.get_boundary_dimensions());+    ///+    /// // collections inherit the greatest dimensionality of their elements+    /// let geometry_collection = GeometryCollection(vec![degenerate_line_rect.into(), degenerate_point_rect.into()]);+    /// assert_eq!(Dimensions::ZeroDimensional, geometry_collection.get_boundary_dimensions());+    ///+    /// let geometry_collection = GeometryCollection::<f32>(vec![]);+    /// assert_eq!(Dimensions::Empty, geometry_collection.get_boundary_dimensions());+    /// ```+    fn get_boundary_dimensions(&self) -> Dimensions;+}++impl<C: CoordinateType> HasDimensions for Geometry<C> {+    fn is_empty(&self) -> bool {+        match self {+            Geometry::Point(g) => g.is_empty(),+            Geometry::Line(g) => g.is_empty(),+            Geometry::LineString(g) => g.is_empty(),+            Geometry::Polygon(g) => g.is_empty(),+            Geometry::MultiPoint(g) => g.is_empty(),+            Geometry::MultiLineString(g) => g.is_empty(),+            Geometry::MultiPolygon(g) => g.is_empty(),+            Geometry::GeometryCollection(g) => g.is_empty(),+            Geometry::Rect(g) => g.is_empty(),+            Geometry::Triangle(g) => g.is_empty(),+        }+    }++    fn get_dimensions(&self) -> Dimensions {+        match self {+            Geometry::Point(g) => g.get_dimensions(),+            Geometry::Line(g) => g.get_dimensions(),+            Geometry::LineString(g) => g.get_dimensions(),+            Geometry::Polygon(g) => g.get_dimensions(),+            Geometry::MultiPoint(g) => g.get_dimensions(),+            Geometry::MultiLineString(g) => g.get_dimensions(),+            Geometry::MultiPolygon(g) => g.get_dimensions(),+            Geometry::GeometryCollection(g) => g.get_dimensions(),+            Geometry::Rect(g) => g.get_dimensions(),+            Geometry::Triangle(g) => g.get_dimensions(),+        }+    }++    fn get_boundary_dimensions(&self) -> Dimensions {+        match self {+            Geometry::Point(g) => g.get_boundary_dimensions(),+            Geometry::Line(g) => g.get_boundary_dimensions(),+            Geometry::LineString(g) => g.get_boundary_dimensions(),+            Geometry::Polygon(g) => g.get_boundary_dimensions(),+            Geometry::MultiPoint(g) => g.get_boundary_dimensions(),+            Geometry::MultiLineString(g) => g.get_boundary_dimensions(),+            Geometry::MultiPolygon(g) => g.get_boundary_dimensions(),+            Geometry::GeometryCollection(g) => g.get_boundary_dimensions(),+            Geometry::Rect(g) => g.get_boundary_dimensions(),+            Geometry::Triangle(g) => g.get_boundary_dimensions(),+        }+    }+}++impl<C: CoordinateType> HasDimensions for Point<C> {+    fn is_empty(&self) -> bool {+        false+    }++    fn get_dimensions(&self) -> Dimensions {+        Dimensions::ZeroDimensional+    }++    fn get_boundary_dimensions(&self) -> Dimensions {+        Dimensions::Empty+    }+}++impl<C: CoordinateType> HasDimensions for Line<C> {+    fn is_empty(&self) -> bool {+        false+    }++    fn get_dimensions(&self) -> Dimensions {+        if self.start == self.end {+            // degenerate line is a point+            Dimensions::ZeroDimensional+        } else {+            Dimensions::OneDimensional+        }+    }++    fn get_boundary_dimensions(&self) -> Dimensions {+        if self.start == self.end {+            // degenerate line is a point, which has no boundary+            Dimensions::Empty+        } else {+            Dimensions::ZeroDimensional+        }+    }+}++impl<C: CoordinateType> HasDimensions for LineString<C> {+    fn is_empty(&self) -> bool {+        self.0.is_empty()+    }++    fn get_dimensions(&self) -> Dimensions {+        if self.0.is_empty() {+            return Dimensions::Empty;+        }++        debug_assert!(self.0.len() > 1, "invalid line_string with 1 coord");+        let first = self.0[0];+        if self.0.iter().any(|&coord| first != coord) {+            Dimensions::OneDimensional+        } else {+            // all coords are the same - i.e. a point+            Dimensions::ZeroDimensional+        }+    }++    ///```

 pub mod concave_hull; pub mod contains; /// Calculate the convex hull of a `Geometry`. pub mod convex_hull;+/// Dimensionality of a geometry and it's boundary, based on OGC-SFA.

+use crate::{+    CoordinateType, Geometry, GeometryCollection, Line, LineString, MultiLineString, MultiPoint,+    MultiPolygon, Point, Polygon, Rect, Triangle,+};++/// Geometries can have 0, 1, or two dimensions. Or, in the case of an [`empty`](#is_empty)+/// geometry, a special `Empty` dimensionality.+///+/// ## Examples

+use crate::{+    CoordinateType, Geometry, GeometryCollection, Line, LineString, MultiLineString, MultiPoint,+    MultiPolygon, Point, Polygon, Rect, Triangle,+};++/// 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::algorithm::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.get_dimensions());+/// assert_eq!(Dimensions::OneDimensional, line_string.get_dimensions());+/// assert_eq!(Dimensions::TwoDimensional, rect.get_dimensions());+///+/// assert!(point.get_dimensions() < line_string.get_dimensions());+/// assert!(rect.get_dimensions() > line_string.get_dimensions());+/// ```+#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd)]+pub enum Dimensions {+    /// Some geometries, like a `MultiPoint` or `GeometryColletion` 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,+}++/// Operate on the dimensionality of geometries.+pub trait HasDimensions {+    /// Some geometries, like a `MultiPoint`, can have zero coordinates - we call these `empty`.+    ///+    /// Types like `Point` and `Rect`, which have at least one coordinate by construction, can+    /// never be considered empty.+    /// ```+    /// use geo_types::{Point, Coordinate, LineString};+    /// use geo::algorithm::dimensions::HasDimensions;+    ///+    /// let line_string = LineString(vec![+    ///     Coordinate { x: 0., y: 0. },+    ///     Coordinate { x: 10., y: 0. },+    /// ]);+    /// assert!(!line_string.is_empty());+    ///+    /// let empty_line_string: LineString<f64> = LineString(vec![]);+    /// assert!(empty_line_string.is_empty());+    ///+    /// let point = Point::new(0.0, 0.0);+    /// assert!(!point.is_empty());+    /// ```+    fn is_empty(&self) -> bool;++    /// The dimensions of some geometries are fixed, e.g. a Point always has 0 dimensions. However+    /// for others, the dimensionality depends on the specific geometry instance - for example+    /// typical `Rect`s are 2-dimensional, but it's possible to create degenerate `Rect`s which+    /// have either 1 or 0 dimensions.+    ///+    /// ## Examples+    ///+    /// ```+    /// use geo_types::{GeometryCollection, Rect, Point};+    /// use geo::algorithm::dimensions::{Dimensions, HasDimensions};+    ///+    /// // normal rectangle+    /// let rect = Rect::new((0.0, 0.0), (10.0, 10.0));+    /// assert_eq!(Dimensions::TwoDimensional, rect.get_dimensions());+    ///+    /// // "rectangle" with zero height degenerates to a line+    /// let degenerate_line_rect = Rect::new((0.0, 10.0), (10.0, 10.0));+    /// assert_eq!(Dimensions::OneDimensional, degenerate_line_rect.get_dimensions());+    ///+    /// // "rectangle" with zero height and zero width degenerates to a point+    /// let degenerate_point_rect = Rect::new((10.0, 10.0), (10.0, 10.0));+    /// assert_eq!(Dimensions::ZeroDimensional, degenerate_point_rect.get_dimensions());+    ///+    /// // collections inherit the greatest dimensionality of their elements+    /// let geometry_collection = GeometryCollection(vec![degenerate_line_rect.into(), degenerate_point_rect.into()]);+    /// assert_eq!(Dimensions::OneDimensional, geometry_collection.get_dimensions());+    ///+    /// let point = Point::new(10.0, 10.0);+    /// assert_eq!(Dimensions::ZeroDimensional, point.get_dimensions());+    ///+    /// // An `Empty` dimensionality is distinct from, and less than, being 0-dimensional+    /// let empty_collection = GeometryCollection::<f32>(vec![]);+    /// assert_eq!(Dimensions::Empty, empty_collection.get_dimensions());+    /// assert!(empty_collection.get_dimensions() < point.get_dimensions());+    /// ```+    fn get_dimensions(&self) -> Dimensions;

 use crate::{ ///     [0.0, 1.0] /// ].into(); ///-/// assert_eq!(linestring.line_interpolate_point(&-1.0), point!(x: -1.0, y: 0.0));-/// assert_eq!(linestring.line_interpolate_point(&0.25), point!(x: -0.5, y: 0.0));-/// assert_eq!(linestring.line_interpolate_point(&0.5), point!(x: 0.0, y: 0.0));-/// assert_eq!(linestring.line_interpolate_point(&0.75), point!(x: 0.0, y: 0.5));-/// assert_eq!(linestring.line_interpolate_point(&2.0), point!(x: 0.0, y: 1.0));+/// assert_eq!(linestring.line_interpolate_point(&-1.0), Some(point!(x: -1.0, y: 0.0)));+/// assert_eq!(linestring.line_interpolate_point(&0.25), Some(point!(x: -0.5, y: 0.0)));+/// assert_eq!(linestring.line_interpolate_point(&0.5), Some(point!(x: 0.0, y: 0.0)));+/// assert_eq!(linestring.line_interpolate_point(&0.75), Some(point!(x: 0.0, y: 0.5)));+/// assert_eq!(linestring.line_interpolate_point(&2.0), Some(point!(x: 0.0, y: 1.0))); /// ``` pub trait LineInterpolatePoint<F: Float> {     type Output;      fn line_interpolate_point(&self, fraction: &F) -> Self::Output; } + impl<T> LineInterpolatePoint<T> for Line<T> where     T: CoordinateType + Float + Zero + One, {-    type Output = Point<T>;+    type Output = Option<Point<T>>;      fn line_interpolate_point(&self, fraction: &T) -> Self::Output {-        if fraction < &T::zero() {-            return self.start.into();-        };-        if fraction > &T::one() {-            return self.end.into();+        match fraction.partial_cmp(&T::zero()) {+            Some(o) => match o {+                Ordering::Less => return Some(self.start.into()),+                Ordering::Equal => return Some(self.start.into()),+                Ordering::Greater => {+                    match fraction.partial_cmp(&T::one()) {+                        Some(p) => match p {+                            Ordering::Greater => return Some(self.end.into()),+                            Ordering::Equal => return Some(self.end.into()),+                            Ordering::Less => {}+                        },+                        None => return None+                    }+                }+            },+            None => return None         };

+use crate::algorithm::convex_hull::qhull;+use crate::algorithm::euclidean_distance::EuclideanDistance;+use crate::algorithm::euclidean_length::EuclideanLength;+use crate::algorithm::kernels::HasKernel;+use crate::prelude::Centroid;+use crate::utils::partial_min;+use crate::{Line, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon};+use geo_types::{Coordinate, CoordinateType};+use num_traits::Float;+use rstar::{RTree, RTreeNum};+use std::collections::VecDeque;++/// Returns a polygon which covers a geometry. Unlike convex hulls, which also cover+/// their geometry, a concave hull does so while trying to further minimize its area by+/// constructing edges such that the exterior of the polygon incorporates points that would+/// be interior points in a convex hull.+///+/// This implementation is inspired by https://github.com/mapbox/concaveman+/// and also uses ideas from the following paper:+/// www.iis.sinica.edu.tw/page/jise/2012/201205_10.pdf+///+/// # Example

+use crate::algorithm::convex_hull::qhull;+use crate::algorithm::euclidean_distance::EuclideanDistance;+use crate::algorithm::euclidean_length::EuclideanLength;+use crate::algorithm::kernels::HasKernel;+use crate::prelude::Centroid;+use crate::utils::partial_min;+use crate::{Line, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon};+use geo_types::{Coordinate, CoordinateType};+use num_traits::Float;+use rstar::{RTree, RTreeNum};+use std::collections::VecDeque;++/// Returns a polygon which covers a geometry. Unlike convex hulls, which also cover+/// their geometry, a concave hull does so while trying to further minimize its area by+/// constructing edges such that the exterior of the polygon incorporates points that would+/// be interior points in a convex hull.+///+/// This implementation is inspired by https://github.com/mapbox/concaveman+/// and also uses ideas from the following paper:+/// www.iis.sinica.edu.tw/page/jise/2012/201205_10.pdf+///+/// # Example+/// ```+/// use geo::{line_string, polygon};+/// use geo::algorithm::concave_hull::ConcaveHull;+///+/// // a square shape+/// let poly = polygon![+///     (x: 0.0, y: 0.0),+///     (x: 4.0, y: 0.0),+///     (x: 4.0, y: 4.0),+///     (x: 0.0, y: 4.0),+/// ];+///+/// // The correct concave hull coordinates+/// let correct_hull = line_string![+///     (x: 4.0, y: 0.0),+///     (x: 4.0, y: 4.0),+///     (x: 0.0, y: 4.0),+///     (x: 0.0, y: 0.0),+///     (x: 4.0, y: 0.0),+/// ];+///+/// let res = poly.concave_hull(2.0);+/// assert_eq!(res.exterior(), &correct_hull);+/// ```+pub trait ConcaveHull {+    type Scalar: CoordinateType;+    fn concave_hull(&self, concavity: Self::Scalar) -> Polygon<Self::Scalar>;+}++impl<T> ConcaveHull for Polygon<T>+where+    T: Float + RTreeNum + HasKernel,+{+    type Scalar = T;+    fn concave_hull(&self, concavity: Self::Scalar) -> Polygon<Self::Scalar> {+        let mut points: Vec<_> = self.exterior().0.clone();+        Polygon::new(concave_hull(&mut points, concavity), vec![])+    }+}++impl<T> ConcaveHull for MultiPolygon<T>+where+    T: Float + RTreeNum + HasKernel,+{+    type Scalar = T;+    fn concave_hull(&self, concavity: Self::Scalar) -> Polygon<Self::Scalar> {+        let mut aggregated: Vec<Coordinate<Self::Scalar>> = self+            .0+            .iter()+            .flat_map(|elem| elem.exterior().0.clone())+            .collect();+        Polygon::new(concave_hull(&mut aggregated, concavity), vec![])+    }+}++impl<T> ConcaveHull for LineString<T>+where+    T: Float + RTreeNum + HasKernel,+{+    type Scalar = T;+    fn concave_hull(&self, concavity: Self::Scalar) -> Polygon<Self::Scalar> {+        Polygon::new(concave_hull(&mut self.0.clone(), concavity), vec![])+    }+}++impl<T> ConcaveHull for MultiLineString<T>+where+    T: Float + RTreeNum + HasKernel,+{+    type Scalar = T;+    fn concave_hull(&self, concavity: T) -> Polygon<T> {+        let mut aggregated: Vec<Coordinate<T>> =+            self.0.iter().flat_map(|elem| elem.0.clone()).collect();+        Polygon::new(concave_hull(&mut aggregated, concavity), vec![])+    }+}++impl<T> ConcaveHull for MultiPoint<T>+where+    T: Float + RTreeNum + HasKernel,+{+    type Scalar = T;+    fn concave_hull(&self, concavity: T) -> Polygon<T> {+        let mut coordinates: Vec<Coordinate<T>> = self.0.iter().map(|point| point.0).collect();+        Polygon::new(concave_hull(&mut coordinates, concavity), vec![])+    }+}++fn find_point_closest_to_line<T>(+    interior_coords_tree: &RTree<Coordinate<T>>,+    line: Line<T>,+    max_dist: T,+    edge_length: T,+    concavity: T,+    line_tree: &RTree<Line<T>>,+) -> Option<Coordinate<T>>+where+    T: Float + RTreeNum,+{+    let h = max_dist + max_dist;+    let w = line.euclidean_length() + h;+    let two = T::add(T::one(), T::one());+    let search_dist = T::div(T::sqrt(T::powi(w, 2) + T::powi(h, 2)), two);+    let centroid = line.centroid();+    let centroid_coord = Coordinate {+        x: centroid.x(),+        y: centroid.y(),+    };+    let mut candidates = interior_coords_tree+        .locate_within_distance(centroid_coord, search_dist)+        .peekable();+    let peek = candidates.peek();

+use crate::algorithm::convex_hull::qhull;+use crate::algorithm::euclidean_distance::EuclideanDistance;+use crate::algorithm::euclidean_length::EuclideanLength;+use crate::algorithm::kernels::HasKernel;+use crate::prelude::Centroid;+use crate::utils::partial_min;+use crate::{Line, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon};+use geo_types::{Coordinate, CoordinateType};+use num_traits::Float;+use rstar::{RTree, RTreeNum};+use std::collections::VecDeque;++/// Returns a polygon which covers a geometry. Unlike convex hulls, which also cover+/// their geometry, a concave hull does so while trying to further minimize its area by+/// constructing edges such that the exterior of the polygon incorporates points that would+/// be interior points in a convex hull.+///+/// This implementation is inspired by https://github.com/mapbox/concaveman+/// and also uses ideas from the following paper:+/// www.iis.sinica.edu.tw/page/jise/2012/201205_10.pdf+///+/// # Example+/// ```+/// use geo::{line_string, polygon};+/// use geo::algorithm::concave_hull::ConcaveHull;+///+/// // a square shape+/// let poly = polygon![+///     (x: 0.0, y: 0.0),+///     (x: 4.0, y: 0.0),+///     (x: 4.0, y: 4.0),+///     (x: 0.0, y: 4.0),+/// ];+///+/// // The correct concave hull coordinates+/// let correct_hull = line_string![+///     (x: 4.0, y: 0.0),+///     (x: 4.0, y: 4.0),+///     (x: 0.0, y: 4.0),+///     (x: 0.0, y: 0.0),+///     (x: 4.0, y: 0.0),+/// ];+///+/// let res = poly.concave_hull(2.0);+/// assert_eq!(res.exterior(), &correct_hull);+/// ```+pub trait ConcaveHull {+    type Scalar: CoordinateType;+    fn concave_hull(&self, concavity: Self::Scalar) -> Polygon<Self::Scalar>;+}++impl<T> ConcaveHull for Polygon<T>+where+    T: Float + RTreeNum + HasKernel,+{+    type Scalar = T;+    fn concave_hull(&self, concavity: Self::Scalar) -> Polygon<Self::Scalar> {+        let mut points: Vec<_> = self.exterior().0.clone();+        Polygon::new(concave_hull(&mut points, concavity), vec![])+    }+}++impl<T> ConcaveHull for MultiPolygon<T>+where+    T: Float + RTreeNum + HasKernel,+{+    type Scalar = T;+    fn concave_hull(&self, concavity: Self::Scalar) -> Polygon<Self::Scalar> {+        let mut aggregated: Vec<Coordinate<Self::Scalar>> = self+            .0+            .iter()+            .flat_map(|elem| elem.exterior().0.clone())+            .collect();+        Polygon::new(concave_hull(&mut aggregated, concavity), vec![])+    }+}++impl<T> ConcaveHull for LineString<T>+where+    T: Float + RTreeNum + HasKernel,+{+    type Scalar = T;+    fn concave_hull(&self, concavity: Self::Scalar) -> Polygon<Self::Scalar> {+        Polygon::new(concave_hull(&mut self.0.clone(), concavity), vec![])+    }+}++impl<T> ConcaveHull for MultiLineString<T>+where+    T: Float + RTreeNum + HasKernel,+{+    type Scalar = T;+    fn concave_hull(&self, concavity: T) -> Polygon<T> {+        let mut aggregated: Vec<Coordinate<T>> =+            self.0.iter().flat_map(|elem| elem.0.clone()).collect();+        Polygon::new(concave_hull(&mut aggregated, concavity), vec![])+    }+}++impl<T> ConcaveHull for MultiPoint<T>+where+    T: Float + RTreeNum + HasKernel,+{+    type Scalar = T;+    fn concave_hull(&self, concavity: T) -> Polygon<T> {+        let mut coordinates: Vec<Coordinate<T>> = self.0.iter().map(|point| point.0).collect();+        Polygon::new(concave_hull(&mut coordinates, concavity), vec![])+    }+}++fn find_point_closest_to_line<T>(+    interior_coords_tree: &RTree<Coordinate<T>>,+    line: Line<T>,+    max_dist: T,+    edge_length: T,+    concavity: T,+    line_tree: &RTree<Line<T>>,+) -> Option<Coordinate<T>>+where+    T: Float + RTreeNum,+{+    let h = max_dist + max_dist;+    let w = line.euclidean_length() + h;+    let two = T::add(T::one(), T::one());+    let search_dist = T::div(T::sqrt(T::powi(w, 2) + T::powi(h, 2)), two);+    let centroid = line.centroid();+    let centroid_coord = Coordinate {+        x: centroid.x(),+        y: centroid.y(),+    };+    let mut candidates = interior_coords_tree+        .locate_within_distance(centroid_coord, search_dist)+        .peekable();+    let peek = candidates.peek();+    match peek {+        None => None,+        Some(&point) => {+            let closest_point =+                candidates.fold(Point::new(point.x, point.y), |acc_point, candidate| {+                    let candidate_point = Point::new(candidate.x, candidate.y);+                    if line.euclidean_distance(&acc_point)+                        > line.euclidean_distance(&candidate_point)+                    {+                        candidate_point+                    } else {+                        acc_point+                    }+                });+            let mut edges_nearby_point = line_tree+                .locate_within_distance(closest_point, search_dist)+                .peekable();+            let peeked_edge = edges_nearby_point.peek();+            let closest_edge_option = match peeked_edge {+                None => None,+                Some(&edge) => Some(edges_nearby_point.fold(*edge, |acc, candidate| {+                    if closest_point.euclidean_distance(&acc)+                        > closest_point.euclidean_distance(candidate)+                    {+                        *candidate+                    } else {+                        acc+                    }+                })),+            };+            let decision_distance = partial_min(+                closest_point.euclidean_distance(&line.start_point()),+                closest_point.euclidean_distance(&line.end_point()),+            );+            if let Some(closest_edge) = closest_edge_option {+                let far_enough = edge_length / decision_distance > concavity;+                let are_edges_equal = closest_edge == line;+                if far_enough && are_edges_equal {+                    Some(Coordinate {+                        x: closest_point.x(),+                        y: closest_point.y(),+                    })+                } else {+                    None+                }+            } else {+                None+            }+        }+    }+}++// This takes significant inspiration from:+// https://github.com/mapbox/concaveman/blob/54838e1/index.js#L11+fn concave_hull<T>(coords: &mut [Coordinate<T>], concavity: T) -> LineString<T>+where+    T: Float + RTreeNum + HasKernel,+{+    let hull = qhull::quick_hull(coords);++    if coords.len() < 4 {+        return hull;+    }++    //Get points in overall dataset that aren't on the exterior linestring of the hull+    let hull_tree: RTree<Coordinate<T>> = RTree::bulk_load(hull.clone().0);++    let interior_coords: Vec<Coordinate<T>> = coords+        .iter()+        .filter_map(|coord| {+            if !hull_tree.contains(coord) {+                Some(*coord)+            } else {+                None+            }+        })

 where     fn reset_buffer(&mut self) {         // Reset buffer         self.buffer.clear();-        // Arbitrary bytes to take up space. Should never be seen in output.-        let placeholder: [u8; PLACEHOLDER_HEADER_SIZE] = *b"DACE\r\n";-        self.buffer.extend_from_slice(&placeholder);+        // Reserve space for the chunk size. This space will be populated once+        // we know the size of the chunk.+        self.buffer.resize(PLACEHOLDER_HEADER_SIZE, 0);

 where     fn reset_buffer(&mut self) {         // Reset buffer         self.buffer.clear();-        // Arbitrary bytes to take up space. Should never be seen in output.-        let placeholder: [u8; PLACEHOLDER_HEADER_SIZE] = *b"DACE\r\n";-        self.buffer.extend_from_slice(&placeholder);+        // Reserve space for the chunk size. This space will be populated once+        // we know the size of the chunk.+        self.buffer.resize(PLACEHOLDER_HEADER_SIZE, 0);

 where     fn reset_buffer(&mut self) {         // Reset buffer         self.buffer.clear();-        // Arbitrary bytes to take up space. Should never be seen in output.-        let placeholder: [u8; PLACEHOLDER_HEADER_SIZE] = *b"DACE\r\n";-        self.buffer.extend_from_slice(&placeholder);+        // Reserve space for the chunk size. This space will be populated once+        // we know the size of the chunk.+        self.buffer.resize(PLACEHOLDER_HEADER_SIZE, 0);