ClipperOffset

src/lib.rs

@@ -70,12 +70,14 @@ mod options;
 mod path;
 mod paths;
 mod point;
+mod offset;
 
 use clipper2c_sys::clipper_allocate;
 
 pub use crate::bounds::*;
 pub use crate::clipper::*;
 pub use crate::operations::*;
+pub use crate::offset::*;
 pub use crate::options::*;
 pub use crate::path::*;
 pub use crate::paths::*;

src/offset.rs

@@ -0,0 +1,102 @@
+pub struct ClipperOffset {
+    ptr: *mut clipper2c_sys::ClipperClipperOffset,
+}
+
+impl Drop for ClipperOffset {
+    fn drop(&mut self) {
+        unsafe {
+            clipper2c_sys::clipper_delete_clipperoffset(self.ptr);
+        }
+    }
+}
+
+impl ClipperOffset {
+    pub fn new(config: ClipperOffsetConfig) -> Self {
+        let ptr = unsafe {
+            let mem = crate::malloc(clipper2c_sys::clipper_clipperoffset_size());
+            clipper2c_sys::clipper_clipperoffset(
+                mem,
+                config.miter_limit,
+                config.arc_tolerance,
+                config.preserve_collinear,
+                config.reverse_solution,
+            )
+        };
+        Self { ptr }
+    }
+
+    pub fn add_path(&self, p: crate::Path, jt: clipper2c_sys::ClipperJoinType, et: clipper2c_sys::ClipperEndType) {
+        unsafe {
+            clipper2c_sys::clipper_clipperoffset_add_path64(self.ptr, p.to_clipperpath64(), jt, et);
+        }
+    }
+
+    pub fn add_paths(&self, p: crate::Paths, jt: clipper2c_sys::ClipperJoinType, et: clipper2c_sys::ClipperEndType) {
+        unsafe {
+            clipper2c_sys::clipper_clipperoffset_add_paths64(
+                self.ptr,
+                p.to_clipperpaths64(),
+                jt,
+                et,
+            );
+        }
+    }
+
+    pub fn clear(&self) {
+        unsafe {
+            clipper2c_sys::clipper_clipperoffset_clear(self.ptr);
+        }
+    }
+
+    pub fn error_code(&self) -> i32 {
+        unsafe { clipper2c_sys::clipper_clipperoffset_error_code(self.ptr) }
+    }
+
+    pub fn execute(&self, delta: f64) -> crate::Paths {
+        unsafe {
+            let mem = crate::malloc(clipper2c_sys::clipper_paths64_size());
+
+            crate::Paths::from_clipperpaths64(clipper2c_sys::clipper_clipperoffset_execute(
+                mem, self.ptr, delta,
+            ))
+        }
+    }
+}
+
+pub struct ClipperOffsetConfig {
+    /// Default: 2.0,
+    miter_limit: f64,
+    /// Default: 0.0,
+    arc_tolerance: f64,
+    /// Default: false
+    preserve_collinear: ::std::os::raw::c_int,
+    /// Default: false
+    reverse_solution: ::std::os::raw::c_int,
+}
+
+impl Default for ClipperOffsetConfig {
+    fn default() -> Self {
+        Self {
+            miter_limit: 2.0,
+            arc_tolerance: 0.0,
+            preserve_collinear: 0,
+            reverse_solution: 0,
+        }
+    }
+}
+
+impl ClipperOffsetConfig {
+    pub fn new(
+        miter_limit: f64,
+        arc_tolerance: f64,
+        preserve_collinear: bool,
+        reverse_solution: bool,
+    ) -> Self {
+        Self {
+            miter_limit,
+            arc_tolerance,
+            preserve_collinear: preserve_collinear as ::std::os::raw::c_int,
+            reverse_solution: reverse_solution as ::std::os::raw::c_int,
+        }
+    }
+}