i_triangle 0.42.0

Polygon Triangulation Library: Efficient Delaunay Triangulation for Complex Shapes.
Documentation 
1
2
3
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use crate::int::meta::TrianglesCount;
use crate::int::monotone::chain::builder::ChainBuilder;
use crate::int::monotone::chain::vertex::ChainVertex;
use crate::int::monotone::flat::triangulator::FlatTriangulation;
use crate::int::monotone::net::triangulator::NetTriangulation;
use crate::int::triangulation::{IndexType, IntTriangulation, RawIntTriangulation};
use alloc::vec::Vec;
use i_overlay::i_float::int::point::IntPoint;
use i_overlay::i_shape::flat::buffer::FlatContoursBuffer;
use i_overlay::i_shape::int::shape::{IntContour, IntShape};

#[derive(Default)]
pub(crate) struct MonotoneTriangulator {
    vertices: Option<Vec<ChainVertex>>,
}

impl MonotoneTriangulator {
    #[inline]
    pub(crate) fn shape_into_net_triangulation(
        &mut self,
        shape: &IntShape,
        points: Option<&[IntPoint]>,
        triangulation: &mut RawIntTriangulation,
    ) {
        let points_count = points.map(|points| points.len()).unwrap_or(0);

        let mut vertices = self.vertices.take().unwrap_or_default();
        ChainBuilder::shape_to_vertices(shape, points, &mut vertices);

        vertices.net_triangulate_into(shape.triangles_count(points_count), triangulation);

        self.vertices = Some(vertices);
    }

    #[inline]
    pub(crate) fn contour_into_net_triangulation(
        &mut self,
        contour: &IntContour,
        points: Option<&[IntPoint]>,
        triangulation: &mut RawIntTriangulation,
    ) {
        let points_count = points.map(|points| points.len()).unwrap_or(0);

        let mut vertices = self.vertices.take().unwrap_or_default();
        ChainBuilder::contour_to_vertices(contour, points, &mut vertices);

        vertices.net_triangulate_into(contour.triangles_count(points_count), triangulation);

        self.vertices = Some(vertices);
    }

    #[inline]
    pub(crate) fn flat_into_net_triangulation(
        &mut self,
        flat: &FlatContoursBuffer,
        triangulation: &mut RawIntTriangulation,
    ) {
        let mut vertices = self.vertices.take().unwrap_or_default();
        ChainBuilder::flat_to_vertices(flat, &mut vertices);

        vertices.net_triangulate_into(flat.triangles_count(0), triangulation);

        self.vertices = Some(vertices);
    }

    #[inline]
    pub(crate) fn shape_into_flat_triangulation<I: IndexType>(
        &mut self,
        shape: &IntShape,
        triangulation: &mut IntTriangulation<I>,
    ) {
        let mut vertices = self.vertices.take().unwrap_or_default();
        ChainBuilder::shape_to_vertices(shape, None, &mut vertices);

        vertices.flat_triangulate_into(shape.triangles_count(0), triangulation);

        self.vertices = Some(vertices);
    }

    #[inline]
    pub(crate) fn contour_into_flat_triangulation<I: IndexType>(
        &mut self,
        contour: &IntContour,
        triangulation: &mut IntTriangulation<I>,
    ) {
        let mut vertices = self.vertices.take().unwrap_or_default();
        ChainBuilder::contour_to_vertices(contour, None, &mut vertices);

        vertices.flat_triangulate_into(contour.triangles_count(0), triangulation);

        self.vertices = Some(vertices);
    }

    #[inline]
    pub(crate) fn flat_into_flat_triangulation<I: IndexType>(
        &mut self,
        flat: &FlatContoursBuffer,
        triangulation: &mut IntTriangulation<I>,
    ) {
        let mut vertices = self.vertices.take().unwrap_or_default();
        ChainBuilder::flat_to_vertices(flat, &mut vertices);

        vertices.flat_triangulate_into(flat.triangles_count(0), triangulation);

        self.vertices = Some(vertices);
    }
}