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

layout: alias `Node` to not require generic parameters

This commit is contained in:
Mikolaj Wielgus 2024-04-17 21:06:55 +02:00
parent 4c8f7cb804
commit f2569c5167
7 changed files with 80 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/bin/topola-egui/app.rs
View File

@ -10,7 +10,7 @@ use topola::{
dsn::{design::DsnDesign, rules::DsnRules},
geometry::{
primitive::{BendShape, DotShape, PrimitiveShape, SegShape},
Node,
GenericNode,
},
layout::{zone::MakePolygon, Layout},
math::Circle,
@ -154,7 +154,11 @@ impl eframe::App for App {
for node in layout.drawing().layer_primitive_nodes(1) {
let shape = node.primitive(layout.drawing()).shape();
let color = if self.overlay.selection().contains(&Node::Primitive(node)) {
let color = if self
.overlay
.selection()
.contains(&GenericNode::Primitive(node))
{
egui::Color32::from_rgb(100, 100, 255)
} else {
egui::Color32::from_rgb(52, 52, 200)
@ -172,7 +176,11 @@ impl eframe::App for App {
for node in layout.drawing().layer_primitive_nodes(0) {
let shape = node.primitive(layout.drawing()).shape();
let color = if self.overlay.selection().contains(&Node::Primitive(node)) {
let color = if self
.overlay
.selection()
.contains(&GenericNode::Primitive(node))
{
egui::Color32::from_rgb(255, 100, 100)
} else {
egui::Color32::from_rgb(200, 52, 52)

12
src/drawing/drawing.rs
View File

@ -29,7 +29,7 @@ use crate::drawing::{
};
use crate::geometry::compound::CompoundManagerTrait;
use crate::geometry::with_rtree::BboxedIndex;
use crate::geometry::Node;
use crate::geometry::GenericNode;
use crate::geometry::{
primitive::{PrimitiveShape, PrimitiveShapeTrait},
with_rtree::GeometryWithRtree,
@ -639,7 +639,7 @@ impl<CW: Copy, R: RulesTrait> Drawing<CW, R> {
.rtree()
.iter()
.filter_map(|wrapper| {
if let Node::Primitive(primitive_node) = wrapper.data {
if let GenericNode::Primitive(primitive_node) = wrapper.data {
Some(primitive_node)
} else {
None
@ -655,7 +655,7 @@ impl<CW: Copy, R: RulesTrait> Drawing<CW, R> {
[f64::INFINITY, f64::INFINITY, layer as f64],
))
.filter_map(|wrapper| {
if let Node::Primitive(primitive_node) = wrapper.data {
if let GenericNode::Primitive(primitive_node) = wrapper.data {
Some(primitive_node)
} else {
None
@ -750,7 +750,7 @@ impl<CW: Copy, R: RulesTrait> Drawing<CW, R> {
.rtree()
.locate_in_envelope_intersecting(&limiting_shape.full_height_envelope_3d(0.0, 2))
.filter_map(|wrapper| {
if let Node::Primitive(primitive_node) = wrapper.data {
if let GenericNode::Primitive(primitive_node) = wrapper.data {
Some(primitive_node)
} else {
None
@ -785,7 +785,7 @@ impl<CW: Copy, R: RulesTrait> Drawing<CW, R> {
.rtree()
.locate_in_envelope_intersecting(&shape.full_height_envelope_3d(0.0, 2))
.filter_map(|wrapper| {
if let Node::Primitive(primitive_node) = wrapper.data {
if let GenericNode::Primitive(primitive_node) = wrapper.data {
Some(primitive_node)
} else {
None
@ -833,7 +833,7 @@ impl<CW: Copy, R: RulesTrait> Drawing<CW, R> {
#[debug_ensures(self.geometry_with_rtree.graph().node_count() == old(self.geometry_with_rtree.graph().node_count()))]
#[debug_ensures(self.geometry_with_rtree.graph().edge_count() == old(self.geometry_with_rtree.graph().edge_count()))]
pub fn rtree(&self) -> &RTree<BboxedIndex<Node<PrimitiveIndex, GenericIndex<CW>>>> {
pub fn rtree(&self) -> &RTree<BboxedIndex<GenericNode<PrimitiveIndex, GenericIndex<CW>>>> {
self.geometry_with_rtree.rtree()
}

14
src/drawing/primitive.rs
View File

@ -20,7 +20,7 @@ use crate::{
},
Drawing,
},
geometry::Node,
geometry::GenericNode,
};
#[enum_dispatch]
@ -186,7 +186,7 @@ impl<'a, W, CW: Copy, R: RulesTrait> GenericPrimitive<'a, W, CW, R> {
}
fn tagged_weight(&self) -> PrimitiveWeight {
if let Node::Primitive(weight) = *self
if let GenericNode::Primitive(weight) = *self
.drawing
.geometry()
.graph()
@ -262,9 +262,15 @@ impl<'a, CW: Copy, R: RulesTrait> FixedDot<'a, CW, R> {
.graph()
.node_weight(ni.node_index())
.unwrap();
if matches!(weight, Node::Primitive(PrimitiveWeight::LoneLooseSeg(..))) {
if matches!(
weight,
GenericNode::Primitive(PrimitiveWeight::LoneLooseSeg(..))
) {
Some(LoneLooseSegIndex::new(ni.node_index()).into())
} else if matches!(weight, Node::Primitive(PrimitiveWeight::SeqLooseSeg(..))) {
} else if matches!(
weight,
GenericNode::Primitive(PrimitiveWeight::SeqLooseSeg(..))
) {
Some(SeqLooseSegIndex::new(ni.node_index()).into())
} else {
None

28
src/geometry/geometry.rs
View File

@ -59,7 +59,7 @@ pub enum GeometryLabel {
}
#[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)]
pub enum Node<P, C> {
pub enum GenericNode<P, C> {
Primitive(P),
Compound(C),
}
@ -80,7 +80,7 @@ pub struct Geometry<
SI: GetNodeIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy,
> {
graph: StableDiGraph<Node<PW, CW>, GeometryLabel, usize>,
graph: StableDiGraph<GenericNode<PW, CW>, GeometryLabel, usize>,
weight_marker: PhantomData<PW>,
dot_weight_marker: PhantomData<DW>,
seg_weight_marker: PhantomData<SW>,
@ -120,7 +120,7 @@ impl<
}
pub fn add_dot<W: DotWeightTrait<PW>>(&mut self, weight: W) -> GenericIndex<W> {
GenericIndex::<W>::new(self.graph.add_node(Node::Primitive(weight.into())))
GenericIndex::<W>::new(self.graph.add_node(GenericNode::Primitive(weight.into())))
}
pub fn add_seg<W: SegWeightTrait<PW>>(
@ -129,7 +129,8 @@ impl<
to: DI,
weight: W,
) -> GenericIndex<W> {
let seg = GenericIndex::<W>::new(self.graph.add_node(Node::Primitive(weight.into())));
let seg =
GenericIndex::<W>::new(self.graph.add_node(GenericNode::Primitive(weight.into())));
self.graph
.update_edge(from.node_index(), seg.node_index(), GeometryLabel::Joined);
@ -146,7 +147,8 @@ impl<
core: DI,
weight: W,
) -> GenericIndex<W> {
let bend = GenericIndex::<W>::new(self.graph.add_node(Node::Primitive(weight.into())));
let bend =
GenericIndex::<W>::new(self.graph.add_node(GenericNode::Primitive(weight.into())));
self.graph
.update_edge(from.node_index(), bend.node_index(), GeometryLabel::Joined);
@ -165,13 +167,15 @@ impl<
pub fn move_dot(&mut self, dot: DI, to: Point) {
let mut weight = self.dot_weight(dot);
weight.set_pos(to);
*self.graph.node_weight_mut(dot.node_index()).unwrap() = Node::Primitive(weight.into());
*self.graph.node_weight_mut(dot.node_index()).unwrap() =
GenericNode::Primitive(weight.into());
}
pub fn shift_bend(&mut self, bend: BI, offset: f64) {
let mut weight = self.bend_weight(bend);
weight.set_offset(offset);
*self.graph.node_weight_mut(bend.node_index()).unwrap() = Node::Primitive(weight.into());
*self.graph.node_weight_mut(bend.node_index()).unwrap() =
GenericNode::Primitive(weight.into());
}
pub fn flip_bend(&mut self, bend: BI) {
@ -267,7 +271,7 @@ impl<
}
fn primitive_weight(&self, index: NodeIndex<usize>) -> PW {
if let Node::Primitive(weight) = *self.graph.node_weight(index).unwrap() {
if let GenericNode::Primitive(weight) = *self.graph.node_weight(index).unwrap() {
weight
} else {
unreachable!()
@ -293,7 +297,9 @@ impl<
}
pub fn compound_weight(&self, compound: GenericIndex<CW>) -> CW {
if let Node::Compound(weight) = *self.graph.node_weight(compound.node_index()).unwrap() {
if let GenericNode::Compound(weight) =
*self.graph.node_weight(compound.node_index()).unwrap()
{
weight
} else {
unreachable!()
@ -468,7 +474,7 @@ impl<
})
}
pub fn graph(&self) -> &StableDiGraph<Node<PW, CW>, GeometryLabel, usize> {
pub fn graph(&self) -> &StableDiGraph<GenericNode<PW, CW>, GeometryLabel, usize> {
&self.graph
}
}
@ -486,7 +492,7 @@ impl<
> CompoundManagerTrait<CW, GenericIndex<CW>> for Geometry<PW, DW, SW, BW, CW, PI, DI, SI, BI>
{
fn add_compound(&mut self, weight: CW) -> GenericIndex<CW> {
GenericIndex::<CW>::new(self.graph.add_node(Node::Compound(weight)))
GenericIndex::<CW>::new(self.graph.add_node(GenericNode::Compound(weight)))
}
fn remove_compound(&mut self, compound: GenericIndex<CW>) {

37
src/geometry/with_rtree.rs
View File

@ -10,7 +10,8 @@ use crate::{
geometry::{
compound::CompoundManagerTrait,
primitive::{PrimitiveShape, PrimitiveShapeTrait},
BendWeightTrait, DotWeightTrait, Geometry, GeometryLabel, GetWidth, Node, SegWeightTrait,
BendWeightTrait, DotWeightTrait, GenericNode, Geometry, GeometryLabel, GetWidth,
SegWeightTrait,
},
graph::{GenericIndex, GetNodeIndex},
};
@ -48,7 +49,7 @@ pub struct GeometryWithRtree<
BI: GetNodeIndex + Into<PI> + Copy,
> {
geometry: Geometry<PW, DW, SW, BW, CW, PI, DI, SI, BI>,
rtree: RTree<BboxedIndex<Node<PI, GenericIndex<CW>>>>,
rtree: RTree<BboxedIndex<GenericNode<PI, GenericIndex<CW>>>>,
layer_count: u64,
weight_marker: PhantomData<PW>,
dot_weight_marker: PhantomData<DW>,
@ -101,7 +102,7 @@ impl<
.dot_shape(dot.into().try_into().unwrap_or_else(|_| unreachable!()))
.envelope_3d(0.0, weight.layer()),
),
Node::Primitive(dot.into()),
GenericNode::Primitive(dot.into()),
));
dot
}
@ -122,7 +123,7 @@ impl<
.seg_shape(seg.into().try_into().unwrap_or_else(|_| unreachable!()))
.envelope_3d(0.0, weight.layer()),
),
Node::Primitive(seg.into()),
GenericNode::Primitive(seg.into()),
));
seg
}
@ -144,7 +145,7 @@ impl<
.bend_shape(bend.into().try_into().unwrap_or_else(|_| unreachable!()))
.envelope_3d(0.0, weight.layer()),
),
Node::Primitive(bend.into()),
GenericNode::Primitive(bend.into()),
));
bend
}
@ -264,7 +265,7 @@ impl<
BI: GetNodeIndex + Into<PI> + Copy,
> GeometryWithRtree<PW, DW, SW, BW, CW, PI, DI, SI, BI>
{
fn make_bbox(&self, primitive: PI) -> BboxedIndex<Node<PI, GenericIndex<CW>>> {
fn make_bbox(&self, primitive: PI) -> BboxedIndex<GenericNode<PI, GenericIndex<CW>>> {
if let Ok(dot) = <PI as TryInto<DI>>::try_into(primitive) {
self.make_dot_bbox(dot)
} else if let Ok(seg) = <PI as TryInto<SI>>::try_into(primitive) {
@ -276,50 +277,50 @@ impl<
}
}
fn make_dot_bbox(&self, dot: DI) -> BboxedIndex<Node<PI, GenericIndex<CW>>> {
fn make_dot_bbox(&self, dot: DI) -> BboxedIndex<GenericNode<PI, GenericIndex<CW>>> {
BboxedIndex::new(
Bbox::new(
self.geometry
.dot_shape(dot)
.envelope_3d(0.0, self.layer(dot.into())),
),
Node::Primitive(dot.into()),
GenericNode::Primitive(dot.into()),
)
}
fn make_seg_bbox(&self, seg: SI) -> BboxedIndex<Node<PI, GenericIndex<CW>>> {
fn make_seg_bbox(&self, seg: SI) -> BboxedIndex<GenericNode<PI, GenericIndex<CW>>> {
BboxedIndex::new(
Bbox::new(
self.geometry
.seg_shape(seg)
.envelope_3d(0.0, self.layer(seg.into())),
),
Node::Primitive(seg.into()),
GenericNode::Primitive(seg.into()),
)
}
fn make_bend_bbox(&self, bend: BI) -> BboxedIndex<Node<PI, GenericIndex<CW>>> {
fn make_bend_bbox(&self, bend: BI) -> BboxedIndex<GenericNode<PI, GenericIndex<CW>>> {
BboxedIndex::new(
Bbox::new(
self.geometry
.bend_shape(bend)
.envelope_3d(0.0, self.layer(bend.into())),
),
Node::Primitive(bend.into()),
GenericNode::Primitive(bend.into()),
)
}
fn make_compound_bbox(
&self,
compound: GenericIndex<CW>,
) -> BboxedIndex<Node<PI, GenericIndex<CW>>> {
) -> BboxedIndex<GenericNode<PI, GenericIndex<CW>>> {
let mut aabb = AABB::<[f64; 3]>::new_empty();
for member in self.geometry.compound_members(compound) {
aabb.merge(&self.make_bbox(member).geom().aabb);
}
BboxedIndex::new(Bbox::new(aabb), Node::Compound(compound))
BboxedIndex::new(Bbox::new(aabb), GenericNode::Compound(compound))
}
fn shape(&self, primitive: PI) -> PrimitiveShape {
@ -351,25 +352,25 @@ impl<
}
// XXX: The type appears wrong? I don't think it should contain CW?
pub fn rtree(&self) -> &RTree<BboxedIndex<Node<PI, GenericIndex<CW>>>> {
pub fn rtree(&self) -> &RTree<BboxedIndex<GenericNode<PI, GenericIndex<CW>>>> {
&self.rtree
}
pub fn graph(&self) -> &StableDiGraph<Node<PW, CW>, GeometryLabel, usize> {
pub fn graph(&self) -> &StableDiGraph<GenericNode<PW, CW>, GeometryLabel, usize> {
self.geometry.graph()
}
fn test_envelopes(&self) -> bool {
!self.rtree.iter().any(|wrapper| {
// TODO: Test envelopes of compounds too.
let Node::Primitive(primitive_node) = wrapper.data else {
let GenericNode::Primitive(primitive_node) = wrapper.data else {
return false;
};
let shape = self.shape(primitive_node);
let layer = self.layer(primitive_node);
let wrapper = BboxedIndex::new(
Bbox::new(shape.envelope_3d(0.0, layer)),
Node::Primitive(primitive_node),
GenericNode::Primitive(primitive_node),
);
!self
.rtree

12
src/layout/layout.rs
View File

@ -6,7 +6,7 @@ use crate::{
drawing::{
bend::LooseBendWeight,
dot::{DotIndex, FixedDotIndex, FixedDotWeight, LooseDotIndex, LooseDotWeight},
graph::{PrimitiveIndex, Retag},
graph::{PrimitiveIndex, PrimitiveWeight, Retag},
rules::RulesTrait,
seg::{
FixedSegIndex, FixedSegWeight, LoneLooseSegIndex, LoneLooseSegWeight, SeqLooseSegIndex,
@ -17,8 +17,8 @@ use crate::{
Drawing, Infringement, LayoutException,
},
geometry::{
compound::CompoundManagerTrait, BendWeightTrait, DotWeightTrait, Geometry, GeometryLabel,
GetWidth, Node, SegWeightTrait,
compound::CompoundManagerTrait, BendWeightTrait, DotWeightTrait, GenericNode, Geometry,
GeometryLabel, GetWidth, SegWeightTrait,
},
graph::{GenericIndex, GetNodeIndex},
layout::{
@ -29,6 +29,8 @@ use crate::{
},
};
pub type NodeIndex = GenericNode<PrimitiveIndex, GenericIndex<ZoneWeight>>;
pub struct Layout<R: RulesTrait> {
drawing: Drawing<ZoneWeight, R>, // Shouldn't be public, but is for now because `Draw` needs it.
connectivity: StableDiGraph<ConnectivityWeight, ConnectivityLabel, usize>,
@ -170,7 +172,7 @@ impl<R: RulesTrait> Layout<R> {
pub fn zones(&self) -> impl Iterator<Item = ZoneIndex> + '_ {
self.drawing.rtree().iter().filter_map(|wrapper| {
if let Node::Compound(zone) = wrapper.data {
if let NodeIndex::Compound(zone) = wrapper.data {
Some(match self.drawing.geometry().compound_weight(zone) {
ZoneWeight::Solid(..) => {
ZoneIndex::Solid(SolidZoneIndex::new(zone.node_index()))
@ -191,7 +193,7 @@ impl<R: RulesTrait> Layout<R> {
[f64::INFINITY, f64::INFINITY, layer as f64],
))
.filter_map(|wrapper| {
if let Node::Compound(zone) = wrapper.data {
if let NodeIndex::Compound(zone) = wrapper.data {
Some(match self.drawing.geometry().compound_weight(zone) {
ZoneWeight::Solid(..) => {
ZoneIndex::Solid(SolidZoneIndex::new(zone.node_index()))

20
src/overlay/overlay.rs
View File

@ -9,13 +9,13 @@ use crate::{
primitive::MakeShape,
rules::RulesTrait,
},
geometry::{shape::ShapeTrait, Node},
geometry::shape::ShapeTrait,
graph::GenericIndex,
layout::{zone::ZoneWeight, Layout},
layout::{zone::ZoneWeight, Layout, NodeIndex},
};
pub struct Overlay {
selection: HashSet<Node<PrimitiveIndex, GenericIndex<ZoneWeight>>>,
selection: HashSet<NodeIndex>,
active_layer: u64,
}
@ -38,10 +38,10 @@ impl Overlay {
.collect();
if let Some(geom) = geoms.iter().find(|&&geom| match geom.data {
Node::Primitive(primitive) => {
NodeIndex::Primitive(primitive) => {
primitive.primitive(layout.drawing()).layer() == self.active_layer
}
Node::Compound(compound) => false,
NodeIndex::Compound(compound) => false,
}) {
if self.toggle_selection_if_contains_point(layout, geom.data, at) {
return;
@ -58,11 +58,11 @@ impl Overlay {
fn toggle_selection_if_contains_point<R: RulesTrait>(
&mut self,
layout: &Layout<R>,
node: Node<PrimitiveIndex, GenericIndex<ZoneWeight>>,
node: NodeIndex,
p: Point,
) -> bool {
match node {
Node::Primitive(primitive) => {
NodeIndex::Primitive(primitive) => {
if primitive
.primitive(layout.drawing())
.shape()
@ -72,19 +72,19 @@ impl Overlay {
return true;
}
}
Node::Compound(compound) => (), // TODO.
NodeIndex::Compound(compound) => (), // TODO.
}
false
}
fn toggle_selection(&mut self, node: Node<PrimitiveIndex, GenericIndex<ZoneWeight>>) {
fn toggle_selection(&mut self, node: NodeIndex) {
if !self.selection.insert(node) {
self.selection.remove(&node);
}
}
pub fn selection(&self) -> &HashSet<Node<PrimitiveIndex, GenericIndex<ZoneWeight>>> {
pub fn selection(&self) -> &HashSet<NodeIndex> {
&self.selection
}
}