feat: testing some stuff

bampy/src/slicer/slice_rings.rs

@@ -3,68 +3,72 @@ use nalgebra::Vector3;
 
 use crate::console_log;
 
-use super::{base_slices::BaseSlice, FloatValue};
+use super::{
+    base_slices::{create_base_slices, BaseSlice},
+    mesh::Mesh,
+    FloatValue, SlicerOptions,
+};
 
 #[derive(Debug)]
 pub struct SliceRing {
-    pub z: FloatValue,
+    pub d: FloatValue,
     /// The points of the ring, in clockwise order.
     pub points: Vec<Vector3<FloatValue>>,
+    pub closed: bool,
 }
 
-pub fn find_slice_rings(mut slice: BaseSlice, layer_index: &mut u32) -> Vec<SliceRing> {
+pub fn slice_rings<'a>(
+    axis: usize,
+    options: &'a SlicerOptions,
+    slicable: &'a Mesh,
+) -> impl Iterator<Item = Vec<SliceRing>> + 'a {
+    let mut layer_index = 0;
+    create_base_slices(axis, options, slicable)
+        .map(move |slice| find_slice_rings(axis, slice, &mut layer_index))
+}
+
+pub fn find_slice_rings(
+    axis: usize,
+    mut slice: BaseSlice,
+    layer_index: &mut u32,
+) -> Vec<SliceRing> {
+    let axis_a = (axis + 1) % 3;
+    let axis_b = (axis + 2) % 3;
     let mut rings = vec![];
     while let Some(line) = slice.lines.pop() {
         if relative_eq!(line.start, line.end) {
             continue;
         }
-        let mut ring = SliceRing {
-            z: slice.z,
-            points: vec![line.start, line.end],
-        };
-        let mut right_start = ring.points[0];
-        let mut right = ring.points[1];
-        let mut sum_of_edges = (right.x - right_start.x) * (right.y + right_start.y);
-
+        let mut right = vec![line.end];
+        let mut left = vec![line.start];
         let mut previous_len = usize::MAX;
-        let mut done = false;
+        let mut closed = false;
 
-        while !done {
+        while !closed {
             if previous_len == slice.lines.len() {
-                console_log!(
-                    "Error: Could not close ring {}, d = {}, {} items left.",
-                    layer_index,
-                    ring.points[0].metric_distance(&right),
-                    slice.lines.len()
-                );
                 break;
             }
             previous_len = slice.lines.len();
 
             slice.lines.retain_mut(|line| {
-                if done {
+                if closed {
                     return true;
                 }
 
-                macro_rules! add {
-                    ( $point:expr ) => {
-                        if !relative_eq!($point, right_start) {
-                            right_start = right;
-                            right = $point;
-                            ring.points.push(right);
-                            sum_of_edges = (right.x - right_start.x) * (right.y + right_start.y);
-                            done = relative_eq!(ring.points[0], right);
-                        }
-                    };
-                }
+                let test = |side: &mut Vec<Vector3<FloatValue>>| {
+                    let last = side.last().unwrap();
+                    let s = relative_eq!(line.start, last);
+                    let e = relative_eq!(line.end, last);
+                    if s && !e {
+                        side.push(line.end);
+                    } else if !s && e {
+                        side.push(line.start);
+                    }
+                    s || e
+                };
 
-                let s = relative_eq!(line.start, right);
-                let e = relative_eq!(line.end, right);
-                if s && !e {
-                    add!(line.end);
-                    false
-                } else if e && !s {
-                    add!(line.start);
+                if test(&mut left) || test(&mut right) {
+                    closed = relative_eq!(left.last().unwrap(), right.last().unwrap());
                     false
                 } else {
                     true
@@ -72,10 +76,21 @@ pub fn find_slice_rings(mut slice: BaseSlice, layer_index: &mut u32) -> Vec<Slic
             })
         }
 
-        // The end point is duplicate, so not part of the winding order calculation.
-        if sum_of_edges < 0.0 {
+        left.reverse();
+        left.extend(right);
+        let mut ring = SliceRing {
+            d: slice.d,
+            closed,
+            points: left,
+        };
+
+        if ring.points.windows(2).fold(0.0, |acc, curr| {
+            acc + (curr[1][axis_a] - curr[0][axis_a]) * (curr[1][axis_b] + curr[0][axis_b])
+        }) < 0.0
+        {
             ring.points.reverse();
         }
+
         rings.push(ring);
         *layer_index += 1;
     }