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

Store all relevant indexes as neighbors instead of in weights

This commit is contained in:
Mikolaj Wielgus 2023-07-15 13:44:02 +02:00
parent 26112724c7
commit b5f85068df
3 changed files with 84 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/layout.rs
View File

@ -3,7 +3,7 @@ use std::rc::Rc;
use geo::geometry::Point; use geo::geometry::Point;
use crate::math::Circle; use crate::math::Circle;
use crate::mesh::{Mesh, TaggedIndex, RTreeWrapper, DotIndex, SegIndex, BendIndex}; use crate::mesh::{Mesh, TaggedIndex, RTreeWrapper, DotIndex, SegIndex, BendIndex, Tag};
use crate::rules::{Rules, Conditions}; use crate::rules::{Rules, Conditions};
use crate::primitive::Primitive; use crate::primitive::Primitive;
use crate::weight::{Weight, DotWeight, SegWeight, BendWeight}; use crate::weight::{Weight, DotWeight, SegWeight, BendWeight};
@ -98,12 +98,12 @@ impl Layout {
let net = self.mesh.dot_weight(head.dot).net; let net = self.mesh.dot_weight(head.dot).net;
let mut layer = around; let mut layer = around;
while let TaggedIndex::Bend(..) = layer { while let TaggedIndex::Bend(layer_bend) = layer {
layer = self.mesh.weight(layer).as_bend().unwrap().around; layer = self.mesh.around(layer_bend)
} }
let center = *layer.as_dot().unwrap(); let center = *layer.as_dot().unwrap();
let bend = self.mesh.add_bend(head.dot, bend_to, BendWeight {net, around, center, cw}); let bend = self.mesh.add_bend(head.dot, bend_to, around, BendWeight {net, cw});
Head {dot: bend_to, bend: Some(bend)} Head {dot: bend_to, bend: Some(bend)}
} }
@ -132,7 +132,7 @@ impl Layout {
match maybe_bend { match maybe_bend {
Some(bend) => { Some(bend) => {
let head_around = self.mesh.bend_weight(bend).around; let head_around = self.mesh.around(bend);
match self.mesh.weight(head_around) { match self.mesh.weight(head_around) {
Weight::Dot(..) => self.dot_guidecircle(*head_around.as_dot().unwrap(), width + 5.0, conditions), Weight::Dot(..) => self.dot_guidecircle(*head_around.as_dot().unwrap(), width + 5.0, conditions),
@ -166,8 +166,8 @@ impl Layout {
let mut layer = TaggedIndex::Bend(bend); let mut layer = TaggedIndex::Bend(bend);
let mut r = width + self.rules.ruleset(conditions).clearance.min; let mut r = width + self.rules.ruleset(conditions).clearance.min;
while let TaggedIndex::Bend(..) = layer { while let TaggedIndex::Bend(layer_bend) = layer {
layer = self.mesh.weight(layer).as_bend().unwrap().around; layer = self.mesh.around(layer_bend);
r += 5.0 + self.mesh.primitive(layer).width(); r += 5.0 + self.mesh.primitive(layer).width();
} }
@ -194,8 +194,9 @@ impl Layout {
let bend = head.bend.unwrap(); let bend = head.bend.unwrap();
let dot_weight = self.mesh.dot_weight(head.dot); let dot_weight = self.mesh.dot_weight(head.dot);
let bend_weight = self.mesh.bend_weight(bend); let bend_weight = self.mesh.bend_weight(bend);
let around = self.mesh.around(bend);
let fixed_dot: TaggedIndex = self.mesh.neighboring_dots(TaggedIndex::Bend(bend)) let fixed_dot: TaggedIndex = self.mesh.ends(TaggedIndex::Bend(bend))
.into_iter() .into_iter()
.filter(|neighbor| *neighbor != TaggedIndex::Dot(head.dot)) .filter(|neighbor| *neighbor != TaggedIndex::Dot(head.dot))
.collect::<Vec<TaggedIndex>>()[0]; .collect::<Vec<TaggedIndex>>()[0];
@ -210,7 +211,8 @@ impl Layout {
r: dot_weight.circle.r, r: dot_weight.circle.r,
}, },
}); });
self.mesh.add_bend(*fixed_dot.as_dot().unwrap(), new_dot, bend_weight);
self.mesh.add_bend(*fixed_dot.as_dot().unwrap(), new_dot, around, bend_weight);
head head
} }

101
src/mesh.rs
View File

@ -116,14 +116,27 @@ impl Mesh {
self.graph.remove_edge(seg.index); self.graph.remove_edge(seg.index);
} }
pub fn add_bend(&mut self, from: DotIndex, to: DotIndex, weight: BendWeight) -> BendIndex { pub fn add_bend(&mut self, from: DotIndex, to: DotIndex, around: TaggedIndex, weight: BendWeight) -> BendIndex {
let bend_index = BendIndex::new(self.graph.add_node(Weight::Bend(weight))); let bend = BendIndex::new(self.graph.add_node(Weight::Bend(weight)));
self.graph.add_edge(from.index, bend_index.index, Weight::EndRef(EndRefWeight {})); self.graph.add_edge(from.index, bend.index, Weight::EndRef(EndRefWeight {}));
self.graph.add_edge(bend_index.index, to.index, Weight::EndRef(EndRefWeight {})); self.graph.add_edge(bend.index, to.index, Weight::EndRef(EndRefWeight {}));
let index = TaggedIndex::Bend(bend_index); match around {
TaggedIndex::Dot(DotIndex {index: around_index, ..}) => {
self.graph.add_edge(bend.index, around_index, Weight::AroundRef(AroundRefWeight {}));
},
TaggedIndex::Bend(BendIndex {index: around_index, ..}) => {
self.graph.add_edge(bend.index, around_index, Weight::AroundRef(AroundRefWeight {}));
},
TaggedIndex::Seg(..)
| TaggedIndex::EndRef(..)
| TaggedIndex::AroundRef(..) =>
unreachable!(),
}
let index = TaggedIndex::Bend(bend);
self.rtree.insert(RTreeWrapper::new(self.primitive(index), index)); self.rtree.insert(RTreeWrapper::new(self.primitive(index), index));
bend_index bend
} }
pub fn remove_bend(&mut self, bend: BendIndex) { pub fn remove_bend(&mut self, bend: BendIndex) {
@ -139,43 +152,71 @@ impl Mesh {
Primitive { Primitive {
weight: self.weight(index), weight: self.weight(index),
dot_neighbor_weights: dot_neighbor_weights:
self.neighboring_dots(index) self.ends(index)
.into_iter() .into_iter()
.map(|index| *self.weight(index).as_dot().unwrap()) .map(|index| *self.weight(index).as_dot().unwrap())
.collect(), .collect(),
around_weight: match index { around_weight: match index {
TaggedIndex::Bend(bend_index) => { TaggedIndex::Bend(bend) => Some(self.weight(self.around(bend))),
Some(self.weight((*self.weight(index).as_bend().unwrap()).around))
},
_ => None, _ => None,
}, },
focus: match index { focus: match index {
TaggedIndex::Bend(bend_index) => { TaggedIndex::Bend(bend) => {
let mut layer = index; let mut layer = index;
while let TaggedIndex::Bend(..) = layer { while let TaggedIndex::Bend(layer_bend) = layer {
layer = self.weight(layer).as_bend().unwrap().around; layer = self.around(layer_bend)
} }
Some(self.weight(layer).as_dot().unwrap().circle.pos) Some(self.weight(layer).as_dot().unwrap().circle.pos)
}, },
_ => None, _ => None,
} },
} }
} }
pub fn neighboring_dots(&self, index: TaggedIndex) -> Vec<TaggedIndex> { /*pub fn focus(&self, bend: BendIndex) -> DotIndex {
let mut layer = bend.tag();
while let TaggedIndex::Bend(bend) = layer {
layer = self.around(layer).unwrap();
}
*layer.as_dot().unwrap()
}*/
pub fn around(&self, bend: BendIndex) -> TaggedIndex {
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() {
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!(),
}
}
}
unreachable!();
}
pub fn ends(&self, index: TaggedIndex) -> Vec<TaggedIndex> {
match index { match index {
TaggedIndex::Dot(DotIndex {index: node_index, ..}) TaggedIndex::Dot(DotIndex {index: node, ..})
| TaggedIndex::Bend(BendIndex {index: node_index, ..}) => | TaggedIndex::Bend(BendIndex {index: node, ..}) =>
return self.graph.neighbors(node_index) self.graph.neighbors(node)
.filter(|ni| self.graph.node_weight(*ni).unwrap().as_dot().is_some()) .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))) .map(|ni| TaggedIndex::Dot(Index::new(ni)))
.collect(), .collect(),
TaggedIndex::Seg(SegIndex {index: edge_index, ..}) => { TaggedIndex::Seg(SegIndex {index: edge, ..}) => {
let endpoints = self.graph.edge_endpoints(edge_index).unwrap(); let endpoints = self.graph.edge_endpoints(edge).unwrap();
return vec![TaggedIndex::Dot(DotIndex::new(endpoints.0)), vec![TaggedIndex::Dot(DotIndex::new(endpoints.0)),
TaggedIndex::Dot(DotIndex::new(endpoints.1))] TaggedIndex::Dot(DotIndex::new(endpoints.1))]
}, },
TaggedIndex::EndRef(..) | TaggedIndex::AroundRef(..) => unreachable!(), TaggedIndex::EndRef(..)
| TaggedIndex::AroundRef(..) =>
unreachable!(),
} }
} }
@ -193,12 +234,14 @@ impl Mesh {
pub fn weight(&self, index: TaggedIndex) -> Weight { pub fn weight(&self, index: TaggedIndex) -> Weight {
match index { match index {
TaggedIndex::Dot(DotIndex {index: node_index, ..}) TaggedIndex::Dot(DotIndex {index: node, ..})
| TaggedIndex::Bend(BendIndex {index: node_index, ..}) => | TaggedIndex::Bend(BendIndex {index: node, ..}) =>
*self.graph.node_weight(node_index).unwrap(), *self.graph.node_weight(node).unwrap(),
TaggedIndex::Seg(SegIndex {index: edge_index, ..}) => TaggedIndex::Seg(SegIndex {index: edge, ..}) =>
*self.graph.edge_weight(edge_index).unwrap(), *self.graph.edge_weight(edge).unwrap(),
TaggedIndex::EndRef(..) | TaggedIndex::AroundRef(..) => unreachable!(), TaggedIndex::EndRef(..)
| TaggedIndex::AroundRef(..) =>
unreachable!(),
} }
} }
} }

2
src/weight.rs
View File

@ -10,8 +10,6 @@ pub struct DotWeight {
#[derive(Debug, Clone, Copy, PartialEq)] #[derive(Debug, Clone, Copy, PartialEq)]
pub struct BendWeight { pub struct BendWeight {
pub net: i32, pub net: i32,
pub around: TaggedIndex,
pub center: DotIndex,
pub cw: bool, pub cw: bool,
} }