working on scope simplifications

Author: recursivepaws

src/bones/polyhedron/cycles.rs

@@ -27,6 +27,44 @@ impl Cycles {
     pub fn into_iter(&self) -> std::vec::IntoIter<Cycle> {
         self.cycles.clone().into_iter()
     }
+    /// Returns the
+    pub fn sorted_connections(&self, v: VertexId) -> Vec<VertexId> {
+        log::info!("cycles: {:?}", self.cycles);
+        log::info!("hunting for {v}");
+        // We only care about cycles that contain the vertex
+        let mut relevant = self
+            .iter()
+            .filter_map(move |cycle| {
+                if let Some(p) = cycle.iter().position(|&x| x == v) {
+                    log::info!("finding {p}");
+                    Some([cycle[p + cycle.len() - 1], cycle[p + 1]])
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<[VertexId; 2]>>();
+        //.collect::<HashMap<VertexId, VertexId>>();
+
+        log::info!("RELEVANT: {relevant:?}");
+        let mut sorted_connections = vec![relevant[0][0]];
+        loop {
+            let previous = sorted_connections.last().unwrap();
+            match relevant
+                .iter()
+                .position(|[v, u]| v == previous || u == previous)
+            {
+                Some(i) => {
+                    let [v, u] = relevant.remove(i);
+                    let next = if v == *previous { u } else { v };
+                    sorted_connections.push(next);
+                }
+                None => {
+                    break;
+                }
+            }
+        }
+        sorted_connections[1..].to_vec()
+    }
 }
 
 impl Index<usize> for Cycle {

src/bones/polyhedron/polyhedron/conway.rs

@@ -1,14 +1,22 @@
-use crate::bones::Polyhedron;
+use crate::bones::{Polyhedron, VertexId};
+
+use super::Shape;
 
 impl Polyhedron {
-    pub fn truncate(&mut self) {
-        for v in self.shape.distance.vertices() {
-            self.render.extend(
-                self.shape.distance.connections(v).len() - 1,
-                self.render.positions[v],
-            );
+    pub fn truncate(&mut self) -> Vec<[VertexId; 2]> {
+        let Polyhedron { shape, render, .. } = self;
+        let Shape {
+            distance, cycles, ..
+        } = shape;
+
+        let mut new_edges = Vec::default();
+        for v in distance.vertices() {
+            let connections = cycles.sorted_connections(v);
+            render.extend(connections.len() - 1, render.positions[v]);
+            new_edges.extend(distance.split_vertex(v, connections));
+            *cycles = distance.simple_cycles();
         }
-        self.shape.truncate(None);
         self.shape.recompute();
+        new_edges
     }
 }

src/bones/polyhedron/shape/conway.rs

@@ -3,48 +3,8 @@ use std::collections::{HashMap, HashSet};
 use crate::bones::{Cycle, Shape, VertexId};
 
 impl Shape {
-    /// Returns the
-    pub fn sorted_connections(&self, v: VertexId) -> Vec<VertexId> {
-        log::info!("cycles: {:?}", self.cycles);
-        log::info!("hunting for {v}");
-        // We only care about cycles that contain the vertex
-        let mut relevant = self
-            .cycles
-            .iter()
-            .filter_map(move |cycle| {
-                if let Some(p) = cycle.iter().position(|&x| x == v) {
-                    log::info!("finding {p}");
-                    Some([cycle[p + cycle.len() - 1], cycle[p + 1]])
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<[VertexId; 2]>>();
-        //.collect::<HashMap<VertexId, VertexId>>();
-
-        log::info!("RELEVANT: {relevant:?}");
-        let mut sorted_connections = vec![relevant[0][0]];
-        loop {
-            let previous = sorted_connections.last().unwrap();
-            match relevant
-                .iter()
-                .position(|[v, u]| v == previous || u == previous)
-            {
-                Some(i) => {
-                    let [v, u] = relevant.remove(i);
-                    let next = if v == *previous { u } else { v };
-                    sorted_connections.push(next);
-                }
-                None => {
-                    break;
-                }
-            }
-        }
-        sorted_connections[1..].to_vec()
-    }
-
     pub fn split_vertex(&mut self, v: VertexId) -> Vec<[usize; 2]> {
-        let sorted_connections = self.sorted_connections(v);
+        let sorted_connections = self.cycles.sorted_connections(v);
         println!("connections_sorted : {sorted_connections:?}");
         //
         // let connections = self.distance.connections(v);