diff --git a/src/layout.rs b/src/layout.rs index e170911..ef57fce 100644 --- a/src/layout.rs +++ b/src/layout.rs @@ -136,8 +136,8 @@ impl Layout { match self.mesh.weight(head_around) { Weight::Dot(..) => self.dot_guidecircle(*head_around.as_dot().unwrap(), width + 5.0, conditions), + Weight::Seg(..) => unreachable!(), Weight::Bend(..) => self.bend_guidecircle(*head_around.as_bend().unwrap(), width, conditions), - Weight::Seg(..) | Weight::EndRef(..) | Weight::AroundRef(..) => unreachable!(), } }, None => Circle { @@ -196,10 +196,10 @@ impl Layout { let bend_weight = self.mesh.bend_weight(bend); let around = self.mesh.around(bend); - let fixed_dot: TaggedIndex = self.mesh.ends(TaggedIndex::Bend(bend)) + let fixed_dot: DotIndex = self.mesh.ends(TaggedIndex::Bend(bend)) .into_iter() - .filter(|neighbor| *neighbor != TaggedIndex::Dot(head.dot)) - .collect::>()[0]; + .filter(|neighbor| {*neighbor != head.dot}) + .collect::>()[0]; self.mesh.remove_bend(bend); self.mesh.remove_dot(head.dot); @@ -212,7 +212,7 @@ impl Layout { }, }); - self.mesh.add_bend(*fixed_dot.as_dot().unwrap(), new_dot, around, bend_weight); + self.mesh.add_bend(fixed_dot, new_dot, around, bend_weight); head } diff --git a/src/main.rs b/src/main.rs index 3b4e47e..f6f0f69 100644 --- a/src/main.rs +++ b/src/main.rs @@ -151,7 +151,6 @@ fn main() { } }, - Weight::EndRef(..) | Weight::AroundRef(..) => unreachable!(), } } diff --git a/src/mesh.rs b/src/mesh.rs index 0d22a23..445a9f6 100644 --- a/src/mesh.rs +++ b/src/mesh.rs @@ -1,12 +1,12 @@ use std::marker::PhantomData; use enum_as_inner::EnumAsInner; -use petgraph::stable_graph::{StableUnGraph, NodeIndex, EdgeIndex}; +use petgraph::stable_graph::{StableDiGraph, NodeIndex, EdgeIndex}; use petgraph::visit::EdgeRef; use rstar::{RTree, RTreeObject, AABB}; use rstar::primitives::GeomWithData; use crate::primitive::Primitive; -use crate::weight::{Weight, DotWeight, SegWeight, BendWeight, EndRefWeight, AroundRefWeight}; +use crate::weight::{Weight, DotWeight, SegWeight, BendWeight, Label}; #[derive(Debug, Copy, Clone, PartialEq)] @@ -36,7 +36,7 @@ impl Tag for DotIndex { } } -pub type SegIndex = Index, SegWeight>; +pub type SegIndex = Index, SegWeight>; impl Tag for SegIndex { fn tag(&self) -> TaggedIndex { @@ -52,51 +52,33 @@ impl Tag for BendIndex { } } -pub type EndRefIndex = Index, EndRefWeight>; - -impl Tag for EndRefIndex { - fn tag(&self) -> TaggedIndex { - TaggedIndex::EndRef(*self) - } -} - -pub type AroundRefIndex = Index, AroundRefWeight>; - -impl Tag for AroundRefIndex { - fn tag(&self) -> TaggedIndex { - TaggedIndex::AroundRef(*self) - } -} - #[derive(Debug, EnumAsInner, Copy, Clone, PartialEq)] pub enum TaggedIndex { Dot(DotIndex), Seg(SegIndex), Bend(BendIndex), - EndRef(EndRefIndex), - AroundRef(AroundRefIndex), } pub type RTreeWrapper = GeomWithData; pub struct Mesh { pub rtree: RTree, - pub graph: StableUnGraph, + pub graph: StableDiGraph, } impl Mesh { pub fn new() -> Self { return Mesh { rtree: RTree::new(), - graph: StableUnGraph::default(), + graph: StableDiGraph::default(), } } pub fn add_dot(&mut self, weight: DotWeight) -> DotIndex { - let dot_index = DotIndex::new(self.graph.add_node(Weight::Dot(weight))); - let index = TaggedIndex::Dot(dot_index); + let dot = DotIndex::new(self.graph.add_node(Weight::Dot(weight))); + let index = TaggedIndex::Dot(dot); self.rtree.insert(RTreeWrapper::new(self.primitive(index), index)); - dot_index + dot } pub fn remove_dot(&mut self, dot: DotIndex) { @@ -105,33 +87,34 @@ impl Mesh { } pub fn add_seg(&mut self, from: DotIndex, to: DotIndex, weight: SegWeight) -> SegIndex { - let seg_index = SegIndex::new(self.graph.add_edge(from.index, to.index, Weight::Seg(weight))); - let index = TaggedIndex::Seg(seg_index); + let seg = SegIndex::new(self.graph.add_node(Weight::Seg(weight))); + self.graph.add_edge(seg.index, from.index, Label::End); + self.graph.add_edge(seg.index, to.index, Label::End); + + let index = TaggedIndex::Seg(seg); self.rtree.insert(RTreeWrapper::new(self.primitive(index), index)); - seg_index + seg + } pub fn remove_seg(&mut self, seg: SegIndex) { self.rtree.remove(&RTreeWrapper::new(self.primitive(TaggedIndex::Seg(seg)), TaggedIndex::Seg(seg))); - self.graph.remove_edge(seg.index); + self.graph.remove_node(seg.index); } pub fn add_bend(&mut self, from: DotIndex, to: DotIndex, around: TaggedIndex, weight: BendWeight) -> BendIndex { let bend = BendIndex::new(self.graph.add_node(Weight::Bend(weight))); - self.graph.add_edge(from.index, bend.index, Weight::EndRef(EndRefWeight {})); - self.graph.add_edge(bend.index, to.index, Weight::EndRef(EndRefWeight {})); + self.graph.add_edge(bend.index, from.index, Label::End); + self.graph.add_edge(bend.index, to.index, Label::End); match around { TaggedIndex::Dot(DotIndex {index: around_index, ..}) => { - self.graph.add_edge(bend.index, around_index, Weight::AroundRef(AroundRefWeight {})); + self.graph.add_edge(bend.index, around_index, Label::Around); }, + TaggedIndex::Seg(..) => unreachable!(), TaggedIndex::Bend(BendIndex {index: around_index, ..}) => { - self.graph.add_edge(bend.index, around_index, Weight::AroundRef(AroundRefWeight {})); + self.graph.add_edge(bend.index, around_index, Label::Around); }, - TaggedIndex::Seg(..) - | TaggedIndex::EndRef(..) - | TaggedIndex::AroundRef(..) => - unreachable!(), } let index = TaggedIndex::Bend(bend); @@ -154,7 +137,7 @@ impl Mesh { dot_neighbor_weights: self.ends(index) .into_iter() - .map(|index| *self.weight(index).as_dot().unwrap()) + .map(|index| self.dot_weight(index)) .collect(), around_weight: match index { TaggedIndex::Bend(bend) => Some(self.weight(self.around(bend))), @@ -186,37 +169,28 @@ impl Mesh { for neighbor in self.graph.neighbors(bend.index) { let edge = self.graph.find_edge(bend.index, neighbor).unwrap(); - if self.graph.edge_weight(edge).unwrap().is_around_ref() { + if self.graph.edge_weight(edge).unwrap().is_around() { return match self.graph.node_weight(neighbor).unwrap() { Weight::Dot(dot) => DotIndex::new(neighbor).tag(), Weight::Bend(bend) => BendIndex::new(neighbor).tag(), - Weight::Seg(..) - | Weight::EndRef(..) - | Weight::AroundRef(..) => - unreachable!(), + Weight::Seg(seg) => SegIndex::new(neighbor).tag(), } } } unreachable!(); } - pub fn ends(&self, index: TaggedIndex) -> Vec { + pub fn ends(&self, index: TaggedIndex) -> Vec { match index { TaggedIndex::Dot(DotIndex {index: node, ..}) - | TaggedIndex::Bend(BendIndex {index: node, ..}) => + | TaggedIndex::Seg(SegIndex {index: node, ..}) + | TaggedIndex::Bend(BendIndex {index: node, ..}) => { self.graph.neighbors(node) + .filter(|ni| self.graph.edge_weight(self.graph.find_edge(node, *ni).unwrap()).unwrap().is_end()) .filter(|ni| self.graph.node_weight(*ni).unwrap().is_dot()) - .filter(|ni| self.graph.edge_weight(self.graph.find_edge(node, *ni).unwrap()).unwrap().is_end_ref()) - .map(|ni| TaggedIndex::Dot(Index::new(ni))) - .collect(), - TaggedIndex::Seg(SegIndex {index: edge, ..}) => { - let endpoints = self.graph.edge_endpoints(edge).unwrap(); - vec![TaggedIndex::Dot(DotIndex::new(endpoints.0)), - TaggedIndex::Dot(DotIndex::new(endpoints.1))] - }, - TaggedIndex::EndRef(..) - | TaggedIndex::AroundRef(..) => - unreachable!(), + .map(|ni| DotIndex::new(ni)) + .collect() + } } } @@ -235,13 +209,9 @@ impl Mesh { pub fn weight(&self, index: TaggedIndex) -> Weight { match index { TaggedIndex::Dot(DotIndex {index: node, ..}) + | TaggedIndex::Seg(SegIndex {index: node, ..}) | TaggedIndex::Bend(BendIndex {index: node, ..}) => *self.graph.node_weight(node).unwrap(), - TaggedIndex::Seg(SegIndex {index: edge, ..}) => - *self.graph.edge_weight(edge).unwrap(), - TaggedIndex::EndRef(..) - | TaggedIndex::AroundRef(..) => - unreachable!(), } } } diff --git a/src/primitive.rs b/src/primitive.rs index ce78d09..213249d 100644 --- a/src/primitive.rs +++ b/src/primitive.rs @@ -28,7 +28,6 @@ impl Primitive { .collect(); return AABB::<[f64; 2]>::from_points(&points); }, - Weight::EndRef(..) | Weight::AroundRef(..) => unreachable!(), } } @@ -43,7 +42,6 @@ impl Primitive { r, }) } - Weight::EndRef(..) | Weight::AroundRef(..) => unreachable!(), } } @@ -52,7 +50,6 @@ impl Primitive { Weight::Dot(dot) => dot.circle.r * 2.0, Weight::Seg(seg) => seg.width, Weight::Bend(bend) => self.dot_neighbor_weights[0].circle.r * 2.0, - Weight::EndRef(..) | Weight::AroundRef(..) => unreachable!(), } } diff --git a/src/weight.rs b/src/weight.rs index ad0f6df..d07f191 100644 --- a/src/weight.rs +++ b/src/weight.rs @@ -1,5 +1,5 @@ use enum_as_inner::EnumAsInner; -use crate::{math::Circle, mesh::{DotIndex, TaggedIndex}}; +use crate::math::Circle; #[derive(Debug, Clone, Copy, PartialEq)] pub struct DotWeight { @@ -19,19 +19,15 @@ pub struct SegWeight { pub width: f64, } -#[derive(Debug, Clone, Copy, PartialEq)] -pub struct EndRefWeight { -} - -#[derive(Debug, Clone, Copy, PartialEq)] -pub struct AroundRefWeight { -} - #[derive(Debug, EnumAsInner, Clone, Copy, PartialEq)] pub enum Weight { Dot(DotWeight), Seg(SegWeight), Bend(BendWeight), - EndRef(EndRefWeight), - AroundRef(AroundRefWeight), +} + +#[derive(Debug, EnumAsInner, Clone, Copy, PartialEq)] +pub enum Label { + End, + Around, }