layout: terminology improvements

- "connected" is renamed to "joined" (more local term),
- primitives whose clearance area neighbors another's are now called
  "abutters",
- primitives whose geometries depend on a bend are now called
  "posteriors" of said bend.

src/layout/collect.rs

@@ -19,27 +19,12 @@ impl<'a, R: RulesTrait> Collect<'a, R> {
         Self { layout }
     }
 
-    pub fn inner_bow_and_outer_bow(&self, bend: LooseBendIndex) -> Vec<GeometryIndex> {
+    pub fn bend_abutters_and_posteriors(&self, bend: LooseBendIndex) -> Vec<GeometryIndex> {
-        let bend_primitive = self.layout.primitive(bend);
+        // Bend's posteriors are the outer abutters and afterouter bows.
+        // Bend's afterouter bows are the bows of bend's afterouters.
+        // Bend's afterouters are the bends outer to the outer bend of said bend.
         let mut v = vec![];
-
-        if let Some(inner) = bend_primitive.inner() {
-            v.append(&mut self.bow(inner.into()));
-        } else {
-            let core = bend_primitive.core();
-            v.push(core.into());
-        }
-
-        if let Some(outer) = bend_primitive.outer() {
-            v.append(&mut self.bow(outer.into()));
-        }
-
-        v
-    }
-
-    pub fn inner_bow_and_outer_bows(&self, bend: LooseBendIndex) -> Vec<GeometryIndex> {
         let bend_primitive = self.layout.primitive(bend);
-        let mut v = vec![];
 
         if let Some(inner) = bend_primitive.inner() {
             v.append(&mut self.bow(inner.into()));
@@ -58,16 +43,32 @@ impl<'a, R: RulesTrait> Collect<'a, R> {
         v
     }
 
-    pub fn segbend_inner_and_outer_bibows(
+    pub fn bend_abutters(&self, bend: LooseBendIndex) -> Vec<GeometryIndex> {
+        let mut v = vec![];
+        let bend_primitive = self.layout.primitive(bend);
+
+        if let Some(inner) = bend_primitive.inner() {
+            v.append(&mut self.bow(inner.into()));
+        } else {
+            let core = bend_primitive.core();
+            v.push(core.into());
+        }
+
+        if let Some(outer) = bend_primitive.outer() {
+            v.append(&mut self.bow(outer.into()));
+        }
+
+        v
+    }
+
+    pub fn potential_segbend_abutters(
         &self,
         from: DotIndex,
         around: WraparoundableIndex,
     ) -> Vec<GeometryIndex> {
         let mut v = match from {
             DotIndex::Fixed(..) => vec![],
-            DotIndex::Loose(dot) => {
+            DotIndex::Loose(dot) => self.bend_abutters(self.layout.primitive(dot).bend().into()),
-                self.inner_bow_and_outer_bow(self.layout.primitive(dot).bend().into())
-            }
         };
         v.append(&mut self.this_and_wraparound_bow(around));
         v

src/layout/geometry/geometry.rs

@@ -46,7 +46,7 @@ pub trait SetOffset {
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum GeometryLabel {
-    Connection,
+    Joined,
     Outer,
     Core,
 }
@@ -114,13 +114,10 @@ impl<
     ) -> GenericIndex<W> {
         let seg = GenericIndex::<W>::new(self.graph.add_node(weight.into()));
 
-        self.graph.update_edge(
-            from.node_index(),
-            seg.node_index(),
-            GeometryLabel::Connection,
-        );
         self.graph
-            .update_edge(seg.node_index(), to.node_index(), GeometryLabel::Connection);
+            .update_edge(from.node_index(), seg.node_index(), GeometryLabel::Joined);
+        self.graph
+            .update_edge(seg.node_index(), to.node_index(), GeometryLabel::Joined);
 
         seg
     }
@@ -134,16 +131,10 @@ impl<
     ) -> GenericIndex<W> {
         let bend = GenericIndex::<W>::new(self.graph.add_node(weight.into()));
 
-        self.graph.update_edge(
+        self.graph
-            from.node_index(),
+            .update_edge(from.node_index(), bend.node_index(), GeometryLabel::Joined);
-            bend.node_index(),
+        self.graph
-            GeometryLabel::Connection,
+            .update_edge(bend.node_index(), to.node_index(), GeometryLabel::Joined);
-        );
-        self.graph.update_edge(
-            bend.node_index(),
-            to.node_index(),
-            GeometryLabel::Connection,
-        );
         self.graph
             .update_edge(bend.node_index(), core.node_index(), GeometryLabel::Core);
 
@@ -381,7 +372,7 @@ impl<
             .next()
     }
 
-    pub fn connecteds(&self, node: GI) -> impl Iterator<Item = GI> + '_ {
+    pub fn joineds(&self, node: GI) -> impl Iterator<Item = GI> + '_ {
         self.graph
             .neighbors_undirected(node.node_index())
             .filter(move |ni| {
@@ -394,7 +385,7 @@ impl<
                                 .0,
                         )
                         .unwrap(),
-                    GeometryLabel::Connection
+                    GeometryLabel::Joined
                 )
             })
             .map(|ni| {
@@ -406,7 +397,7 @@ impl<
     }
 
     pub fn seg_joints(&self, seg: SI) -> (DI, DI) {
-        let v: Vec<_> = self.connecteds(seg.into()).collect();
+        let v: Vec<_> = self.joineds(seg.into()).collect();
         (
             v[0].try_into().unwrap_or_else(|_| unreachable!()),
             v[1].try_into().unwrap_or_else(|_| unreachable!()),
@@ -414,21 +405,19 @@ impl<
     }
 
     pub fn bend_joints(&self, bend: BI) -> (DI, DI) {
-        let v: Vec<_> = self.connecteds(bend.into()).collect();
+        let v: Vec<_> = self.joineds(bend.into()).collect();
         (
             v[0].try_into().unwrap_or_else(|_| unreachable!()),
             v[1].try_into().unwrap_or_else(|_| unreachable!()),
         )
     }
 
-    pub fn connected_segs(&self, dot: DI) -> impl Iterator<Item = SI> + '_ {
+    pub fn joined_segs(&self, dot: DI) -> impl Iterator<Item = SI> + '_ {
-        self.connecteds(dot.into())
+        self.joineds(dot.into()).filter_map(|ni| ni.try_into().ok())
-            .filter_map(|ni| ni.try_into().ok())
     }
 
-    pub fn connected_bends(&self, dot: DI) -> impl Iterator<Item = BI> + '_ {
+    pub fn joined_bends(&self, dot: DI) -> impl Iterator<Item = BI> + '_ {
-        self.connecteds(dot.into())
+        self.joineds(dot.into()).filter_map(|ni| ni.try_into().ok())
-            .filter_map(|ni| ni.try_into().ok())
     }
 
     pub fn graph(&self) -> &StableDiGraph<GW, GeometryLabel, usize> {

src/layout/geometry/with_rtree.rs

@@ -114,11 +114,11 @@ impl<
     }
 
     pub fn remove_dot(&mut self, dot: DI) -> Result<(), ()> {
-        if self.geometry.connected_segs(dot).next().is_some() {
+        if self.geometry.joined_segs(dot).next().is_some() {
             return Err(());
         }
 
-        if self.geometry.connected_bends(dot).next().is_some() {
+        if self.geometry.joined_bends(dot).next().is_some() {
             return Err(());
         }
 
@@ -138,11 +138,11 @@ impl<
     }
 
     pub fn move_dot(&mut self, dot: DI, to: Point) {
-        for seg in self.geometry.connected_segs(dot) {
+        for seg in self.geometry.joined_segs(dot) {
             self.rtree.remove(&self.make_seg_bbox(seg));
         }
 
-        for bend in self.geometry.connected_bends(dot) {
+        for bend in self.geometry.joined_bends(dot) {
             self.rtree.remove(&self.make_bend_bbox(bend));
         }
 
@@ -150,11 +150,11 @@ impl<
         self.geometry.move_dot(dot, to);
         self.rtree.insert(self.make_dot_bbox(dot));
 
-        for bend in self.geometry.connected_bends(dot) {
+        for bend in self.geometry.joined_bends(dot) {
             self.rtree.insert(self.make_bend_bbox(bend));
         }
 
-        for seg in self.geometry.connected_segs(dot) {
+        for seg in self.geometry.joined_segs(dot) {
             self.rtree.insert(self.make_seg_bbox(seg));
         }
     }

src/layout/layout.rs

@@ -260,7 +260,7 @@ impl<R: RulesTrait> Layout<R> {
         cw: bool,
     ) -> Result<Segbend, LayoutException> {
         let maybe_wraparound = self.wraparoundable(around).wraparound();
-        let mut infringables = self.collect().segbend_inner_and_outer_bibows(from, around);
+        let mut infringables = self.collect().potential_segbend_abutters(from, around);
 
         if let Some(wraparound) = maybe_wraparound {
             infringables.append(&mut self.collect().outer_bows(wraparound));
@@ -345,18 +345,18 @@ impl<R: RulesTrait> Layout<R> {
                 self.move_dot_infringably(
                     joints.0.into(),
                     from,
-                    &self.collect().inner_bow_and_outer_bows(rail),
+                    &self.collect().bend_abutters_and_posteriors(rail),
                 )?;
                 self.move_dot_infringably(
                     joints.1.into(),
                     to,
-                    &self.collect().inner_bow_and_outer_bows(rail),
+                    &self.collect().bend_abutters_and_posteriors(rail),
                 )?;
 
                 self.shift_bend_infringably(
                     rail.into(),
                     offset,
-                    &self.collect().inner_bow_and_outer_bows(rail),
+                    &self.collect().bend_abutters_and_posteriors(rail),
                 )?;
 
                 // Update offsets in case the rule conditions changed.
@@ -387,18 +387,18 @@ impl<R: RulesTrait> Layout<R> {
                 self.move_dot_infringably(
                     joints.0.into(),
                     from,
-                    &self.collect().inner_bow_and_outer_bows(rail),
+                    &self.collect().bend_abutters_and_posteriors(rail),
                 )?;
                 self.move_dot_infringably(
                     joints.1.into(),
                     to,
-                    &self.collect().inner_bow_and_outer_bows(rail),
+                    &self.collect().bend_abutters_and_posteriors(rail),
                 )?;
 
                 self.shift_bend_infringably(
                     rail.into(),
                     offset,
-                    &self.collect().inner_bow_and_outer_bows(rail),
+                    &self.collect().bend_abutters_and_posteriors(rail),
                 )?;
             }
 
@@ -428,7 +428,7 @@ impl<R: RulesTrait> Layout<R> {
             seg_weight,
             bend_weight,
             cw,
-            &self.collect().segbend_inner_and_outer_bibows(from, around),
+            &self.collect().potential_segbend_abutters(from, around),
         )
     }
 
@@ -522,7 +522,7 @@ impl<R: RulesTrait> Layout<R> {
             weight,
             &self
                 .collect()
-                .inner_bow_and_outer_bow(self.primitive(to).bend().into()),
+                .bend_abutters(self.primitive(to).bend().into()),
         )?;
 
         if let DotIndex::Fixed(dot) = from {
@@ -742,9 +742,7 @@ impl<R: RulesTrait> Layout<R> {
             DotIndex::Loose(loose) => self.move_dot_infringably(
                 dot,
                 to,
-                &self
+                &self.collect().bend_abutters(self.primitive(loose).bend()),
-                    .collect()
-                    .inner_bow_and_outer_bow(self.primitive(loose).bend()),
             ),
         }
     }

src/layout/primitive.rs

@@ -249,7 +249,7 @@ impl<'a, R: RulesTrait> FixedDot<'a, R> {
     pub fn first_loose(&self, _band: BandIndex) -> Option<LooseIndex> {
         self.layout
             .geometry()
-            .connecteds(self.index.into())
+            .joineds(self.index.into())
             .into_iter()
             .find_map(|ni| {
                 let weight = self
@@ -279,14 +279,14 @@ impl<'a, R: RulesTrait> GetLimbs for FixedDot<'a, R> {
     fn segs(&self) -> Vec<SegIndex> {
         self.layout
             .geometry()
-            .connected_segs(self.index.into())
+            .joined_segs(self.index.into())
             .collect()
     }
 
     fn bends(&self) -> Vec<BendIndex> {
         self.layout
             .geometry()
-            .connected_bends(self.index.into())
+            .joined_bends(self.index.into())
             .collect()
     }
 }
@@ -300,7 +300,7 @@ impl<'a, R: RulesTrait> LooseDot<'a, R> {
     pub fn seg(&self) -> Option<SeqLooseSegIndex> {
         self.layout
             .geometry()
-            .connected_segs(self.index.into())
+            .joined_segs(self.index.into())
             .map(|ni| SeqLooseSegIndex::new(ni.node_index()))
             .next()
     }
@@ -308,7 +308,7 @@ impl<'a, R: RulesTrait> LooseDot<'a, R> {
     pub fn bend(&self) -> LooseBendIndex {
         self.layout
             .geometry()
-            .connected_bends(self.index.into())
+            .joined_bends(self.index.into())
             .map(|ni| LooseBendIndex::new(ni.node_index()))
             .next()
             .unwrap()