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

mod path_64;
pub use path_64::*;

mod paths_64;
pub use paths_64::*;

mod clipper_64;
pub use clipper_64::*;

mod poly_tree_64;
pub use poly_tree_64::*;

use crate::{clipper2::*, malloc, EndType, JoinType, PathD, PathsD};

pub type Point64 = ClipperPoint64;

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

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

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

    pub fn to_pathd(&self) -> PathD {
        unsafe {
            let mem = malloc(clipper_pathd_size());
            let pathd_ptr = clipper_path64_to_pathd(mem, self.get_clipper_path());
            let pathd = PathD::from(pathd_ptr);
            clipper_delete_pathd(pathd_ptr);
            pathd
        }
    }
}

impl Paths64 {
    pub(crate) fn from(ptr: *mut ClipperPaths64) -> Self {
        let paths = unsafe {
            let len: i32 = clipper_paths64_length(ptr).try_into().unwrap();
            (0..len)
                .map(|i| {
                    let point_len: i32 = clipper_paths64_path_length(ptr, i).try_into().unwrap();
                    let points = (0..point_len)
                        .map(|j| clipper_paths64_get_point(ptr, i, j))
                        .collect();
                    Path64::new(&points)
                })
                .collect()
        };
        Self::new(&paths)
    }

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

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

    pub fn inflate(
        &self,
        delta: f64,
        join_type: JoinType,
        end_type: EndType,
        miter_limit: f64,
    ) -> Paths64 {
        unsafe {
            let mem = malloc(clipper_paths64_size());
            let paths_ptr = clipper_paths64_inflate(
                mem,
                self.get_clipper_paths(),
                delta,
                join_type.into(),
                end_type.into(),
                miter_limit,
            );
            let paths = Self::from(paths_ptr);
            clipper_delete_paths64(paths_ptr);
            paths
        }
    }

    pub fn to_pathsd(&self) -> PathsD {
        unsafe {
            let mem = malloc(clipper_pathd_size());
            let pathsd_ptr = clipper_paths64_to_pathsd(mem, self.get_clipper_paths());
            let pathsd = PathsD::from(pathsd_ptr);
            clipper_delete_pathsd(pathsd_ptr);
            pathsd
        }
    }
}