Make inner and outer circle obtainable from `Shape`

src/main.rs

@@ -216,7 +216,7 @@ fn main() {
             },
         })
         .unwrap();
-    let barrier1_dot2 = layout
+    /*let barrier1_dot2 = layout
         .add_dot(DotWeight {
             net: 10,
             circle: Circle {
@@ -225,7 +225,7 @@ fn main() {
             },
         })
         .unwrap();
-    let _ = layout.add_seg(barrier1_dot1, barrier1_dot2, 16.0);
+    let _ = layout.add_seg(barrier1_dot1, barrier1_dot2, 16.0);*/
 
     let barrier2_dot1 = layout
         .add_dot(DotWeight {
@@ -381,9 +381,8 @@ fn render_times(
                         );
                     }
                     Shape::Bend(bend) => {
-                        let delta1 = bend.from - bend.center;
+                        let delta1 = bend.from - bend.c.pos;
-                        let delta2 = bend.to - bend.center;
+                        let delta2 = bend.to - bend.c.pos;
-                        let r = bend.from.euclidean_distance(&bend.center);
 
                         let mut angle1 = delta1.y().atan2(delta1.x());
                         let mut angle2 = delta2.y().atan2(delta2.x());
@@ -392,10 +391,10 @@ fn render_times(
                             let _ = canvas.arc(
                                 //around_circle.pos.x() as i16,
                                 //around_circle.pos.y() as i16,
-                                bend.center.x() as i16,
+                                bend.c.pos.x() as i16,
-                                bend.center.y() as i16,
+                                bend.c.pos.y() as i16,
                                 //(shape.around_weight.unwrap().circle.r + 10.0 + (d as f64)) as i16,
-                                (r + (d as f64)) as i16,
+                                (bend.circle().r + (d as f64)) as i16,
                                 angle1.to_degrees() as i16,
                                 angle2.to_degrees() as i16,
                                 Color::RGB(200, 52, 52),

src/mesh.rs

@@ -294,7 +294,6 @@ impl Mesh {
         for edge in triangulation.directed_edges() {
             let from = edge.from().as_ref().index;
             let to = edge.to().as_ref().index;
-            dbg!(from, to);
             self.graph.add_edge(from, to, Label::Peer);
         }
     }

src/primitive.rs

@@ -7,7 +7,7 @@ use crate::graph::{
     BendIndex, BendWeight, DotIndex, DotWeight, Index, Label, Path, SegIndex, SegWeight, Tag,
     TaggedIndex, TaggedWeight,
 };
-use crate::math;
+use crate::math::{self, Circle};
 use crate::shape::{BendShape, DotShape, SegShape, Shape};
 
 #[derive(Debug)]
@@ -34,10 +34,14 @@ impl<'a, Weight> Primitive<'a, Weight> {
             }
             TaggedWeight::Bend(bend) => {
                 let ends = self.ends();
+
                 let mut bend_shape = BendShape {
                     from: self.primitive(ends[0]).weight().circle.pos,
                     to: self.primitive(ends[1]).weight().circle.pos,
-                    center: self.primitive(self.core().unwrap()).weight().circle.pos,
+                    c: Circle {
+                        pos: self.primitive(self.core().unwrap()).weight().circle.pos,
+                        r: self.inner_radius(),
+                    },
                     width: self.primitive(ends[0]).weight().circle.r * 2.0,
                 };
 
@@ -49,6 +53,27 @@ impl<'a, Weight> Primitive<'a, Weight> {
         }
     }
 
+    fn inner_radius(&self) -> f64 {
+        let mut r = 0.0;
+        let mut layer = BendIndex::new(self.index.index);
+
+        while let Some(inner) = self.primitive(layer).inner() {
+            r += self.primitive(inner).shape().width();
+            layer = inner;
+        }
+
+        let core_circle = self
+            .primitive(
+                self.primitive(BendIndex::new(self.index.index))
+                    .core()
+                    .unwrap(),
+            )
+            .weight()
+            .circle;
+
+        core_circle.r + r + 5.0
+    }
+
     pub fn neighbors(&self) -> impl Iterator<Item = TaggedIndex> + '_ {
         self.graph
             .neighbors_undirected(self.index.index)

src/shape.rs

@@ -37,30 +37,34 @@ impl SegShape {
 pub struct BendShape {
     pub from: Point,
     pub to: Point,
-    pub center: Point,
+    pub c: Circle,
     pub width: f64,
 }
 
 impl BendShape {
-    fn inner_circle(&self) -> Circle {
+    pub fn inner_circle(&self) -> Circle {
+        self.c
+    }
+
+    pub fn circle(&self) -> Circle {
         Circle {
-            pos: self.center,
+            pos: self.c.pos,
-            r: self.center.euclidean_distance(&self.from) - self.width / 2.0,
+            r: self.c.r + self.width / 2.0,
         }
     }
 
-    fn outer_circle(&self) -> Circle {
+    pub fn outer_circle(&self) -> Circle {
         Circle {
-            pos: self.center,
+            pos: self.c.pos,
-            r: self.center.euclidean_distance(&self.from) + self.width / 2.0,
+            r: self.c.r + self.width,
         }
     }
 
     fn between_ends(&self, point: Point) -> bool {
         math::between_vectors(
-            point - self.center,
+            point - self.c.pos,
-            self.from - self.center,
+            self.from - self.c.pos,
-            self.to - self.center,
+            self.to - self.c.pos,
         )
     }
 }
@@ -87,10 +91,8 @@ impl Shape {
             Shape::Dot(dot) => dot.c.pos,
             Shape::Seg(seg) => (seg.from + seg.to) / 2.0,
             Shape::Bend(bend) => {
-                let sum = (bend.from - bend.center) + (bend.to - bend.center);
+                let sum = (bend.from - bend.c.pos) + (bend.to - bend.c.pos);
-                let r = bend.from.euclidean_distance(&bend.center);
+                bend.c.pos + (sum / sum.euclidean_distance(&point! {x: 0.0, y: 0.0})) * bend.c.r
-
-                bend.center + (sum / sum.euclidean_distance(&point! {x: 0.0, y: 0.0})) * r
             }
         }
     }
@@ -211,10 +213,10 @@ impl Shape {
                 AABB::<[f64; 2]>::from_points(points.iter())
             }
             Shape::Bend(bend) => {
-                let halfwidth = bend.center.euclidean_distance(&bend.from).ceil() + bend.width;
+                let halfwidth = bend.c.r + bend.width;
                 AABB::from_corners(
-                    [bend.center.x() - halfwidth, bend.center.y() - halfwidth],
+                    [bend.c.pos.x() - halfwidth, bend.c.pos.y() - halfwidth],
-                    [bend.center.x() + halfwidth, bend.center.y() + halfwidth],
+                    [bend.c.pos.x() + halfwidth, bend.c.pos.y() + halfwidth],
                 )
             }
         }