> {
+ self.delaunay
+ .to_convex_polygons()
+ .into_iter()
+ .map(|contour| self.adapter.points_from_int(&contour))
+ .collect()
+ }
+}
diff --git a/iTriangle/src/generic/custom.rs b/iTriangle/src/generic/custom.rs
new file mode 100644
index 0000000..d862c16
--- /dev/null
+++ b/iTriangle/src/generic/custom.rs
@@ -0,0 +1,365 @@
+use crate::generic::adapter::{IntPointAdapter, PointAdapter};
+use crate::generic::triangulation::RawTriangulation;
+use crate::int::custom::IntCustomTriangulatable;
+use crate::int::triangulation::RawIntTriangulation;
+use crate::int::validation::Validation;
+use i_key_sort::sort::key::SortKey;
+use i_overlay::i_float::adapter::FloatPointAdapter;
+use i_overlay::i_float::float::compatible::FloatPointCompatible;
+use i_overlay::i_float::float::rect::FloatRect;
+use i_overlay::i_float::int::number::int::IntNumber;
+use i_overlay::i_float::int::point::IntPoint;
+use i_overlay::i_shape::base::data::{Contour, Shape};
+use i_overlay::i_shape::float::rect::RectInit;
+use i_overlay::i_shape::int::shape::{IntContour, IntShape, IntShapes};
+use i_tree::{Expiration, LayoutNumber};
+
+/// A trait for triangulating geometry with user-defined validation rules.
+///
+/// Accepts a custom [`Validation`] object for tuning fill rule, min area, etc.
+pub trait CustomTriangulatable {
+ type Adapter: PointAdapter;
+
+ /// Performs triangulation using the specified [`Validation`] settings.
+ fn custom_triangulate(
+ &self,
+ validation: Validation<::Int>,
+ ) -> RawTriangulation;
+
+ /// Performs triangulation with Steiner points and a custom [`Validation`] config.
+ fn custom_triangulate_with_steiner_points(
+ &self,
+ points: &[P],
+ validation: Validation<::Int>,
+ ) -> RawTriangulation;
+}
+
+/// Float-only. You can choose the integer coordinate type to be used internally
+/// by the triangulator.
+pub trait CustomTriangulatableAs: CustomTriangulatable {
+ /// Performs triangulation using the requested integer coordinate type.
+ fn custom_triangulate_as(
+ &self,
+ validation: Validation,
+ ) -> RawTriangulation>
+ where
+ I: IntNumber + Expiration + LayoutNumber + SortKey;
+
+ /// Performs triangulation with Steiner points using the requested integer coordinate type.
+ fn custom_triangulate_with_steiner_points_as(
+ &self,
+ points: &[P],
+ validation: Validation,
+ ) -> RawTriangulation>
+ where
+ I: IntNumber + Expiration + LayoutNumber + SortKey;
+}
+
+impl CustomTriangulatable
for [P]
+where
+ P: FloatPointCompatible,
+{
+ type Adapter = FloatPointAdapter;
+
+ #[inline]
+ fn custom_triangulate(&self, validation: Validation) -> RawTriangulation {
+ self.custom_triangulate_as(validation)
+ }
+
+ #[inline]
+ fn custom_triangulate_with_steiner_points(
+ &self,
+ points: &[P],
+ validation: Validation,
+ ) -> RawTriangulation {
+ self.custom_triangulate_with_steiner_points_as(points, validation)
+ }
+}
+
+impl CustomTriangulatableAs
for [P]
+where
+ P: FloatPointCompatible,
+{
+ fn custom_triangulate_as(
+ &self,
+ validation: Validation,
+ ) -> RawTriangulation>
+ where
+ I: IntNumber + Expiration + LayoutNumber + SortKey,
+ {
+ if let Some(rect) = FloatRect::with_path(self) {
+ let adapter = FloatPointAdapter::::new(rect);
+ let int_contour: IntContour = adapter.points_to_int(self);
+ let raw = IntCustomTriangulatable::custom_triangulate(&int_contour, validation);
+ RawTriangulation { raw, adapter }
+ } else {
+ RawTriangulation {
+ raw: RawIntTriangulation::default(),
+ adapter: FloatPointAdapter::::new(FloatRect::zero()),
+ }
+ }
+ }
+
+ fn custom_triangulate_with_steiner_points_as(
+ &self,
+ points: &[P],
+ validation: Validation,
+ ) -> RawTriangulation>
+ where
+ I: IntNumber + Expiration + LayoutNumber + SortKey,
+ {
+ if let Some(rect) = FloatRect::with_path(self) {
+ let adapter = FloatPointAdapter::::new(rect);
+ let int_points = adapter.points_to_int(points);
+ let int_contour: IntContour = adapter.points_to_int(self);
+ let raw = IntCustomTriangulatable::custom_triangulate_with_steiner_points(
+ &int_contour,
+ &int_points,
+ validation,
+ );
+ RawTriangulation { raw, adapter }
+ } else {
+ RawTriangulation {
+ raw: RawIntTriangulation::default(),
+ adapter: FloatPointAdapter::::new(FloatRect::zero()),
+ }
+ }
+ }
+}
+
+impl CustomTriangulatable
for [Contour
]
+where
+ P: FloatPointCompatible,
+{
+ type Adapter = FloatPointAdapter;
+
+ #[inline]
+ fn custom_triangulate(&self, validation: Validation) -> RawTriangulation {
+ self.custom_triangulate_as(validation)
+ }
+
+ #[inline]
+ fn custom_triangulate_with_steiner_points(
+ &self,
+ points: &[P],
+ validation: Validation,
+ ) -> RawTriangulation {
+ self.custom_triangulate_with_steiner_points_as(points, validation)
+ }
+}
+
+impl CustomTriangulatableAs
for [Contour
]
+where
+ P: FloatPointCompatible,
+{
+ fn custom_triangulate_as(
+ &self,
+ validation: Validation,
+ ) -> RawTriangulation>
+ where
+ I: IntNumber + Expiration + LayoutNumber + SortKey,
+ {
+ if let Some(rect) = FloatRect::with_paths(self) {
+ let adapter = FloatPointAdapter::::new(rect);
+ let int_shape: IntShape = self.iter().map(|c| adapter.points_to_int(c)).collect();
+ let raw = IntCustomTriangulatable::custom_triangulate(&int_shape, validation);
+ RawTriangulation { raw, adapter }
+ } else {
+ RawTriangulation {
+ raw: RawIntTriangulation::default(),
+ adapter: FloatPointAdapter::::new(FloatRect::zero()),
+ }
+ }
+ }
+
+ fn custom_triangulate_with_steiner_points_as(
+ &self,
+ points: &[P],
+ validation: Validation,
+ ) -> RawTriangulation>
+ where
+ I: IntNumber + Expiration + LayoutNumber + SortKey,
+ {
+ if let Some(rect) = FloatRect::with_paths(self) {
+ let adapter = FloatPointAdapter::::new(rect);
+ let int_points = adapter.points_to_int(points);
+ let int_shape: IntShape = self.iter().map(|c| adapter.points_to_int(c)).collect();
+ let raw = IntCustomTriangulatable::custom_triangulate_with_steiner_points(
+ &int_shape,
+ &int_points,
+ validation,
+ );
+ RawTriangulation { raw, adapter }
+ } else {
+ RawTriangulation {
+ raw: RawIntTriangulation::default(),
+ adapter: FloatPointAdapter::::new(FloatRect::zero()),
+ }
+ }
+ }
+}
+
+impl CustomTriangulatable
for [Shape
]
+where
+ P: FloatPointCompatible,
+{
+ type Adapter = FloatPointAdapter;
+
+ #[inline]
+ fn custom_triangulate(&self, validation: Validation) -> RawTriangulation {
+ self.custom_triangulate_as(validation)
+ }
+
+ #[inline]
+ fn custom_triangulate_with_steiner_points(
+ &self,
+ points: &[P],
+ validation: Validation,
+ ) -> RawTriangulation {
+ self.custom_triangulate_with_steiner_points_as(points, validation)
+ }
+}
+
+impl CustomTriangulatableAs
for [Shape
]
+where
+ P: FloatPointCompatible,
+{
+ fn custom_triangulate_as(
+ &self,
+ validation: Validation,
+ ) -> RawTriangulation>
+ where
+ I: IntNumber + Expiration + LayoutNumber + SortKey,
+ {
+ if let Some(rect) = FloatRect::with_list_of_paths(self) {
+ let adapter = FloatPointAdapter::::new(rect);
+ let int_shapes: IntShapes = self
+ .iter()
+ .map(|shape| shape.iter().map(|c| adapter.points_to_int(c)).collect())
+ .collect();
+ let raw = IntCustomTriangulatable::custom_triangulate(&int_shapes, validation);
+ RawTriangulation { raw, adapter }
+ } else {
+ RawTriangulation {
+ raw: RawIntTriangulation::default(),
+ adapter: FloatPointAdapter::::new(FloatRect::zero()),
+ }
+ }
+ }
+
+ fn custom_triangulate_with_steiner_points_as(
+ &self,
+ points: &[P],
+ validation: Validation,
+ ) -> RawTriangulation>
+ where
+ I: IntNumber + Expiration + LayoutNumber + SortKey,
+ {
+ if let Some(rect) = FloatRect::with_list_of_paths(self) {
+ let adapter = FloatPointAdapter::::new(rect);
+ let int_points = adapter.points_to_int(points);
+ let int_shapes: IntShapes = self
+ .iter()
+ .map(|shape| shape.iter().map(|c| adapter.points_to_int(c)).collect())
+ .collect();
+ let raw = IntCustomTriangulatable::custom_triangulate_with_steiner_points(
+ &int_shapes,
+ &int_points,
+ validation,
+ );
+ RawTriangulation { raw, adapter }
+ } else {
+ RawTriangulation {
+ raw: RawIntTriangulation::default(),
+ adapter: FloatPointAdapter::::new(FloatRect::zero()),
+ }
+ }
+ }
+}
+
+impl CustomTriangulatable> for IntContour
+where
+ I: IntNumber + Expiration + LayoutNumber + SortKey,
+{
+ type Adapter = IntPointAdapter;
+
+ #[inline]
+ fn custom_triangulate(&self, validation: Validation) -> RawTriangulation {
+ RawTriangulation::new(
+ IntCustomTriangulatable::custom_triangulate(self, validation),
+ IntPointAdapter::new(),
+ )
+ }
+
+ #[inline]
+ fn custom_triangulate_with_steiner_points(
+ &self,
+ points: &[IntPoint],
+ validation: Validation,
+ ) -> RawTriangulation {
+ RawTriangulation::new(
+ IntCustomTriangulatable::custom_triangulate_with_steiner_points(
+ self, points, validation,
+ ),
+ IntPointAdapter::new(),
+ )
+ }
+}
+
+impl CustomTriangulatable> for IntShape
+where
+ I: IntNumber + Expiration + LayoutNumber + SortKey,
+{
+ type Adapter = IntPointAdapter;
+
+ #[inline]
+ fn custom_triangulate(&self, validation: Validation) -> RawTriangulation {
+ RawTriangulation::new(
+ IntCustomTriangulatable::custom_triangulate(self, validation),
+ IntPointAdapter::new(),
+ )
+ }
+
+ #[inline]
+ fn custom_triangulate_with_steiner_points(
+ &self,
+ points: &[IntPoint],
+ validation: Validation,
+ ) -> RawTriangulation {
+ RawTriangulation::new(
+ IntCustomTriangulatable::custom_triangulate_with_steiner_points(
+ self, points, validation,
+ ),
+ IntPointAdapter::new(),
+ )
+ }
+}
+
+impl CustomTriangulatable> for IntShapes
+where
+ I: IntNumber + Expiration + LayoutNumber + SortKey,
+{
+ type Adapter = IntPointAdapter;
+
+ #[inline]
+ fn custom_triangulate(&self, validation: Validation) -> RawTriangulation {
+ RawTriangulation::new(
+ IntCustomTriangulatable::custom_triangulate(self, validation),
+ IntPointAdapter::new(),
+ )
+ }
+
+ #[inline]
+ fn custom_triangulate_with_steiner_points(
+ &self,
+ points: &[IntPoint],
+ validation: Validation,
+ ) -> RawTriangulation {
+ RawTriangulation::new(
+ IntCustomTriangulatable::custom_triangulate_with_steiner_points(
+ self, points, validation,
+ ),
+ IntPointAdapter::new(),
+ )
+ }
+}
diff --git a/iTriangle/src/float/delaunay.rs b/iTriangle/src/generic/delaunay.rs
similarity index 52%
rename from iTriangle/src/float/delaunay.rs
rename to iTriangle/src/generic/delaunay.rs
index 6a31a62..bb5a205 100644
--- a/iTriangle/src/float/delaunay.rs
+++ b/iTriangle/src/generic/delaunay.rs
@@ -1,31 +1,28 @@
use crate::advanced::buffer::DelaunayBuffer;
use crate::advanced::delaunay::IntDelaunay;
-use crate::float::triangulation::{RawTriangulation, Triangulation};
+use crate::generic::adapter::PointAdapter;
+use crate::generic::triangulation::{RawTriangulation, Triangulation};
use crate::int::triangulation::IndexType;
use alloc::vec::Vec;
-use i_overlay::i_float::adapter::FloatPointAdapter;
-use i_overlay::i_float::float::compatible::FloatPointCompatible;
-use i_overlay::i_float::int::number::int::IntNumber;
-use i_overlay::i_shape::float::adapter::PathToFloat;
-/// A Delaunay-refined triangle mesh with float-mapped geometry.
+/// A Delaunay-refined triangle mesh with adapter-mapped geometry.
///
-/// Produced from [`Triangulation::into_delaunay`] by applying edge flips
+/// Produced from [`RawTriangulation::into_delaunay`] by applying edge flips
/// to satisfy the Delaunay condition.
-pub struct Delaunay {
- pub(super) delaunay: IntDelaunay,
- pub(super) adapter: FloatPointAdapter,
+pub struct Delaunay
```rust
-use i_triangle::float::triangulatable::Triangulatable;
-use i_triangle::float::triangulation::Triangulation;
+use i_triangle::generic::triangulatable::Triangulatable;
+use i_triangle::generic::triangulation::Triangulation;
let shape = vec![
vec![
@@ -199,8 +200,8 @@ println!("centroids: {:?}", centroids);
If you need to triangulate many shapes, it is more efficient to use `Triangulator`.
```rust
-use i_triangle::float::triangulation::Triangulation;
-use i_triangle::float::triangulator::Triangulator;
+use i_triangle::generic::triangulation::Triangulation;
+use i_triangle::generic::triangulator::Triangulator;
let contours = vec![
vec![[0.0, 0.0], [4.0, 0.0], [4.0, 4.0], [0.0, 4.0]],
diff --git a/iTriangle/src/float/centroid_net.rs b/iTriangle/src/float/centroid_net.rs
deleted file mode 100644
index 92c3191..0000000
--- a/iTriangle/src/float/centroid_net.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use crate::float::delaunay::Delaunay;
-use alloc::vec::Vec;
-use i_overlay::i_float::float::compatible::FloatPointCompatible;
-use i_overlay::i_float::int::number::int::IntNumber;
-use i_overlay::i_float::int::number::wide_int::WideIntNumber;
-use i_overlay::i_shape::base::data::Contour;
-use i_overlay::i_shape::float::adapter::ShapeToFloat;
-
-impl