fixes

bampy/src/slicer/base_slices.rs

@@ -1,13 +1,10 @@
-use bvh::bvh::BvhNode;
-
-use crate::console_log;
-
 use super::{
     line::Line3,
     mesh::Mesh,
     slice_rings::{find_slice_rings, SliceRing},
     SlicerOptions,
 };
+use bvh::bvh::BvhNode;
 
 #[derive(Debug)]
 pub struct BaseSlice {
@@ -20,9 +17,9 @@ pub struct BaseSlice {
 pub fn create_slices(options: &SlicerOptions, slicable: &Mesh<f64>) -> Vec<SliceRing> {
     let layer_count = f64::floor(slicable.aabb.max.z / options.layer_height) as usize;
     let mut rings = vec![];
+    let mut layer_index = 0;
 
     for i in 0..layer_count {
-        console_log!("Layer {}", i);
         let layer = i as f64 * options.layer_height;
         let mut base_slice = BaseSlice {
             z: layer,
@@ -62,7 +59,7 @@ pub fn create_slices(options: &SlicerOptions, slicable: &Mesh<f64>) -> Vec<Slice
             }
         }
 
-        rings.append(&mut find_slice_rings(base_slice));
+        rings.append(&mut find_slice_rings(base_slice, &mut layer_index));
     }
 
     rings

bampy/src/slicer/slice_rings.rs

@@ -1,4 +1,4 @@
-use approx::{relative_eq, relative_ne};
+use approx::relative_eq;
 use nalgebra::Vector3;
 
 use crate::console_log;
@@ -8,10 +8,11 @@ use super::base_slices::BaseSlice;
 #[derive(Debug)]
 pub struct SliceRing {
     pub z: f64,
+    /// The points of the ring, in clockwise order.
     pub points: Vec<Vector3<f64>>,
 }
 
-pub fn find_slice_rings(mut slice: BaseSlice) -> Vec<SliceRing> {
+pub fn find_slice_rings(mut slice: BaseSlice, layer_index: &mut u32) -> Vec<SliceRing> {
     let mut rings = vec![];
     while let Some(line) = slice.lines.pop() {
         if relative_eq!(line.start, line.end) {
@@ -23,13 +24,16 @@ pub fn find_slice_rings(mut slice: BaseSlice) -> Vec<SliceRing> {
         };
         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 previous_len = usize::MAX;
-        while relative_ne!(ring.points[0], right) {
+        let mut done = false;
+
+        while !done {
             if previous_len == slice.lines.len() {
                 console_log!(
-                    "Error: Could not find a ring for slice at z = {}, d = {}, {} items left.",
-                    slice.z,
+                    "Error: Could not close ring {}, d = {}, {} items left.",
+                    layer_index,
                     ring.points[0].metric_distance(&right),
                     slice.lines.len()
                 );
@@ -38,24 +42,42 @@ pub fn find_slice_rings(mut slice: BaseSlice) -> Vec<SliceRing> {
             previous_len = slice.lines.len();
 
             slice.lines.retain_mut(|line| {
+                if done {
+                    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 s = relative_eq!(line.start, right);
                 let e = relative_eq!(line.end, right);
-                if s && !e && !relative_eq!(line.end, right_start) {
-                    ring.points.push(line.end);
-                    right_start = right;
-                    right = line.end;
+                if s && !e {
+                    add!(line.end);
                     false
-                } else if e && !s && !relative_eq!(line.start, right_start) {
-                    ring.points.push(line.start);
-                    right_start = right;
-                    right = line.start;
+                } else if e && !s {
+                    add!(line.start);
                     false
                 } else {
                     true
                 }
             })
         }
-        rings.push(ring)
+
+        // The end point is duplicate, so not part of the winding order calculation.
+        if sum_of_edges < 0.0 {
+            ring.points.reverse();
+        }
+        rings.push(ring);
+        *layer_index += 1;
     }
 
     rings