berkus
/
topola
mirror of https://codeberg.org/topola/topola.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

layout,geometry: move some code from `Layout` to new `Geometry` struct

This commit is contained in:
Mikolaj Wielgus 2024-01-27 15:33:17 +00:00
parent 8c1b7d1e7e
commit 9f42991032
5 changed files with 242 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
src/geometry/geometry.rs
View File

@ -1,18 +1,21 @@
use contracts::debug_invariant;
use enum_dispatch::enum_dispatch; use enum_dispatch::enum_dispatch;
use geo::Point;
use petgraph::stable_graph::{NodeIndex, StableDiGraph}; use petgraph::stable_graph::{NodeIndex, StableDiGraph};
use crate::{ use crate::{
connectivity::{BandIndex, ComponentIndex}, connectivity::{BandIndex, ComponentIndex},
graph::{GenericIndex, GetNodeIndex},
layout::Layout, layout::Layout,
primitive::Primitive, primitive::Primitive,
}; };
use super::{ use super::{
bend::{FixedBendIndex, FixedBendWeight, LooseBendIndex, LooseBendWeight}, bend::{BendWeight, FixedBendIndex, FixedBendWeight, LooseBendIndex, LooseBendWeight},
dot::{FixedDotIndex, FixedDotWeight, LooseDotIndex, LooseDotWeight}, dot::{DotWeight, FixedDotIndex, FixedDotWeight, LooseDotIndex, LooseDotWeight},
seg::{ seg::{
FixedSegIndex, FixedSegWeight, LoneLooseSegIndex, LoneLooseSegWeight, SeqLooseSegIndex, FixedSegIndex, FixedSegWeight, LoneLooseSegIndex, LoneLooseSegWeight, SegWeight,
SeqLooseSegWeight, SeqLooseSegIndex, SeqLooseSegWeight,
}, },
}; };
@ -128,3 +131,62 @@ pub enum GeometryLabel {
pub trait MakePrimitive { pub trait MakePrimitive {
fn primitive<'a>(&self, layout: &'a Layout) -> Primitive<'a>; fn primitive<'a>(&self, layout: &'a Layout) -> Primitive<'a>;
} }
#[derive(Debug)]
pub struct Geometry {
pub graph: GeometryGraph,
}
impl Geometry {
pub fn new() -> Self {
Self {
graph: StableDiGraph::default(),
}
}
pub fn add_dot<W: DotWeight>(&mut self, weight: W) -> GenericIndex<W> {
GenericIndex::<W>::new(self.graph.add_node(weight.into()))
}
pub fn add_seg<W: SegWeight>(
&mut self,
from: impl GetNodeIndex,
to: impl GetNodeIndex,
weight: W,
) -> GenericIndex<W> {
let seg = GenericIndex::<W>::new(self.graph.add_node(weight.into()));
self.graph
.update_edge(from.node_index(), seg.node_index(), GeometryLabel::Adjacent);
self.graph
.update_edge(seg.node_index(), to.node_index(), GeometryLabel::Adjacent);
seg
}
pub fn add_bend<W: BendWeight>(
&mut self,
from: impl GetNodeIndex,
to: impl GetNodeIndex,
core: impl GetNodeIndex,
weight: W,
) -> GenericIndex<W> {
let bend = GenericIndex::<W>::new(self.graph.add_node(weight.into()));
self.graph.update_edge(
from.node_index(),
bend.node_index(),
GeometryLabel::Adjacent,
);
self.graph
.update_edge(bend.node_index(), to.node_index(), GeometryLabel::Adjacent);
self.graph
.update_edge(bend.node_index(), core.node_index(), GeometryLabel::Core);
bend
}
pub fn graph(&self) -> &GeometryGraph {
&self.graph
}
}

295
src/layout.rs
View File

@ -13,6 +13,7 @@ use crate::connectivity::{
BandIndex, BandWeight, ComponentIndex, ComponentWeight, ConnectivityGraph, ConnectivityLabel, BandIndex, BandWeight, ComponentIndex, ComponentWeight, ConnectivityGraph, ConnectivityLabel,
ConnectivityWeight, GetNet, ConnectivityWeight, GetNet,
}; };
use crate::geometry::geometry::Geometry;
use crate::geometry::seg::SeqLooseSegWeight; use crate::geometry::seg::SeqLooseSegWeight;
use crate::geometry::{ use crate::geometry::{
bend::{BendWeight, FixedBendIndex, LooseBendIndex, LooseBendWeight}, bend::{BendWeight, FixedBendIndex, LooseBendIndex, LooseBendWeight},
@ -70,17 +71,17 @@ pub struct AlreadyConnected(pub i64, pub GeometryIndex);
pub struct Layout { pub struct Layout {
rtree: RTree<RTreeWrapper>, rtree: RTree<RTreeWrapper>,
connectivity: ConnectivityGraph, connectivity: ConnectivityGraph,
geometry: GeometryGraph, geometry: Geometry,
} }
#[debug_invariant(self.geometry.node_count() == self.rtree.size())] #[debug_invariant(self.geometry.graph().node_count() == self.rtree.size())]
#[debug_invariant(self.test_envelopes())] #[debug_invariant(self.test_envelopes())]
impl Layout { impl Layout {
pub fn new() -> Self { pub fn new() -> Self {
Layout { Layout {
rtree: RTree::new(), rtree: RTree::new(),
connectivity: StableDiGraph::default(), connectivity: StableDiGraph::default(),
geometry: StableDiGraph::default(), geometry: Geometry::new(),
} }
} }
@ -143,7 +144,7 @@ impl Layout {
self.connectivity.remove_node(band.node_index()); self.connectivity.remove_node(band.node_index());
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count() - 4))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count() - 4))]
pub fn remove_segbend(&mut self, segbend: &Segbend, face: LooseDotIndex) { pub fn remove_segbend(&mut self, segbend: &Segbend, face: LooseDotIndex) {
let maybe_outer = self.primitive(segbend.bend).outer(); let maybe_outer = self.primitive(segbend.bend).outer();
@ -166,18 +167,22 @@ impl Layout {
} }
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count() - 1))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count() - 1))]
fn remove(&mut self, node: GeometryIndex) { fn remove(&mut self, node: GeometryIndex) {
// Unnecessary retag. It should be possible to elide it. // Unnecessary retag. It should be possible to elide it.
let weight = *self.geometry.node_weight(node.node_index()).unwrap(); let weight = *self
.geometry
.graph()
.node_weight(node.node_index())
.unwrap();
self.remove_from_rtree(weight.retag(node.node_index())); self.remove_from_rtree(weight.retag(node.node_index()));
self.geometry.remove_node(node.node_index()); self.geometry.graph.remove_node(node.node_index());
} }
// TODO: This method shouldn't be public. // TODO: This method shouldn't be public.
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn add_component(&mut self, net: i64) -> ComponentIndex { pub fn add_component(&mut self, net: i64) -> ComponentIndex {
ComponentIndex::new( ComponentIndex::new(
self.connectivity self.connectivity
@ -186,8 +191,8 @@ impl Layout {
} }
// TODO: This method shouldn't be public. // TODO: This method shouldn't be public.
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn add_band(&mut self, from: FixedDotIndex, width: f64) -> BandIndex { pub fn add_band(&mut self, from: FixedDotIndex, width: f64) -> BandIndex {
BandIndex::new( BandIndex::new(
self.connectivity self.connectivity
@ -199,9 +204,9 @@ impl Layout {
) )
} }
#[debug_ensures(ret.is_ok() -> self.geometry.node_count() == old(self.geometry.node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count() + 1))]
#[debug_ensures(ret.is_err() -> self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn add_fixed_dot(&mut self, weight: FixedDotWeight) -> Result<FixedDotIndex, Infringement> { pub fn add_fixed_dot(&mut self, weight: FixedDotWeight) -> Result<FixedDotIndex, Infringement> {
self.add_dot_infringably(weight, &[]) self.add_dot_infringably(weight, &[])
} }
@ -213,8 +218,8 @@ impl Layout {
self.add_dot_infringably(weight, &[]) self.add_dot_infringably(weight, &[])
}*/ }*/
#[debug_ensures(ret.is_ok() -> self.geometry.node_count() == old(self.geometry.node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count() + 1))]
#[debug_ensures(ret.is_err() -> self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
fn add_dot_infringably<W: DotWeight>( fn add_dot_infringably<W: DotWeight>(
&mut self, &mut self,
weight: W, weight: W,
@ -223,7 +228,7 @@ impl Layout {
where where
GenericIndex<W>: Into<GeometryIndex> + Copy, GenericIndex<W>: Into<GeometryIndex> + Copy,
{ {
let dot = GenericIndex::<W>::new(self.geometry.add_node(weight.into())); let dot = self.geometry.add_dot(weight);
self.insert_into_rtree(dot.into()); self.insert_into_rtree(dot.into());
self.fail_and_remove_if_infringes_except(dot.into(), infringables)?; self.fail_and_remove_if_infringes_except(dot.into(), infringables)?;
@ -231,10 +236,10 @@ impl Layout {
Ok(dot) Ok(dot)
} }
#[debug_ensures(ret.is_ok() -> self.geometry.node_count() == old(self.geometry.node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count() + 1))]
#[debug_ensures(ret.is_ok() -> self.geometry.edge_count() == old(self.geometry.edge_count() + 2))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count() + 2))]
#[debug_ensures(ret.is_err() -> self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(ret.is_err() -> self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn add_fixed_seg( pub fn add_fixed_seg(
&mut self, &mut self,
from: FixedDotIndex, from: FixedDotIndex,
@ -244,10 +249,10 @@ impl Layout {
self.add_seg_infringably(from, to, weight, &[]) self.add_seg_infringably(from, to, weight, &[])
} }
#[debug_ensures(ret.is_ok() -> self.geometry.node_count() == old(self.geometry.node_count() + 4))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count() + 4))]
#[debug_ensures(ret.is_ok() -> self.geometry.edge_count() >= old(self.geometry.edge_count() + 5))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().edge_count() >= old(self.geometry.graph().edge_count() + 5))]
#[debug_ensures(ret.is_err() -> self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(ret.is_err() -> self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn insert_segbend( pub fn insert_segbend(
&mut self, &mut self,
from: DotIndex, from: DotIndex,
@ -290,8 +295,8 @@ impl Layout {
Ok::<Segbend, LayoutException>(segbend) Ok::<Segbend, LayoutException>(segbend)
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn inner_bow_and_outer_bow(&self, bend: LooseBendIndex) -> Vec<GeometryIndex> { fn inner_bow_and_outer_bow(&self, bend: LooseBendIndex) -> Vec<GeometryIndex> {
let bend_primitive = self.primitive(bend); let bend_primitive = self.primitive(bend);
let mut v = vec![]; let mut v = vec![];
@ -310,8 +315,8 @@ impl Layout {
v v
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn inner_bow_and_outer_bows(&self, bend: LooseBendIndex) -> Vec<GeometryIndex> { fn inner_bow_and_outer_bows(&self, bend: LooseBendIndex) -> Vec<GeometryIndex> {
let bend_primitive = self.primitive(bend); let bend_primitive = self.primitive(bend);
let mut v = vec![]; let mut v = vec![];
@ -333,8 +338,8 @@ impl Layout {
v v
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn this_and_wraparound_bow(&self, around: WraparoundableIndex) -> Vec<GeometryIndex> { fn this_and_wraparound_bow(&self, around: WraparoundableIndex) -> Vec<GeometryIndex> {
let mut v = match around { let mut v = match around {
WraparoundableIndex::FixedDot(..) => vec![around.into()], WraparoundableIndex::FixedDot(..) => vec![around.into()],
@ -348,8 +353,8 @@ impl Layout {
} }
// XXX: Move this to primitives? // XXX: Move this to primitives?
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn bow(&self, bend: LooseBendIndex) -> Vec<GeometryIndex> { fn bow(&self, bend: LooseBendIndex) -> Vec<GeometryIndex> {
let mut bow: Vec<GeometryIndex> = vec![]; let mut bow: Vec<GeometryIndex> = vec![];
bow.push(bend.into()); bow.push(bend.into());
@ -369,8 +374,8 @@ impl Layout {
bow bow
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn outer_bows(&self, bend: LooseBendIndex) -> Vec<GeometryIndex> { fn outer_bows(&self, bend: LooseBendIndex) -> Vec<GeometryIndex> {
let mut outer_bows = vec![]; let mut outer_bows = vec![];
let mut rail = bend; let mut rail = bend;
@ -393,24 +398,25 @@ impl Layout {
outer_bows outer_bows
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()) #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count())
|| self.geometry.edge_count() == old(self.geometry.edge_count() - 1) || self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count() - 1)
|| self.geometry.edge_count() == old(self.geometry.edge_count() + 1))] || self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count() + 1))]
fn reattach_bend(&mut self, bend: LooseBendIndex, maybe_new_inner: Option<LooseBendIndex>) { fn reattach_bend(&mut self, bend: LooseBendIndex, maybe_new_inner: Option<LooseBendIndex>) {
self.remove_from_rtree(bend.into()); self.remove_from_rtree(bend.into());
if let Some(old_inner_edge) = self if let Some(old_inner_edge) = self
.geometry .geometry()
.graph()
.edges_directed(bend.node_index(), Incoming) .edges_directed(bend.node_index(), Incoming)
.filter(|edge| *edge.weight() == GeometryLabel::Outer) .filter(|edge| *edge.weight() == GeometryLabel::Outer)
.next() .next()
{ {
self.geometry.remove_edge(old_inner_edge.id()); self.geometry.graph.remove_edge(old_inner_edge.id());
} }
if let Some(new_inner) = maybe_new_inner { if let Some(new_inner) = maybe_new_inner {
self.geometry.update_edge( self.geometry.graph.update_edge(
new_inner.node_index(), new_inner.node_index(),
bend.node_index(), bend.node_index(),
GeometryLabel::Outer, GeometryLabel::Outer,
@ -420,8 +426,8 @@ impl Layout {
self.insert_into_rtree(bend.into()); self.insert_into_rtree(bend.into());
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn update_this_and_outward_bows( fn update_this_and_outward_bows(
&mut self, &mut self,
around: LooseBendIndex, around: LooseBendIndex,
@ -475,10 +481,10 @@ impl Layout {
Ok::<(), LayoutException>(()) Ok::<(), LayoutException>(())
} }
#[debug_ensures(ret.is_ok() -> self.geometry.node_count() == old(self.geometry.node_count() + 4))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count() + 4))]
#[debug_ensures(ret.is_ok() -> self.geometry.edge_count() >= old(self.geometry.edge_count() + 5))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().edge_count() >= old(self.geometry.graph().edge_count() + 5))]
#[debug_ensures(ret.is_err() -> self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(ret.is_err() -> self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn add_segbend( pub fn add_segbend(
&mut self, &mut self,
from: DotIndex, from: DotIndex,
@ -497,10 +503,10 @@ impl Layout {
) )
} }
#[debug_ensures(ret.is_ok() -> self.geometry.node_count() == old(self.geometry.node_count() + 4))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count() + 4))]
#[debug_ensures(ret.is_ok() -> self.geometry.edge_count() >= old(self.geometry.edge_count() + 5))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().edge_count() >= old(self.geometry.graph().edge_count() + 5))]
#[debug_ensures(ret.is_err() -> self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(ret.is_err() -> self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn add_segbend_infringably( fn add_segbend_infringably(
&mut self, &mut self,
from: DotIndex, from: DotIndex,
@ -541,10 +547,10 @@ impl Layout {
}) })
} }
#[debug_ensures(ret.is_ok() -> self.geometry.node_count() == old(self.geometry.node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count() + 1))]
#[debug_ensures(ret.is_ok() -> self.geometry.edge_count() == old(self.geometry.edge_count() + 2))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count() + 2))]
#[debug_ensures(ret.is_err() -> self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(ret.is_err() -> self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn add_lone_loose_seg( pub fn add_lone_loose_seg(
&mut self, &mut self,
from: FixedDotIndex, from: FixedDotIndex,
@ -567,10 +573,10 @@ impl Layout {
Ok(seg) Ok(seg)
} }
#[debug_ensures(ret.is_ok() -> self.geometry.node_count() == old(self.geometry.node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count() + 1))]
#[debug_ensures(ret.is_ok() -> self.geometry.edge_count() == old(self.geometry.edge_count() + 2))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count() + 2))]
#[debug_ensures(ret.is_err() -> self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(ret.is_err() -> self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn add_seq_loose_seg( pub fn add_seq_loose_seg(
&mut self, &mut self,
from: DotIndex, from: DotIndex,
@ -590,10 +596,10 @@ impl Layout {
Ok(seg) Ok(seg)
} }
#[debug_ensures(ret.is_ok() -> self.geometry.node_count() == old(self.geometry.node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count() + 1))]
#[debug_ensures(ret.is_ok() -> self.geometry.edge_count() == old(self.geometry.edge_count() + 2))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count() + 2))]
#[debug_ensures(ret.is_err() -> self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(ret.is_err() -> self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn add_seg_infringably<W: SegWeight>( fn add_seg_infringably<W: SegWeight>(
&mut self, &mut self,
from: impl GetNodeIndex, from: impl GetNodeIndex,
@ -604,12 +610,7 @@ impl Layout {
where where
GenericIndex<W>: Into<GeometryIndex> + Copy, GenericIndex<W>: Into<GeometryIndex> + Copy,
{ {
let seg = GenericIndex::<W>::new(self.geometry.add_node(weight.into())); let seg = self.geometry.add_seg(from, to, weight);
self.geometry
.update_edge(from.node_index(), seg.node_index(), GeometryLabel::Adjacent);
self.geometry
.update_edge(seg.node_index(), to.node_index(), GeometryLabel::Adjacent);
self.insert_into_rtree(seg.into()); self.insert_into_rtree(seg.into());
self.fail_and_remove_if_infringes_except(seg.into(), infringables)?; self.fail_and_remove_if_infringes_except(seg.into(), infringables)?;
@ -633,11 +634,11 @@ impl Layout {
} }
}*/ }*/
#[debug_ensures(ret.is_ok() -> self.geometry.node_count() == old(self.geometry.node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count() + 1))]
#[debug_ensures(ret.is_ok() -> self.geometry.edge_count() == old(self.geometry.edge_count() + 3) #[debug_ensures(ret.is_ok() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count() + 3)
|| self.geometry.edge_count() == old(self.geometry.edge_count() + 4))] || self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count() + 4))]
#[debug_ensures(ret.is_err() -> self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(ret.is_err() -> self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn add_loose_bend_infringably( fn add_loose_bend_infringably(
&mut self, &mut self,
from: LooseDotIndex, from: LooseDotIndex,
@ -672,10 +673,10 @@ impl Layout {
} }
} }
#[debug_ensures(ret.is_ok() -> self.geometry.node_count() == old(self.geometry.node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count() + 1))]
#[debug_ensures(ret.is_err() -> self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(ret.is_ok() -> self.geometry.edge_count() == old(self.geometry.edge_count() + 3))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count() + 3))]
#[debug_ensures(ret.is_err() -> self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn add_core_bend_infringably<W: BendWeight>( fn add_core_bend_infringably<W: BendWeight>(
&mut self, &mut self,
from: impl GetNodeIndex, from: impl GetNodeIndex,
@ -683,31 +684,21 @@ impl Layout {
core: FixedDotIndex, core: FixedDotIndex,
weight: W, weight: W,
infringables: &[GeometryIndex], infringables: &[GeometryIndex],
) -> Result<LooseBendIndex, Infringement> ) -> Result<GenericIndex<W>, Infringement>
where where
GenericIndex<W>: Into<GeometryIndex> + Copy, GenericIndex<W>: Into<GeometryIndex> + Copy,
{ {
let bend = LooseBendIndex::new(self.geometry.add_node(weight.into())); let bend = self.geometry.add_bend(from, to, core, weight);
self.geometry.update_edge(
from.node_index(),
bend.node_index(),
GeometryLabel::Adjacent,
);
self.geometry
.update_edge(bend.node_index(), to.node_index(), GeometryLabel::Adjacent);
self.geometry
.update_edge(bend.node_index(), core.node_index(), GeometryLabel::Core);
self.insert_into_rtree(bend.into()); self.insert_into_rtree(bend.into());
self.fail_and_remove_if_infringes_except(bend.into(), infringables)?; self.fail_and_remove_if_infringes_except(bend.into(), infringables)?;
Ok(bend) Ok(bend)
} }
#[debug_ensures(ret.is_ok() -> self.geometry.node_count() == old(self.geometry.node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count() + 1))]
#[debug_ensures(ret.is_err() -> self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(ret.is_ok() -> self.geometry.edge_count() == old(self.geometry.edge_count() + 4))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count() + 4))]
#[debug_ensures(ret.is_err() -> self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(ret.is_err() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn add_outer_bend_infringably<W: BendWeight>( fn add_outer_bend_infringably<W: BendWeight>(
&mut self, &mut self,
from: impl GetNodeIndex, from: impl GetNodeIndex,
@ -715,14 +706,24 @@ impl Layout {
inner: impl GetNodeIndex, inner: impl GetNodeIndex,
weight: W, weight: W,
infringables: &[GeometryIndex], infringables: &[GeometryIndex],
) -> Result<LooseBendIndex, Infringement> { ) -> Result<GenericIndex<W>, Infringement>
where
GenericIndex<W>: Into<GeometryIndex>,
{
let core = *self let core = *self
.geometry .geometry
.graph()
.neighbors(inner.node_index()) .neighbors(inner.node_index())
.filter(|ni| { .filter(|ni| {
matches!( matches!(
self.geometry self.geometry
.edge_weight(self.geometry.find_edge(inner.node_index(), *ni).unwrap()) .graph()
.edge_weight(
self.geometry
.graph()
.find_edge(inner.node_index(), *ni)
.unwrap()
)
.unwrap(), .unwrap(),
GeometryLabel::Core GeometryLabel::Core
) )
@ -732,32 +733,26 @@ impl Layout {
.first() .first()
.unwrap(); .unwrap();
let bend = LooseBendIndex::new(self.geometry.add_node(weight.into())); let bend = self.geometry.add_bend(from, to, core, weight);
self.geometry.update_edge( self.geometry.graph.update_edge(
from.node_index(), inner.node_index(),
bend.node_index(), bend.node_index(),
GeometryLabel::Adjacent, GeometryLabel::Outer,
); );
self.geometry
.update_edge(bend.node_index(), to.node_index(), GeometryLabel::Adjacent);
self.geometry
.update_edge(bend.node_index(), core.node_index(), GeometryLabel::Core);
self.geometry
.update_edge(inner.node_index(), bend.node_index(), GeometryLabel::Outer);
self.insert_into_rtree(bend.into()); self.insert_into_rtree(bend.into());
self.fail_and_remove_if_infringes_except(bend.into(), infringables)?; self.fail_and_remove_if_infringes_except(bend.into(), infringables)?;
Ok(bend) Ok(bend)
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn flip_bend(&mut self, bend: FixedBendIndex) { pub fn flip_bend(&mut self, bend: FixedBendIndex) {
self.remove_from_rtree(bend.into()); self.remove_from_rtree(bend.into());
let Some(GeometryWeight::FixedBend(weight)) = let Some(GeometryWeight::FixedBend(weight)) =
self.geometry.node_weight_mut(bend.node_index()) self.geometry.graph.node_weight_mut(bend.node_index())
else { else {
unreachable!(); unreachable!();
}; };
@ -775,9 +770,9 @@ impl Layout {
Segbend::from_dot(dot, self) Segbend::from_dot(dot, self)
} }
#[debug_ensures(ret.is_ok() -> self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(ret.is_ok() -> self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(ret.is_ok() -> self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
#[debug_ensures(ret.is_err() -> self.geometry.node_count() == old(self.geometry.node_count() - 1))] #[debug_ensures(ret.is_err() -> self.geometry.graph().node_count() == old(self.geometry.graph().node_count() - 1))]
fn fail_and_remove_if_infringes_except( fn fail_and_remove_if_infringes_except(
&mut self, &mut self,
node: GeometryIndex, node: GeometryIndex,
@ -799,7 +794,7 @@ impl Layout {
} }
pub fn node_count(&self) -> usize { pub fn node_count(&self) -> usize {
self.geometry.node_count() self.geometry.graph().node_count()
} }
fn node_indices(&self) -> impl Iterator<Item = GeometryIndex> + '_ { fn node_indices(&self) -> impl Iterator<Item = GeometryIndex> + '_ {
@ -809,8 +804,8 @@ impl Layout {
#[debug_invariant(self.test_envelopes())] #[debug_invariant(self.test_envelopes())]
impl Layout { impl Layout {
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn move_dot(&mut self, dot: DotIndex, to: Point) -> Result<(), Infringement> { pub fn move_dot(&mut self, dot: DotIndex, to: Point) -> Result<(), Infringement> {
match dot { match dot {
DotIndex::Fixed(..) => self.move_dot_infringably(dot, to, &[]), DotIndex::Fixed(..) => self.move_dot_infringably(dot, to, &[]),
@ -822,8 +817,8 @@ impl Layout {
} }
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn move_dot_infringably( fn move_dot_infringably(
&mut self, &mut self,
dot: DotIndex, dot: DotIndex,
@ -832,7 +827,7 @@ impl Layout {
) -> Result<(), Infringement> { ) -> Result<(), Infringement> {
self.remove_from_rtree_with_legs(dot.into()); self.remove_from_rtree_with_legs(dot.into());
let mut weight = *self.geometry.node_weight(dot.node_index()).unwrap(); let mut weight = *self.geometry.graph.node_weight(dot.node_index()).unwrap();
let old_weight = weight; let old_weight = weight;
match weight { match weight {
@ -845,11 +840,19 @@ impl Layout {
_ => unreachable!(), _ => unreachable!(),
} }
*self.geometry.node_weight_mut(dot.node_index()).unwrap() = weight; *self
.geometry
.graph
.node_weight_mut(dot.node_index())
.unwrap() = weight;
if let Some(infringement) = self.detect_infringement_except(dot.into(), infringables) { if let Some(infringement) = self.detect_infringement_except(dot.into(), infringables) {
// Restore original state. // Restore original state.
*self.geometry.node_weight_mut(dot.node_index()).unwrap() = old_weight; *self
.geometry
.graph
.node_weight_mut(dot.node_index())
.unwrap() = old_weight;
self.insert_into_rtree_with_legs(dot.into()); self.insert_into_rtree_with_legs(dot.into());
return Err(infringement); return Err(infringement);
@ -859,8 +862,8 @@ impl Layout {
Ok(()) Ok(())
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn detect_infringement_except( fn detect_infringement_except(
&self, &self,
node: GeometryIndex, node: GeometryIndex,
@ -882,8 +885,8 @@ impl Layout {
} }
// TODO: Collision and infringement are the same for now. Change this. // TODO: Collision and infringement are the same for now. Change this.
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn detect_collision(&self, node: GeometryIndex) -> Option<Collision> { fn detect_collision(&self, node: GeometryIndex) -> Option<Collision> {
let shape = node.primitive(self).shape(); let shape = node.primitive(self).shape();
@ -899,8 +902,8 @@ impl Layout {
.and_then(|collidee| Some(Collision(shape, collidee))) .and_then(|collidee| Some(Collision(shape, collidee)))
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn insert_into_rtree_with_legs(&mut self, node: GeometryIndex) { fn insert_into_rtree_with_legs(&mut self, node: GeometryIndex) {
self.insert_into_rtree(node); self.insert_into_rtree(node);
@ -909,15 +912,15 @@ impl Layout {
} }
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn insert_into_rtree(&mut self, node: GeometryIndex) { fn insert_into_rtree(&mut self, node: GeometryIndex) {
let shape = node.primitive(self).shape(); let shape = node.primitive(self).shape();
self.rtree.insert(RTreeWrapper::new(shape, node)); self.rtree.insert(RTreeWrapper::new(shape, node));
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn remove_from_rtree_with_legs(&mut self, node: GeometryIndex) { fn remove_from_rtree_with_legs(&mut self, node: GeometryIndex) {
for leg in node.primitive(self).legs() { for leg in node.primitive(self).legs() {
self.remove_from_rtree(leg); self.remove_from_rtree(leg);
@ -926,8 +929,8 @@ impl Layout {
self.remove_from_rtree(node); self.remove_from_rtree(node);
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
fn remove_from_rtree(&mut self, node: GeometryIndex) { fn remove_from_rtree(&mut self, node: GeometryIndex) {
let shape = node.primitive(self).shape(); let shape = node.primitive(self).shape();
let removed_element = self.rtree.remove(&RTreeWrapper::new(shape, node)); let removed_element = self.rtree.remove(&RTreeWrapper::new(shape, node));
@ -936,38 +939,38 @@ impl Layout {
} }
impl Layout { impl Layout {
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn connectivity(&self) -> &ConnectivityGraph { pub fn connectivity(&self) -> &ConnectivityGraph {
&self.connectivity &self.connectivity
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn geometry(&self) -> &GeometryGraph { pub fn geometry(&self) -> &Geometry {
&self.geometry &self.geometry
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn primitive<W>(&self, index: GenericIndex<W>) -> GenericPrimitive<W> { pub fn primitive<W>(&self, index: GenericIndex<W>) -> GenericPrimitive<W> {
GenericPrimitive::new(index, self) GenericPrimitive::new(index, self)
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn wraparoundable(&self, index: WraparoundableIndex) -> Wraparoundable { pub fn wraparoundable(&self, index: WraparoundableIndex) -> Wraparoundable {
Wraparoundable::new(index, self) Wraparoundable::new(index, self)
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn loose(&self, index: LooseIndex) -> Loose { pub fn loose(&self, index: LooseIndex) -> Loose {
Loose::new(index, self) Loose::new(index, self)
} }
#[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.graph().node_count() == old(self.geometry.graph().node_count()))]
#[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] #[debug_ensures(self.geometry.graph().edge_count() == old(self.geometry.graph().edge_count()))]
pub fn band(&self, index: BandIndex) -> Band { pub fn band(&self, index: BandIndex) -> Band {
Band::new(index, self) Band::new(index, self)
} }

2
src/mesh.rs
View File

@ -89,7 +89,7 @@ impl Mesh {
vertex_to_triangulation_vertex: Vec::new(), vertex_to_triangulation_vertex: Vec::new(),
}; };
this.vertex_to_triangulation_vertex this.vertex_to_triangulation_vertex
.resize(layout.geometry().node_bound(), None); .resize(layout.geometry().graph().node_bound(), None);
this this
} }

32
src/primitive.rs
View File

@ -89,14 +89,17 @@ pub trait GetFirstRail: GetLayout + GetNodeIndex {
fn first_rail(&self) -> Option<LooseBendIndex> { fn first_rail(&self) -> Option<LooseBendIndex> {
self.layout() self.layout()
.geometry() .geometry()
.graph()
.neighbors_directed(self.node_index(), Incoming) .neighbors_directed(self.node_index(), Incoming)
.filter(|node| { .filter(|node| {
matches!( matches!(
self.layout() self.layout()
.geometry() .geometry()
.graph()
.edge_weight( .edge_weight(
self.layout() self.layout()
.geometry() .geometry()
.graph()
.find_edge(*node, self.node_index()) .find_edge(*node, self.node_index())
.unwrap() .unwrap()
) )
@ -113,14 +116,17 @@ pub trait GetCore: GetLayout + GetNodeIndex {
fn core(&self) -> FixedDotIndex { fn core(&self) -> FixedDotIndex {
self.layout() self.layout()
.geometry() .geometry()
.graph()
.neighbors(self.node_index()) .neighbors(self.node_index())
.filter(|node| { .filter(|node| {
matches!( matches!(
self.layout() self.layout()
.geometry() .geometry()
.graph()
.edge_weight( .edge_weight(
self.layout() self.layout()
.geometry() .geometry()
.graph()
.find_edge(self.node_index(), *node) .find_edge(self.node_index(), *node)
.unwrap() .unwrap()
) )
@ -138,14 +144,17 @@ pub trait GetInnerOuter: GetLayout + GetNodeIndex {
fn inner(&self) -> Option<LooseBendIndex> { fn inner(&self) -> Option<LooseBendIndex> {
self.layout() self.layout()
.geometry() .geometry()
.graph()
.neighbors_directed(self.node_index(), Incoming) .neighbors_directed(self.node_index(), Incoming)
.filter(|node| { .filter(|node| {
matches!( matches!(
self.layout() self.layout()
.geometry() .geometry()
.graph()
.edge_weight( .edge_weight(
self.layout() self.layout()
.geometry() .geometry()
.graph()
.find_edge(*node, self.node_index()) .find_edge(*node, self.node_index())
.unwrap() .unwrap()
) )
@ -160,14 +169,17 @@ pub trait GetInnerOuter: GetLayout + GetNodeIndex {
fn outer(&self) -> Option<LooseBendIndex> { fn outer(&self) -> Option<LooseBendIndex> {
self.layout() self.layout()
.geometry() .geometry()
.graph()
.neighbors_directed(self.node_index(), Outgoing) .neighbors_directed(self.node_index(), Outgoing)
.filter(|node| { .filter(|node| {
matches!( matches!(
self.layout() self.layout()
.geometry() .geometry()
.graph()
.edge_weight( .edge_weight(
self.layout() self.layout()
.geometry() .geometry()
.graph()
.find_edge(self.node_index(), *node) .find_edge(self.node_index(), *node)
.unwrap() .unwrap()
) )
@ -258,6 +270,7 @@ impl<'a, W> GenericPrimitive<'a, W> {
*self *self
.layout .layout
.geometry() .geometry()
.graph()
.node_weight(self.index.node_index()) .node_weight(self.index.node_index())
.unwrap() .unwrap()
} }
@ -265,14 +278,17 @@ impl<'a, W> GenericPrimitive<'a, W> {
fn adjacents(&self) -> Vec<NodeIndex<usize>> { fn adjacents(&self) -> Vec<NodeIndex<usize>> {
self.layout self.layout
.geometry() .geometry()
.graph()
.neighbors_undirected(self.index.node_index()) .neighbors_undirected(self.index.node_index())
.filter(|node| { .filter(|node| {
matches!( matches!(
self.layout self.layout
.geometry() .geometry()
.graph()
.edge_weight( .edge_weight(
self.layout self.layout
.geometry() .geometry()
.graph()
.find_edge_undirected(self.index.node_index(), *node) .find_edge_undirected(self.index.node_index(), *node)
.unwrap() .unwrap()
.0, .0,
@ -324,7 +340,7 @@ impl_fixed_primitive!(FixedDot, FixedDotWeight);
impl<'a> FixedDot<'a> { impl<'a> FixedDot<'a> {
pub fn first_loose(&self, _band: BandIndex) -> Option<LooseIndex> { pub fn first_loose(&self, _band: BandIndex) -> Option<LooseIndex> {
self.adjacents().into_iter().find_map(|node| { self.adjacents().into_iter().find_map(|node| {
let weight = self.layout.geometry().node_weight(node).unwrap(); let weight = self.layout.geometry().graph().node_weight(node).unwrap();
if matches!(weight, GeometryWeight::LoneLooseSeg(..)) { if matches!(weight, GeometryWeight::LoneLooseSeg(..)) {
Some(LoneLooseSegIndex::new(node).into()) Some(LoneLooseSegIndex::new(node).into())
} else if matches!(weight, GeometryWeight::SeqLooseSeg(..)) { } else if matches!(weight, GeometryWeight::SeqLooseSeg(..)) {
@ -349,7 +365,7 @@ impl<'a> GetLegs for FixedDot<'a> {
self.adjacents() self.adjacents()
.into_iter() .into_iter()
.filter_map( .filter_map(
|node| match self.layout.geometry().node_weight(node).unwrap() { |node| match self.layout.geometry().graph().node_weight(node).unwrap() {
GeometryWeight::FixedSeg(_seg) => { GeometryWeight::FixedSeg(_seg) => {
Some(SegIndex::Fixed(FixedSegIndex::new(node))) Some(SegIndex::Fixed(FixedSegIndex::new(node)))
} }
@ -370,7 +386,7 @@ impl<'a> GetLegs for FixedDot<'a> {
.into_iter() .into_iter()
.filter(|node| { .filter(|node| {
matches!( matches!(
self.layout.geometry().node_weight(*node).unwrap(), self.layout.geometry().graph().node_weight(*node).unwrap(),
GeometryWeight::FixedBend(..) GeometryWeight::FixedBend(..)
) )
}) })
@ -390,7 +406,7 @@ impl<'a> LooseDot<'a> {
.into_iter() .into_iter()
.filter(|node| { .filter(|node| {
matches!( matches!(
self.layout.geometry().node_weight(*node).unwrap(), self.layout.geometry().graph().node_weight(*node).unwrap(),
GeometryWeight::SeqLooseSeg(..) GeometryWeight::SeqLooseSeg(..)
) )
}) })
@ -403,7 +419,7 @@ impl<'a> LooseDot<'a> {
.into_iter() .into_iter()
.filter(|node| { .filter(|node| {
matches!( matches!(
self.layout.geometry().node_weight(*node).unwrap(), self.layout.geometry().graph().node_weight(*node).unwrap(),
GeometryWeight::LooseBend(..) GeometryWeight::LooseBend(..)
) )
}) })
@ -519,10 +535,12 @@ impl<'a> GetWidth for SeqLooseSeg<'a> {
impl<'a> GetEnds<DotIndex, LooseDotIndex> for SeqLooseSeg<'a> { impl<'a> GetEnds<DotIndex, LooseDotIndex> for SeqLooseSeg<'a> {
fn ends(&self) -> (DotIndex, LooseDotIndex) { fn ends(&self) -> (DotIndex, LooseDotIndex) {
let v = self.adjacents(); let v = self.adjacents();
if let GeometryWeight::FixedDot(..) = self.layout.geometry().node_weight(v[0]).unwrap() { if let GeometryWeight::FixedDot(..) =
self.layout.geometry().graph().node_weight(v[0]).unwrap()
{
(FixedDotIndex::new(v[0]).into(), LooseDotIndex::new(v[1])) (FixedDotIndex::new(v[0]).into(), LooseDotIndex::new(v[1]))
} else if let GeometryWeight::FixedDot(..) = } else if let GeometryWeight::FixedDot(..) =
self.layout.geometry().node_weight(v[1]).unwrap() self.layout.geometry().graph().node_weight(v[1]).unwrap()
{ {
(FixedDotIndex::new(v[1]).into(), LooseDotIndex::new(v[0])) (FixedDotIndex::new(v[1]).into(), LooseDotIndex::new(v[0]))
} else { } else {

2
src/triangulation.rs
View File

@ -27,7 +27,7 @@ impl<I: Copy + PartialEq + GetNodeIndex, W: GetVertexIndex<I> + HasPosition<Scal
index_marker: PhantomData, index_marker: PhantomData,
}; };
this.vertex_to_handle this.vertex_to_handle
.resize(layout.geometry().node_bound(), None); .resize(layout.geometry().graph().node_bound(), None);
this this
} }