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

primitive,layout: Remove methods that assume order 

There's should be no previous or next primitive, only this end and the
other end.
This commit is contained in:
Mikolaj Wielgus 2023-10-24 05:04:38 +00:00
parent aaad590870
commit cedc2253ca
5 changed files with 35 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/bow.rs
View File

@ -20,13 +20,13 @@ impl Bow {
pub fn from_bend(index: FixedBendIndex, graph: &StableDiGraph<Weight, Label, usize>) -> Self {
let bend = index;
let seg1_dot2 = FixedBend::new(bend, graph).prev().unwrap();
let seg1_dot2 = FixedBend::new(bend, graph).ends().0;
let seg1 = FixedDot::new(seg1_dot2, graph).seg().unwrap();
let seg1_dot1 = FixedSeg::new(seg1, graph).prev().unwrap();
let seg1_dot1 = FixedSeg::new(seg1, graph).other_end(seg1_dot2);
let seg2_dot1 = FixedBend::new(bend, graph).next().unwrap();
let seg2_dot1 = FixedBend::new(bend, graph).ends().1;
let seg2 = FixedDot::new(seg2_dot1, graph).seg().unwrap();
let seg2_dot2 = FixedSeg::new(seg2, graph).next().unwrap();
let seg2_dot2 = FixedSeg::new(seg2, graph).other_end(seg2_dot1);
Self {
seg1_dot1,

36
src/draw.rs
View File

@ -61,7 +61,7 @@ impl<'a> Draw<'a> {
}
pub fn start(&mut self, from: FixedDotIndex) -> Head {
self.prev_head(from)
self.head(from)
}
#[debug_ensures(ret.is_ok() -> self.layout.node_count() == old(self.layout.node_count() + 1))]
@ -98,7 +98,7 @@ impl<'a> Draw<'a> {
into: FixedDotIndex,
width: f64,
) -> Result<(), ()> {
let to_head = self.next_head(into);
let to_head = self.head(into);
let to_cw = self.guide(&Default::default()).head_cw(&to_head).unwrap();
let tangent = self
.guide(&Default::default())
@ -272,15 +272,15 @@ impl<'a> Draw<'a> {
#[debug_ensures(ret.is_some() -> self.layout.node_count() == old(self.layout.node_count() - 4))]
#[debug_ensures(ret.is_none() -> self.layout.node_count() == old(self.layout.node_count()))]
pub fn undo_segbend(&mut self, head: SegbendHead) -> Option<Head> {
self.layout
.primitive(head.segbend.ends().0)
.prev()
.map(|prev_dot| {
self.layout.remove_interior(&head.segbend);
self.layout.remove(head.dot().into());
let prev_dot = self
.layout
.primitive(head.segbend.seg)
.other_end(head.segbend.dot);
self.prev_head(prev_dot)
})
self.layout.remove_interior(&head.segbend);
self.layout.remove(head.dot().into());
Some(self.head(prev_dot))
}
#[debug_requires(width <= self.layout.primitive(head.dot()).weight().circle.r * 2.0)]
@ -311,19 +311,11 @@ impl<'a> Draw<'a> {
self.layout.remove(head.dot.into());
}
fn prev_head(&self, dot: FixedDotIndex) -> Head {
if let Some(segbend) = self.layout.prev_segbend(dot) {
Head::from(SegbendHead { dot, segbend })
fn head(&self, dot: FixedDotIndex) -> Head {
if let Some(segbend) = self.layout.segbend(dot) {
SegbendHead { dot, segbend }.into()
} else {
Head::from(BareHead { dot })
}
}
fn next_head(&self, dot: FixedDotIndex) -> Head {
if let Some(segbend) = self.layout.next_segbend(dot) {
Head::from(SegbendHead { dot, segbend })
} else {
Head::from(BareHead { dot })
BareHead { dot }.into()
}
}

16
src/layout.rs
View File

@ -328,22 +328,10 @@ impl Layout {
Bow::from_bend(bend, &self.graph)
}
pub fn prev_segbend(&self, dot: FixedDotIndex) -> Option<Segbend> {
Segbend::from_dot_prev(dot, &self.graph)
pub fn segbend(&self, dot: FixedDotIndex) -> Option<Segbend> {
Segbend::from_dot(dot, &self.graph)
}
pub fn next_segbend(&self, dot: FixedDotIndex) -> Option<Segbend> {
Segbend::from_dot_next(dot, &self.graph)
}
/*pub fn prev_band(&self, to: FixedDotIndex) -> Option<Band> {
Band::from_dot_prev(to, &self.graph)
}
pub fn next_band(&self, from: FixedDotIndex) -> Option<Band> {
Band::from_dot_next(from, &self.graph)
}*/
#[debug_ensures(ret.is_ok() -> self.graph.node_count() == old(self.graph.node_count()))]
#[debug_ensures(ret.is_ok() -> self.graph.edge_count() == old(self.graph.edge_count()))]
#[debug_ensures(ret.is_err() -> self.graph.node_count() == old(self.graph.node_count() - 1))]

48
src/primitive.rs
View File

@ -66,30 +66,6 @@ impl<'a, W> GenericPrimitive<'a, W> {
.map(|index| self.graph.node_weight(index).unwrap().retag(index))
}
fn prev_node(&self) -> Option<NodeIndex<usize>> {
self.graph
.neighbors_directed(self.index.node_index(), Incoming)
.filter(|ni| {
self.graph
.edge_weight(self.graph.find_edge(*ni, self.index.node_index()).unwrap())
.unwrap()
.is_adjacent()
})
.next()
}
fn next_node(&self) -> Option<NodeIndex<usize>> {
self.graph
.neighbors_directed(self.index.node_index(), Outgoing)
.filter(|ni| {
self.graph
.edge_weight(self.graph.find_edge(self.index.node_index(), *ni).unwrap())
.unwrap()
.is_adjacent()
})
.next()
}
pub fn core(&self) -> Option<FixedDotIndex> {
self.graph
.neighbors(self.index.node_index())
@ -257,12 +233,12 @@ impl<'a> MakeShape for LooseDot<'a> {
pub type FixedSeg<'a> = GenericPrimitive<'a, FixedSegWeight>;
impl<'a> FixedSeg<'a> {
pub fn next(&self) -> Option<FixedDotIndex> {
self.next_node().map(|ni| FixedDotIndex::new(ni))
}
pub fn prev(&self) -> Option<FixedDotIndex> {
self.prev_node().map(|ni| FixedDotIndex::new(ni))
pub fn other_end(&self, dot: FixedDotIndex) -> FixedDotIndex {
let ends = self.ends();
[ends.0, ends.1]
.into_iter()
.find(|end| end.node_index() != dot.node_index())
.unwrap()
}
}
@ -358,12 +334,12 @@ impl<'a> FixedBend<'a> {
.next()
}
pub fn next(&self) -> Option<FixedDotIndex> {
self.next_node().map(|ni| FixedDotIndex::new(ni))
}
pub fn prev(&self) -> Option<FixedDotIndex> {
self.prev_node().map(|ni| FixedDotIndex::new(ni))
pub fn other_end(&self, dot: FixedDotIndex) -> FixedDotIndex {
let ends = self.ends();
[ends.0, ends.1]
.into_iter()
.find(|end| end.node_index() != dot.node_index())
.unwrap()
}
fn inner_radius(&self) -> f64 {

20
src/segbend.rs
View File

@ -13,27 +13,13 @@ pub struct Segbend {
}
impl Segbend {
pub fn new(bend: FixedBendIndex, dot: FixedDotIndex, seg: FixedSegIndex) -> Self {
Self { seg, dot, bend }
}
pub fn from_dot_prev(
pub fn from_dot(
dot: FixedDotIndex,
graph: &StableDiGraph<Weight, Label, usize>,
) -> Option<Self> {
let bend = FixedDot::new(dot, graph).bend()?;
let dot = FixedBend::new(bend, graph).prev().unwrap();
let seg = FixedDot::new(dot, graph).seg().unwrap();
Some(Self { bend, dot, seg })
}
pub fn from_dot_next(
dot: FixedDotIndex,
graph: &StableDiGraph<Weight, Label, usize>,
) -> Option<Self> {
let bend = FixedDot::new(dot, graph).bend()?;
let dot = FixedBend::new(bend, graph).next().unwrap();
let seg = FixedDot::new(dot, graph).seg().unwrap();
let dot = FixedBend::new(bend, graph).other_end(dot);
let seg = FixedDot::new(dot, graph).seg()?;
Some(Self { bend, dot, seg })
}
}