Clipper2-sys

https://docs.rs/clipper2-sys/0.5.0/
Admin
Clipper2-sys is a Rust FFI binding for the Clipper2 polygon clipping library, providing low-level...
Tokens:23,975
Snippets:77
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Initialize and manage ClipperD object in Rust

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/double/clipper_d

Demonstrates the creation of a `ClipperD` object, setting and getting properties like `preserve_collinear` and `reverse_solution`, clearing the clipper, and adding subject and clip paths. It also includes the implementation of the `Drop` trait for proper resource deallocation.

```Rust
use std::os::raw::c_int;

use crate::{
    clipper_clipperd,
    clipper_clipperd_add_clip,
    clipper_clipperd_add_open_subject,
    clipper_clipperd_add_subject,
    clipper_clipperd_clear,
    clipper_clipperd_execute,
    clipper_clipperd_execute_tree_with_open,
    clipper_clipperd_get_preserve_collinear,
    clipper_clipperd_get_reverse_solution,
    clipper_clipperd_set_preserve_collinear,
    clipper_clipperd_set_reverse_solution,
    clipper_clipperd_size,
    clipper_delete_clipperd,
    clipper_delete_pathsd,
    clipper_delete_polytreed,
    clipper_polytreed,
    clipper_polytreed_size,
    malloc,
    ClipType,
    ClipperClipperD,
    FillRule,
    PathsD,
    PolyTreeD,
};

pub struct ClipperD {
    ptr: *mut ClipperClipperD,
}

impl ClipperD {
    pub fn new(precision: c_int) -> Self {
        let ptr = unsafe {
            let mem = malloc(clipper_clipperd_size());
            clipper_clipperd(mem, precision)
        };
        Self { ptr: ptr }
    }

    pub fn set_preserve_collinear(&self, value: bool) {
        unsafe { clipper_clipperd_set_preserve_collinear(self.ptr, if value { 1 } else { 0 }) }
    }

    pub fn get_preserve_collinear(&self) -> bool {
        unsafe { clipper_clipperd_get_preserve_collinear(self.ptr) == 1 }
    }

    pub fn set_reverse_solution(&self, value: bool) {
        unsafe { clipper_clipperd_set_reverse_solution(self.ptr, if value { 1 } else { 0 }) }
    }

    pub fn get_reverse_solution(&self) -> bool {
        unsafe { clipper_clipperd_get_reverse_solution(self.ptr) == 1 }
    }

    pub fn clear(&self) {
        unsafe { clipper_clipperd_clear(self.ptr) }
    }

    pub fn add_open_subject(&self, open_subject: PathsD) {
        unsafe {
            let path_prt = open_subject.get_clipper_paths();
            clipper_clipperd_add_open_subject(self.ptr, path_prt);
            clipper_delete_pathsd(path_prt);
        }
    }

    pub fn add_subject(&self, subject: PathsD) {
        unsafe {
            let path_prt = subject.get_clipper_paths();
            clipper_clipperd_add_subject(self.ptr, path_prt);
            clipper_delete_pathsd(path_prt);
        }
    }

    pub fn add_clip(&self, clip: PathsD) {
        unsafe {
            let path_prt = clip.get_clipper_paths();
            clipper_clipperd_add_clip(self.ptr, path_prt);
            clipper_delete_pathsd(path_prt);
        }
    }

    pub fn boolean_operation(&self, clip_type: ClipType, fill_rule: FillRule) -> PathsD {
        let closed_path = PathsD::new(&vec![]).get_clipper_paths();
        let open_path = PathsD::new(&vec![]).get_clipper_paths();
        unsafe {
            let is_success = clipper_clipperd_execute(
                self.ptr,
                clip_type.into(),
                fill_rule.into(),
                closed_path,
                open_path,
            );

            let path = PathsD::from(closed_path);
            clipper_delete_pathsd(closed_path);
            clipper_delete_pathsd(open_path);
            path
        }
    }

    pub fn boolean_operation_tree(&self, clip_type: ClipType, fill_rule: FillRule) -> PolyTreeD {
        let tree_ptr = unsafe {
            let mem = malloc(clipper_polytreed_size());
            clipper_polytreed(mem, std::ptr::null_mut())
        };
        let open_path = PathsD::new(&vec![]).get_clipper_paths();
        unsafe {
            let is_success = clipper_clipperd_execute_tree_with_open(
                self.ptr,
                clip_type.into(),
                fill_rule.into(),
                tree_ptr,
                open_path,
            );
            clipper_delete_pathsd(open_path);
            let tree = PolyTreeD::from(tree_ptr);
            clipper_delete_polytreed(tree_ptr);
            tree
        }
    }
}

impl Drop for ClipperD {
    fn drop(&mut self) {
        unsafe { clipper_delete_clipperd(self.ptr) }
    }
}
```

--------------------------------

### Rust PathsD Struct and Methods

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/double/paths_d

This Rust code defines the `PathsD` struct, which is a wrapper around a `Vec<PathD>`. It provides methods for creating, manipulating, and accessing paths, including checking emptiness, getting length, retrieving specific paths, adding paths, and performing translations and scaling operations.

```Rust
use crate::PathD;

#[derive(Clone, Debug)]
pub struct PathsD(pub(crate) Vec<PathD>);

impl PathsD {
    pub fn new(paths: &Vec<PathD>) -> Self {
        Self(paths.clone())
    }

    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    pub fn len(&self) -> usize {
        self.0.len()
    }

    pub fn get_path(&self, index: usize) -> PathD {
        self.0[index].clone()
    }

    pub fn add_path(&mut self, path: PathD) {
        self.0.push(path)
    }

    pub fn add_paths(&mut self, mut paths: Vec<PathD>) {
        self.0.append(&mut paths)
    }

    pub fn get_paths(&self) -> Vec<PathD> {
        self.0.clone()
    }

    pub fn translate(&self, dx: f64, dy: f64) -> Self {
        let new_paths = self.0.iter().map(|p| p.translate(dx, dy)).collect();
        Self(new_paths)
    }

    pub fn scale(&self, sx: f64, sy: f64) -> Self {
        let new_paths = self.0.iter().map(|p| p.scale(sx, sy)).collect();
        Self(new_paths)
    }
}
```

--------------------------------

### Path64 Struct and Methods in Rust

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/int64/path_64

Defines the Path64 struct and its associated methods for manipulating 2D paths. This includes functionalities for creating a new path, checking if it's empty, getting its length, retrieving a specific point, adding a new point, translating the path by a given delta, and scaling the path by given factors.

```Rust
use crate::Point64;

#[derive(Clone, Debug)]
pub struct Path64(pub(crate) Vec<Point64>);

impl Path64 {
    pub fn new(points: &Vec<Point64>) -> Self {
        Self(points.clone())
    }

    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    pub fn len(&self) -> usize {
        self.0.len()
    }

    pub fn get_point(&self, index: usize) -> Point64 {
        self.0[index]
    }

    pub fn add_point(&mut self, point: Point64) {
        self.0.push(point)
    }

    pub fn translate(&self, dx: i64, dy: i64) -> Self {
        let new_points = self
            .0
            .iter()
            .map(|p| Point64 {
                x: p.x + dx,
                y: p.y + dy,
            })
            .collect();
        Self(new_points)
    }

    pub fn scale(&self, sx: f64, sy: f64) -> Self {
        let mut _sx = sx;
        if _sx == 0. {
            _sx = 1.;
        }
        let mut _sy = sy;
        if _sy == 0. {
            _sy = 1.;
        }
        let new_points = self
            .0
            .iter()
            .map(|p| Point64 {
                x: ((p.x as f64) * sx) as i64,
                y: ((p.y as f64) * sy) as i64,
            })
            .collect();
        Self(new_points)
    }
}
```

--------------------------------

### Rust Paths64 Structure and Methods

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/int64/paths_64

This snippet defines the `Paths64` struct in Rust, which is a wrapper around a vector of `Path64` objects. It includes methods for creating, manipulating, and accessing paths, such as checking emptiness, getting length, retrieving specific paths, adding paths, and performing translations and scaling operations.

```Rust
use crate::Path64;

#[derive(Clone, Debug)]
pub struct Paths64(pub(crate) Vec<Path64>);

impl Paths64 {
    pub fn new(paths: &Vec<Path64>) -> Self {
        Self(paths.clone())
    }

    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    pub fn len(&self) -> usize {
        self.0.len()
    }

    pub fn get_path(&self, index: usize) -> Path64 {
        self.0[index].clone()
    }

    pub fn add_path(&mut self, path: Path64) {
        self.0.push(path)
    }

    pub fn add_paths(&mut self, mut paths: Vec<Path64>) {
        self.0.append(&mut paths)
    }

    pub fn get_paths(&self) -> Vec<Path64> {
        self.0.clone()
    }

    pub fn translate(&self, dx: i64, dy: i64) -> Self {
        let new_paths = self.0.iter().map(|p| p.translate(dx, dy)).collect();
        Self(new_paths)
    }

    pub fn scale(&self, sx: f64, sy: f64) -> Self {
        let new_paths = self.0.iter().map(|p| p.scale(sx, sy)).collect();
        Self(new_paths)
    }
}
```

--------------------------------

### Get ClipperPath64 from Path64 in Rust

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/int64

Provides a method to obtain a raw ClipperPath64 pointer from a Rust Path64 struct. This involves allocating memory and calling a C++ function to create the Clipper path.

```rust
impl Path64 {
    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())
        }
    }
```

--------------------------------

### Rust PolyTreeD Methods for Accessing Data

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/double/poly_tree_d

Provides methods for the PolyTreeD struct to access its internal data. These include getting mutable access to child nodes, checking if a polygon is a hole, retrieving all hole paths, getting the main polygon, and accessing the scale factor. These methods facilitate interaction with the polygon tree data.

```Rust
impl PolyTreeD {

    pub fn get_childs(&mut self) -> &mut Vec<Self> {
        &mut self.childs
    }

    pub fn is_hole(&self) -> bool {
        self.is_hole
    }

    pub fn get_hole_paths(&self) -> PathsD {
        let mut paths = PathsD::new(&vec![]);
        for child in &self.childs {
            if child.is_hole {
                paths.add_path(child.get_polygon());
            }
        }
        paths
    }

    pub fn get_polygon(&self) -> PathD {
        self.polygon.clone()
    }

    pub fn scale(&self) -> f64 {
        self.scale
    }
}
```

--------------------------------

### Get ClipperPaths64 from Paths64 in Rust

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/int64

Provides a method to obtain a raw ClipperPaths64 pointer from a Rust Paths64 struct. This involves allocating memory and converting each Path64 to its C++ representation.

```rust
impl Paths64 {
    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>>();
            let result = clipper_paths64_of_paths(mem, paths.as_mut_ptr(), self.len());
            for prt in paths {
                clipper_delete_path64(prt);
            }
            result
        }
    }
```

--------------------------------

### Rust PolyTreeD Structure and Initialization

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/double/poly_tree_d

Defines the PolyTreeD struct in Rust, which represents a polygon tree structure. It includes methods for initializing the struct from a C pointer, accessing child nodes, checking if a polygon is a hole, retrieving the polygon's paths, and getting the scale factor. The initialization involves unsafe Rust code to interact with C functions.

```Rust
use crate {
    clipper_delete_pathd,
    clipper_pathd_size,
    clipper_polytreed_count,
    clipper_polytreed_get_child,
    clipper_polytreed_inv_scale,
    clipper_polytreed_is_hole,
    clipper_polytreed_polygon,
    malloc,
    ClipperPolyTreeD,
    PathD,
    PathsD,
};

#[derive(Debug)]
pub struct PolyTreeD {
    pub(crate) childs: Vec<Self>,
    pub(crate) is_hole: bool,
    pub(crate) polygon: PathD,
    pub(crate) scale: f64,
}

impl PolyTreeD {
    pub(crate) fn from(ptr: *mut ClipperPolyTreeD) -> Self {
        let is_hole: bool;
        let scale: f64;
        let polygon: PathD;
        let childs: Vec<Self>;
        unsafe {
            is_hole = clipper_polytreed_is_hole(ptr) == 1;
            scale = clipper_polytreed_inv_scale(ptr);
            let mem = malloc(clipper_pathd_size());
            let polygon_prt = clipper_polytreed_polygon(mem, ptr);
            polygon = PathD::from(polygon_prt);
            clipper_delete_pathd(polygon_prt);
            let count = clipper_polytreed_count(ptr);
            childs = (0..count)
                .map(|i| {
                    let tree_ptr = clipper_polytreed_get_child(ptr, i);
                    Self::from(tree_ptr as *mut ClipperPolyTreeD)
                })
                .collect();
        }
        Self {
            childs: childs,
            is_hole: is_hole,
            polygon: polygon,
            scale: scale,
        }
    }
}
```

--------------------------------

### Rust: Calculate Area of Paths64

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/int64

Computes the total area of a collection of paths (Paths64) using the Clipper2 library. This involves getting the C++ pointer for the paths, calling the area function, and cleaning up memory.

```rust
unsafe {
            let paths64_prt = self.get_clipper_paths();
            let reuslt = clipper_paths64_area(paths64_prt);
            clipper_delete_paths64(paths64_prt);
            reuslt
        }
```

--------------------------------

### PathD Struct and Methods in Rust

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/double/path_d

This Rust code defines the PathD struct, which represents a 2D path composed of a vector of PointD. It includes methods for creating a new path, checking if it's empty, getting its length, accessing points by index, adding points, translating the path by a given delta, and scaling the path by given factors. The translate and scale methods return new PathD instances with the modified coordinates.

```Rust
use crate::PointD;

#[derive(Clone, Debug)]
pub struct PathD(pub(crate) Vec<PointD>);

impl PathD {
    pub fn new(points: &Vec<PointD>) -> Self {
        Self(points.clone())
    }

    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    pub fn len(&self) -> usize {
        self.0.len()
    }

    pub fn get_point(&self, index: usize) -> PointD {
        self.0[index]
    }

    pub fn add_point(&mut self, point: PointD) {
        self.0.push(point)
    }

    pub fn translate(&self, dx: f64, dy: f64) -> Self {
        let new_points = self
            .0
            .iter()
            .map(|p| PointD {
                x: p.x + dx,
                y: p.y + dy,
            })
            .collect();
        Self(new_points)
    }

    pub fn scale(&self, sx: f64, sy: f64) -> Self {
        let mut _sx = sx;
        if _sx == 0. {
            _sx = 1.;
        }
        let mut _sy = sy;
        if _sy == 0. {
            _sy = 1.;
        }
        let new_points = self
            .0
            .iter()
            .map(|p| PointD {
                x: p.x * _sx,
                y: p.y * _sy,
            })
            .collect();
        Self(new_points)
    }
}
```

--------------------------------

### ClipperOffset Initialization and Methods

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/clipper_offset

This snippet demonstrates the initialization of the ClipperOffset struct with various parameters like miter limit, arc tolerance, and solution properties. It also includes methods for adding paths, executing the offset operation, clearing the offset, and getting/setting configuration parameters.

```Rust
use crate {
    clipper_clipper64_size,
    clipper_clipperoffset,
    clipper_clipperoffset_add_path64,
    clipper_clipperoffset_add_paths64,
    clipper_clipperoffset_clear,
    clipper_clipperoffset_execute,
    clipper_clipperoffset_get_arc_tolerance,
    clipper_clipperoffset_get_miter_limit,
    clipper_clipperoffset_get_preserve_collinear,
    clipper_clipperoffset_get_reverse_solution,
    clipper_clipperoffset_set_arc_tolerance,
    clipper_clipperoffset_set_miter_limit,
    clipper_clipperoffset_set_preserve_collinear,
    clipper_clipperoffset_set_reverse_solution,
    clipper_delete_clipperoffset,
    clipper_delete_path64,
    clipper_delete_paths64,
    malloc,
    ClipperClipperOffset,
    EndType,
    JoinType,
    Path64,
    Paths64,
} from "crate";

pub struct ClipperOffset {
    ptr: *mut ClipperClipperOffset,
}

impl ClipperOffset {
    pub fn new(
        miter_limit: f64,
        arc_tolerance: f64,
        preserve_collinear: bool,
        reverse_solution: bool,
    ) -> Self {
        let ptr = unsafe {
            let mem = malloc(clipper_clipperoffset_size());
            clipper_clipperoffset(
                mem,
                miter_limit,
                arc_tolerance,
                if preserve_collinear { 1 } else { 0 },
                if reverse_solution { 1 } else { 0 },
            )
        };
        Self { ptr: ptr }
    }

    pub fn add_path(&self, path: Path64, join_type: JoinType, end_type: EndType) {
        unsafe {
            let path_prt = path.get_clipper_path();
            clipper_clipperoffset_add_path64(self.ptr, path_prt, join_type.into(), end_type.into());
            clipper_delete_path64(path_prt);
        }
    }

    pub fn add_paths(&self, paths: Paths64, join_type: JoinType, end_type: EndType) {
        unsafe {
            let path_prt = paths.get_clipper_paths();
            clipper_clipperoffset_add_paths64(
                self.ptr,
                path_prt,
                join_type.into(),
                end_type.into(),
            );
            clipper_delete_paths64(path_prt);
        }
    }

    pub fn execute(&self, delta: f64) -> Paths64 {
        unsafe {
            let mem = malloc(clipper_clipper64_size());
            let paths_ptr = clipper_clipperoffset_execute(mem, self.ptr, delta);
            let paths = Paths64::from(paths_ptr);
            clipper_delete_paths64(paths_ptr);
            paths
        }
    }

    pub fn clear(&self) {
        unsafe { clipper_clipperoffset_clear(self.ptr) }
    }

    pub fn get_miter_limit(&self) -> f64 {
        unsafe { clipper_clipperoffset_get_miter_limit(self.ptr) }
    }

    pub fn set_miter_limit(&self, miter_limit: f64) {
        unsafe { clipper_clipperoffset_set_miter_limit(self.ptr, miter_limit) }
    }

    pub fn get_arc_tolerance(&self) -> f64 {
        unsafe { clipper_clipperoffset_get_arc_tolerance(self.ptr) }
    }

    pub fn set_arc_tolerance(&self, arc_tolerance: f64) {
        unsafe { clipper_clipperoffset_set_arc_tolerance(self.ptr, arc_tolerance) }
    }

    pub fn get_preserve_collinear(&self) -> bool {
        unsafe { clipper_clipperoffset_get_preserve_collinear(self.ptr) == 1 }
    }

    pub fn set_preserve_collinear(&self, preserve_collinear: bool) {
        unsafe {
            clipper_clipperoffset_set_preserve_collinear(
                self.ptr,
                if preserve_collinear { 1 } else { 0 },
            )
        }
    }

    pub fn get_reverse_solution(&self) -> bool {
        unsafe { clipper_clipperoffset_get_reverse_solution(self.ptr) == 1 }
    }

    pub fn set_reverse_solution(&self, reverse_solution: bool) {
        unsafe {
            clipper_clipperoffset_set_reverse_solution(
                self.ptr,
                if reverse_solution { 1 } else { 0 },
            )
        }
    }
}

impl Drop for ClipperOffset {
    fn drop(&mut self) {
        unsafe { clipper_delete_clipperoffset(self.ptr) }
    }
}
```

--------------------------------

### Rustdoc Keyboard Shortcuts

Source: https://docs.rs/clipper2-sys/0.5.0/help

This snippet details the keyboard shortcuts available in Rustdoc for efficient navigation and interaction with the documentation interface. It covers actions like showing help, focusing the search field, navigating search results, and expanding/collapsing sections.

```Rustdoc
`?`
    Show this help dialog 

`S` / `/` 
    Focus the search field 

`↑`
    Move up in search results 

`↓`
    Move down in search results 

`←` / `→` 
    Switch result tab (when results focused) 

`⏎`
    Go to active search result 

`+`
    Expand all sections 

`-`
    Collapse all sections 

`_`
    Collapse all sections, including impl blocks
```

--------------------------------

### Rustdoc Search Tricks

Source: https://docs.rs/clipper2-sys/0.5.0/help

This snippet outlines advanced search functionalities in Rustdoc, allowing users to refine their searches by item kind, type signature, exact name matching, slice/array handling, and path-based lookups.

```Rustdoc
Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given item kind.
Accepted kinds are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.
Search functions by type signature (e.g., `vec -> usize` or `-> vec` or `String, enum:Cow -> bool`)
You can look for items with an exact name by putting double quotes around your request: `"string"`
Look for functions that accept or return slices and arrays by writing square brackets (e.g., `-> [u8]` or `[] -> Option`)
Look for items inside another one by searching for a path: `vec::Vec`
```

--------------------------------

### Get ClipperPathD from PathD in Rust

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/double

Converts a Rust `PathD` struct into a raw `ClipperPathD` pointer for use with the Clipper2 C++ library. It manages memory allocation and conversion.

```Rust
impl PathD {
    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())
        }
    }
}
```

--------------------------------

### Simplify Path64 in Rust

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/int64

Implements path simplification for Path64 using the Clipper2 library. It takes an epsilon value and a flag for open paths, returning a new simplified Path64.

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

--------------------------------

### Create Point64 in Rust

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/int64

Defines a constructor for the Point64 struct, allowing the creation of new points with x and y integer coordinates.

```rust
impl Point64 {
    pub fn new(x: i64, y: i64) -> Self {
        Self { x: x, y: y }
    }
}
```

--------------------------------

### Get ClipperPathsD from PathsD in Rust

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/double

Converts a Rust `PathsD` struct into a raw `ClipperPathsD` pointer for use with the Clipper2 C++ library. It handles memory allocation and conversion of multiple paths.

```Rust
impl PathsD {
    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>>();
            let result = clipper_pathsd_of_paths(mem, paths.as_mut_ptr(), self.len());
            for ptr in paths {
                clipper_delete_pathd(ptr);
            }
            result
        }
    }
}
```

--------------------------------

### Implement PointD Constructor

Source: https://docs.rs/clipper2-sys/0.5.0/clipper2_sys/type

This snippet shows the implementation of a public associated function `new` for the PointD struct in Rust. It takes two f64 arguments, x and y, and returns a new instance of Self (PointD).

```Rust
pub fn new(x: f64, y: f64) -> Self
```

--------------------------------

### Rust Bindings Generation

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/clipper2

This Rust code snippet demonstrates how bindings are included based on feature flags. It conditionally includes generated bindings from either the OUT_DIR or the CARGO_MANIFEST_DIR, depending on whether the 'update-bindings' or 'generate-bindings' features are enabled.

```Rust
#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(dead_code)]
#![allow(clippy::unreadable_literal)]
#![allow(deref_nullptr)]

#[cfg(all(not(feature = "update-bindings"), feature = "generate-bindings"))]
include!(concat!(env!("OUT_DIR"), "/bindings.rs"));

#[cfg(any(feature = "update-bindings", not(feature = "generate-bindings")))]
include!(concat!(
    env!("CARGO_MANIFEST_DIR"),
    "/generated/bindings.rs"
));
```

--------------------------------

### Simplify Paths64 in Rust

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/int64

Implements simplification for a collection of paths (Paths64) using the Clipper2 library. It takes an epsilon value and a flag for open paths.

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

--------------------------------

### Rust Conversion: FillRule to ClipperFillRule

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/lib

Implements the `From` trait for converting the Rust `FillRule` enum to its `ClipperFillRule` equivalent, enabling seamless use with the Clipper library's fill rule mechanisms.

```Rust
impl From<FillRule> for ClipperFillRule {
    fn from(value: FillRule) -> Self {
        match value {
            FillRule::EvenOdd => ClipperFillRule_EVEN_ODD,
            FillRule::NonZero => ClipperFillRule_NON_ZERO,
            FillRule::Positive => ClipperFillRule_POSITIVE,
            FillRule::Negative => ClipperFillRule_NEGATIVE,
        }
    }
}
```

--------------------------------

### From<T> Trait Implementation for PolyTreeD

Source: https://docs.rs/clipper2-sys/0.5.0/clipper2_sys/struct

Implements the From<T> trait for PolyTreeD, allowing conversion from a type T into PolyTreeD. This is a common pattern for creating instances.

```Rust
fn from(t: T) -> T
```

--------------------------------

### Rust Memory Management Functions

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/lib

Provides unsafe functions for memory allocation and deallocation using the libc crate. These functions are essential for interacting with lower-level memory management routines.

```Rust
pub(crate) unsafe fn malloc(size: usize) -> *mut std::os::raw::c_void {
    libc::malloc(size)
}

pub(crate) unsafe fn free(p: *mut std::os::raw::c_void) {
    libc::free(p)
}
```

--------------------------------

### Simplify PathsD in Rust

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/double

Simplifies a `PathsD` collection using a specified epsilon value and a flag for open paths. It leverages the Clipper2 C++ library's simplification functionality.

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

--------------------------------

### Clipper64 Struct and Methods for Polygon Clipping

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/int64/clipper_64

This Rust code defines the Clipper64 struct, which wraps the C++ Clipper64 object. It provides methods for initializing, configuring (e.g., setting collinearity and reverse solution), adding subject and clip paths, and executing boolean operations (clipping) to produce Paths64 or PolyTree64 results. It also includes memory management for the underlying C++ objects.

```Rust
use crate {
    clipper_clipper64,
    clipper_clipper64_add_clip,
    clipper_clipper64_add_open_subject,
    clipper_clipper64_add_subject,
    clipper_clipper64_clear,
    clipper_clipper64_execute,
    clipper_clipper64_execute_tree_with_open,
    clipper_clipper64_get_preserve_collinear,
    clipper_clipper64_get_reverse_solution,
    clipper_clipper64_set_preserve_collinear,
    clipper_clipper64_set_reverse_solution,
    clipper_clipper64_size,
    clipper_delete_clipper64,
    clipper_delete_paths64,
    clipper_delete_polytree64,
    clipper_polytree64,
    clipper_polytree64_size,
    malloc,
    ClipType,
    ClipperClipper64,
    FillRule,
    Paths64,
    PolyTree64,
};

pub struct Clipper64 {
    ptr: *mut ClipperClipper64,
}

impl Clipper64 {
    pub fn new() -> Self {
        let ptr = unsafe {
            let mem = malloc(clipper_clipper64_size());
            clipper_clipper64(mem)
        };
        Self { ptr: ptr }
    }

    pub fn set_preserve_collinear(&self, value: bool) {
        unsafe { clipper_clipper64_set_preserve_collinear(self.ptr, if value { 1 } else { 0 }) }
    }

    pub fn get_preserve_collinear(&self) -> bool {
        unsafe { clipper_clipper64_get_preserve_collinear(self.ptr) == 1 }
    }

    pub fn set_reverse_solution(&self, value: bool) {
        unsafe { clipper_clipper64_set_reverse_solution(self.ptr, if value { 1 } else { 0 }) }
    }

    pub fn get_reverse_solution(&self) -> bool {
        unsafe { clipper_clipper64_get_reverse_solution(self.ptr) == 1 }
    }

    pub fn clear(&self) {
        unsafe { clipper_clipper64_clear(self.ptr) }
    }

    pub fn add_open_subject(&self, open_subject: Paths64) {
        unsafe {
            let path_prt = open_subject.get_clipper_paths();
            clipper_clipper64_add_open_subject(self.ptr, path_prt);
            clipper_delete_paths64(path_prt);
        }
    }

    pub fn add_subject(&self, subject: Paths64) {
        unsafe {
            let path_prt = subject.get_clipper_paths();
            clipper_clipper64_add_subject(self.ptr, path_prt);
            clipper_delete_paths64(path_prt);
        }
    }

    pub fn add_clip(&self, clip: Paths64) {
        unsafe {
            let path_prt = clip.get_clipper_paths();
            clipper_clipper64_add_clip(self.ptr, path_prt);
            clipper_delete_paths64(path_prt);
        }
    }

    pub fn boolean_operation(&self, clip_type: ClipType, fill_rule: FillRule) -> Paths64 {
        let closed_path = Paths64::new(&vec![]).get_clipper_paths();
        let open_path = Paths64::new(&vec![]).get_clipper_paths();
        unsafe {
            let is_success = clipper_clipper64_execute(
                self.ptr,
                clip_type.into(),
                fill_rule.into(),
                closed_path,
                open_path,
            );

            let path = Paths64::from(closed_path);
            clipper_delete_paths64(closed_path);
            clipper_delete_paths64(open_path);
            path
        }
    }

    pub fn boolean_operation_tree(&self, clip_type: ClipType, fill_rule: FillRule) -> PolyTree64 {
        let tree_ptr = unsafe {
            let mem = malloc(clipper_polytree64_size());
            clipper_polytree64(mem, std::ptr::null_mut())
        };
        let open_path = Paths64::new(&vec![]).get_clipper_paths();
        unsafe {
            let is_success = clipper_clipper64_execute_tree_with_open(
                self.ptr,
                clip_type.into(),
                fill_rule.into(),
                tree_ptr,
                open_path,
            );
            clipper_delete_paths64(open_path);
            let tree = PolyTree64::from(tree_ptr);
            clipper_delete_polytree64(tree_ptr);
            tree
        }
    }
}

impl Drop for Clipper64 {
    fn drop(&mut self) {
        unsafe { clipper_delete_clipper64(self.ptr) }
    }
}
```

--------------------------------

### Any Trait Implementation for PolyTreeD

Source: https://docs.rs/clipper2-sys/0.5.0/clipper2_sys/struct

Implements the Any trait for PolyTreeD, enabling runtime type identification. This is a standard Rust feature for trait objects.

```Rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Rust: Minkowski Sum for Paths64

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/int64

Calculates the Minkowski sum for a collection of paths (Paths64) with a given pattern Path64. It utilizes the Clipper2 C++ API, handling memory allocation and deallocation.

```rust
unsafe {
            let pattern_ptr = pattern.get_clipper_path();
            let paths_ptr = self.get_clipper_paths();

            let mem = malloc(clipper_paths64_size());
            let result_prt = clipper_paths64_minkowski_sum(
                mem,
                pattern_ptr,
                paths_ptr,
                if is_closed { 1 } else { 0 },
                fillrule.into(),
            );
            let result = Paths64::from(result_prt);
            clipper_delete_paths64(result_prt);
            clipper_delete_path64(pattern_ptr);
            clipper_delete_paths64(paths_ptr);
            result
        }
```

--------------------------------

### Rust: Minkowski Sum for Path64

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/int64

Calculates the Minkowski sum of a Path64 with a given pattern Path64. It handles the conversion of Rust types to C++ pointers, calls the appropriate Clipper2 function, and manages memory cleanup.

```rust
unsafe {
            let pattern_ptr = pattern.get_clipper_path();
            let path_ptr = self.get_clipper_path();

            let mem = malloc(clipper_paths64_size());
            let result_prt = clipper_path64_minkowski_sum(
                mem,
                pattern_ptr,
                path_ptr,
                if is_closed { 1 } else { 0 },
            );
            let result = Paths64::from(result_prt);
            clipper_delete_paths64(result_prt);
            clipper_delete_path64(pattern_ptr);
            clipper_delete_path64(path_ptr);
            result
        }
```

--------------------------------

### Simplify PathD in Rust

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/double

Simplifies a `PathD` using a specified epsilon value and a flag indicating if the path is open. It calls the underlying Clipper2 C++ function and handles memory management.

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

--------------------------------

### TryInto<U> Trait Implementation for PolyTreeD

Source: https://docs.rs/clipper2-sys/0.5.0/clipper2_sys/struct

Implements the TryInto<U> trait for PolyTreeD, enabling fallible conversions into type U. This complements the TryFrom<T> trait.

```Rust
type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### TryFrom<U> Trait Implementation for PolyTreeD

Source: https://docs.rs/clipper2-sys/0.5.0/clipper2_sys/struct

Implements the TryFrom<U> trait for PolyTreeD, allowing fallible conversions from type U. This is used when conversions might fail.

```Rust
type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### Into<U> Trait Implementation for PolyTreeD

Source: https://docs.rs/clipper2-sys/0.5.0/clipper2_sys/struct

Implements the Into<U> trait for PolyTreeD, enabling conversion into another type U. This leverages the From<T> trait for conversions.

```Rust
fn into(self) -> U
```

--------------------------------

### Rust: Minkowski Difference for Paths64

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/int64

Computes the Minkowski difference for a Paths64 object with a pattern Path64. This involves calling the Clipper2 C++ library via FFI, managing memory, and ensuring proper pointer handling.

```rust
unsafe {
            let pattern_ptr = pattern.get_clipper_path();
            let paths_ptr = self.get_clipper_paths();

            let mem = malloc(clipper_paths64_size());
            let result_prt = clipper_paths64_minkowski_diff(
                mem,
                pattern_ptr,
                paths_ptr,
                if is_closed { 1 } else { 0 },
                fillrule.into(),
            );
            let result = Paths64::from(result_prt);
            clipper_delete_paths64(result_prt);
            clipper_delete_path64(pattern_ptr);
            clipper_delete_paths64(paths_ptr);
            result
        }
```

--------------------------------

### Rust: PolyTree64 Struct and Methods

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/int64/poly_tree_64

This Rust code defines the `PolyTree64` struct, which represents a polygon tree structure from the Clipper library. It includes methods for converting from a C pointer, accessing child nodes, checking if a polygon is a hole, and retrieving the polygon's paths. The implementation relies on several external functions from the `clipper2-sys` crate.

```Rust
use crate {
    clipper_delete_path64,
    clipper_path64_size,
    clipper_polytree64_count,
    clipper_polytree64_get_child,
    clipper_polytree64_is_hole,
    clipper_polytree64_polygon,
    malloc,
    ClipperPolyTree64,
    Path64,
    Paths64,
};

#[derive(Debug)]
pub struct PolyTree64 {
    pub(crate) childs: Vec<Self>,
    pub(crate) is_hole: bool,
    pub(crate) polygon: Path64,
}

impl PolyTree64 {
    pub(crate) fn from(ptr: *mut ClipperPolyTree64) -> Self {
        let is_hole: bool;
        let polygon: Path64;
        let childs: Vec<Self>;
        unsafe {
            is_hole = clipper_polytree64_is_hole(ptr) == 1;
            let mem = malloc(clipper_path64_size());
            let polygon_prt = clipper_polytree64_polygon(mem, ptr);
            polygon = Path64::from(polygon_prt);
            clipper_delete_path64(polygon_prt);
            let count = clipper_polytree64_count(ptr);
            childs = (0..count)
                .map(|i| {
                    let tree_ptr = clipper_polytree64_get_child(ptr, i);
                    Self::from(tree_ptr as *mut ClipperPolyTree64)
                })
                .collect();
        }
        Self {
            childs: childs,
            is_hole: is_hole,
            polygon: polygon,
        }
    }
}

impl PolyTree64 {
    pub fn get_childs(&mut self) -> &mut Vec<Self> {
        &mut self.childs
    }

    pub fn is_hole(&self) -> bool {
        self.is_hole
    }

    pub fn get_hole_paths(&self) -> Paths64 {
        let mut paths = Paths64::new(&vec![]);
        for child in &self.childs {
            if child.is_hole {
                paths.add_path(child.get_polygon());
            }
        }
        paths
    }

    pub fn get_polygon(&self) -> Path64 {
        self.polygon.clone()
    }
}
```

--------------------------------

### Rust: Minkowski Difference for Path64

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/int64

Computes the Minkowski difference between a Path64 and a pattern Path64. This function interfaces with the Clipper2 C++ library, managing memory and pointer conversions.

```rust
unsafe {
            let pattern_ptr = pattern.get_clipper_path();
            let path_ptr = self.get_clipper_path();

            let mem = malloc(clipper_paths64_size());
            let result_prt = clipper_path64_minkowski_diff(
                mem,
                pattern_ptr,
                path_ptr,
                if is_closed { 1 } else { 0 },
            );
            let result = Paths64::from(result_prt);
            clipper_delete_paths64(result_prt);
            clipper_delete_path64(pattern_ptr);
            clipper_delete_path64(path_ptr);
            result
        }
```

--------------------------------

### Debug Trait Implementation for PolyTreeD

Source: https://docs.rs/clipper2-sys/0.5.0/clipper2_sys/struct

Implements the Debug trait for PolyTreeD, allowing it to be formatted for debugging purposes. This is crucial for inspecting the state of PolyTreeD instances.

```Rust
fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

--------------------------------

### PolyTreeD scale Method

Source: https://docs.rs/clipper2-sys/0.5.0/clipper2_sys/struct

Returns the scaling factor applied to the PolyTreeD. This method is useful for understanding transformations or coordinate system scaling.

```Rust
pub fn scale(&self) -> f64
```

--------------------------------

### Rust Conversion: ClipType to ClipperClipType

Source: https://docs.rs/clipper2-sys/0.5.0/src/clipper2_sys/lib

Implements the `From` trait to convert the Rust `ClipType` enum to its corresponding `ClipperClipType` representation, facilitating interaction with the underlying C library.

```Rust
impl From<ClipType> for ClipperClipType {
    fn from(value: ClipType) -> Self {
        match value {
            ClipType::None => ClipperClipType_NONE,
            ClipType::Intersection => ClipperClipType_INTERSECTION,
            ClipType::Union => ClipperClipType_UNION,
            ClipType::Difference => ClipperClipType_DIFFERENCE,
            ClipType::Xor => ClipperClipType_XOR,
        }
    }
}
```
Tokens:
Raw