chijin 0.3.7

Minimal Rust bindings for OpenCASCADE (OCC 7.9)
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

use crate::edge::Edge;
use crate::face::Face;
use crate::ffi;
use glam::DVec3;

/// Iterator over faces of a shape.
///
/// Wraps `TopExp_Explorer` with `TopAbs_FACE`.
pub struct FaceIterator {
    explorer: cxx::UniquePtr<ffi::TopExp_Explorer>,
}

impl FaceIterator {
    pub(crate) fn new(explorer: cxx::UniquePtr<ffi::TopExp_Explorer>) -> Self {
        FaceIterator { explorer }
    }
}

impl Iterator for FaceIterator {
    type Item = Face;

    fn next(&mut self) -> Option<Face> {
        if !ffi::explorer_more(&self.explorer) {
            return None;
        }
        let face = ffi::explorer_current_face(&self.explorer);
        ffi::explorer_next(self.explorer.pin_mut());
        Some(Face::new(face))
    }
}

/// Iterator over edges of a shape.
///
/// Wraps `TopExp_Explorer` with `TopAbs_EDGE`.
pub struct EdgeIterator {
    explorer: cxx::UniquePtr<ffi::TopExp_Explorer>,
}

impl EdgeIterator {
    pub(crate) fn new(explorer: cxx::UniquePtr<ffi::TopExp_Explorer>) -> Self {
        EdgeIterator { explorer }
    }
}

impl Iterator for EdgeIterator {
    type Item = Edge;

    fn next(&mut self) -> Option<Edge> {
        if !ffi::explorer_more(&self.explorer) {
            return None;
        }
        let edge = ffi::explorer_current_edge(&self.explorer);
        ffi::explorer_next(self.explorer.pin_mut());
        Some(Edge::new(edge))
    }
}

/// Iterator over approximation points of an edge.
///
/// Each item is a `DVec3` point on the polyline approximation.
pub struct ApproximationSegmentIterator {
    coords: Vec<f64>,
    count: usize,
    index: usize,
}

impl ApproximationSegmentIterator {
    pub(crate) fn new(approx: ffi::ApproxPoints) -> Self {
        ApproximationSegmentIterator {
            coords: approx.coords,
            count: approx.count as usize,
            index: 0,
        }
    }
}

impl Iterator for ApproximationSegmentIterator {
    type Item = DVec3;

    fn next(&mut self) -> Option<DVec3> {
        if self.index >= self.count {
            return None;
        }
        let base = self.index * 3;
        let x = self.coords[base];
        let y = self.coords[base + 1];
        let z = self.coords[base + 2];
        self.index += 1;
        Some(DVec3::new(x, y, z))
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let remaining = self.count - self.index;
        (remaining, Some(remaining))
    }
}

impl ExactSizeIterator for ApproximationSegmentIterator {}