cadrum 0.4.5

Rust CAD library powered by OpenCASCADE (OCCT 8.0.0-rc5)
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 super::edge::Edge;
use super::face::Face;
use super::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());
		// TopExp_Explorer は探索中の有効な edge のみを返すので null は想定外。
		Some(
			Edge::try_from_ffi(edge, "EdgeIterator: explorer_current_edge returned null".into())
				.expect("EdgeIterator: unexpected null from explorer_current_edge (this is a bug)"),
		)
	}
}

/// 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 {}