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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use std::os::raw::c_int;

mod path_d;
pub use path_d::*;

mod paths_d;
pub use paths_d::*;

mod clipper_d;
pub use clipper_d::*;

mod poly_tree_d;
pub use poly_tree_d::*;

use crate::{clipper2::*, malloc, EndType, JoinType, Path64, Paths64};

pub type PointD = ClipperPointD;

impl PathD {
    pub(crate) fn from(ptr: *mut ClipperPathD) -> Self {
        let points = unsafe {
            let len: i32 = clipper_pathd_length(ptr).try_into().unwrap();
            (0..len).map(|i| clipper_pathd_get_point(ptr, i)).collect()
        };
        Self::new(&points)
    }

    pub(crate) fn get_clipper_path(&self) -> *mut ClipperPathD {
        unsafe {
            let mem = malloc(clipper_pathd_size());
            clipper_pathd_of_points(mem, self.0.clone().as_mut_ptr(), self.len())
        }
    }
}

impl PathD {
    pub fn simplify(&self, epsilon: f64, is_open_path: bool) -> PathD {
        unsafe {
            let mem = malloc(clipper_pathd_size());
            let path_ptr = clipper_pathd_simplify(
                mem,
                self.get_clipper_path(),
                epsilon,
                if is_open_path { 1 } else { 0 },
            );
            let path = Self::from(path_ptr);
            clipper_delete_pathd(path_ptr);
            path
        }
    }

    pub fn to_path64(&self) -> Path64 {
        unsafe {
            let mem = malloc(clipper_path64_size());
            let path64_ptr = clipper_pathd_to_path64(mem, self.get_clipper_path());
            let path64 = Path64::from(path64_ptr);
            clipper_delete_path64(path64_ptr);
            path64
        }
    }
}

impl PathsD {
    pub(crate) fn from(ptr: *mut ClipperPathsD) -> Self {
        let paths = unsafe {
            let len: i32 = clipper_pathsd_length(ptr).try_into().unwrap();
            (0..len)
                .map(|i| {
                    let point_len: i32 = clipper_pathsd_path_length(ptr, i).try_into().unwrap();
                    let points = (0..point_len)
                        .map(|j| clipper_pathsd_get_point(ptr, i, j))
                        .collect();
                    PathD::new(&points)
                })
                .collect()
        };
        Self::new(&paths)
    }

    pub(crate) fn get_clipper_paths(&self) -> *mut ClipperPathsD {
        unsafe {
            let mem = malloc(clipper_pathsd_size());
            let mut paths = self
                .0
                .iter()
                .map(|p| p.get_clipper_path())
                .collect::<Vec<*mut ClipperPathD>>();
            clipper_pathsd_of_paths(mem, paths.as_mut_ptr(), self.len())
        }
    }
}

impl PathsD {
    pub fn simplify(&self, epsilon: f64, is_open_path: bool) -> PathsD {
        unsafe {
            let mem = malloc(clipper_pathsd_size());
            let paths_ptr = clipper_pathsd_simplify(
                mem,
                self.get_clipper_paths(),
                epsilon,
                if is_open_path { 1 } else { 0 },
            );
            let paths = Self::from(paths_ptr);
            clipper_delete_pathsd(paths_ptr);
            paths
        }
    }

    pub fn inflate(
        &self,
        delta: f64,
        join_type: JoinType,
        end_type: EndType,
        miter_limit: f64,
        precision: c_int,
    ) -> PathsD {
        unsafe {
            let mem = malloc(clipper_pathsd_size());
            let paths_ptr = clipper_pathsd_inflate(
                mem,
                self.get_clipper_paths(),
                delta,
                join_type.into(),
                end_type.into(),
                miter_limit,
                precision,
            );
            let paths = Self::from(paths_ptr);
            clipper_delete_pathsd(paths_ptr);
            paths
        }
    }

    pub fn to_paths64(&self) -> Paths64 {
        unsafe {
            let mem = malloc(clipper_paths64_size());
            let paths64_ptr = clipper_pathsd_to_paths64(mem, self.get_clipper_paths());
            let paths64 = Paths64::from(paths64_ptr);
            clipper_delete_paths64(paths64_ptr);
            paths64
        }
    }
}