From bad487f6af5f88eccbfbfea515b1c6d98bd3f2c8 Mon Sep 17 00:00:00 2001 From: Mikolaj Wielgus Date: Sat, 13 Apr 2024 18:51:34 +0000 Subject: [PATCH] geometry,drawing: rename grouping to compound, node to node weight --- src/drawing/collect.rs | 8 +- src/drawing/drawing.rs | 54 ++++++------ src/drawing/graph.rs | 12 +-- src/drawing/guide.rs | 8 +- src/drawing/loose.rs | 22 ++--- src/drawing/primitive.rs | 164 +++++++++++++++++++------------------ src/dsn/design.rs | 6 +- src/geometry/compound.rs | 8 ++ src/geometry/geometry.rs | 79 +++++++++--------- src/geometry/grouping.rs | 8 -- src/geometry/mod.rs | 2 +- src/geometry/with_rtree.rs | 111 ++++++++++++------------- src/layout/layout.rs | 38 ++++----- src/layout/zone.rs | 4 +- src/wraparoundable.rs | 18 ++-- 15 files changed, 275 insertions(+), 267 deletions(-) create mode 100644 src/geometry/compound.rs delete mode 100644 src/geometry/grouping.rs diff --git a/src/drawing/collect.rs b/src/drawing/collect.rs index 8f24f6f..66eda63 100644 --- a/src/drawing/collect.rs +++ b/src/drawing/collect.rs @@ -9,12 +9,12 @@ use super::{ }; #[derive(Debug)] -pub struct Collect<'a, GW: Copy, R: RulesTrait> { - drawing: &'a Drawing, +pub struct Collect<'a, CW: Copy, R: RulesTrait> { + drawing: &'a Drawing, } -impl<'a, GW: Copy, R: RulesTrait> Collect<'a, GW, R> { - pub fn new(drawing: &'a Drawing) -> Self { +impl<'a, CW: Copy, R: RulesTrait> Collect<'a, CW, R> { + pub fn new(drawing: &'a Drawing) -> Self { Self { drawing } } diff --git a/src/drawing/drawing.rs b/src/drawing/drawing.rs index a80507e..7d7026e 100644 --- a/src/drawing/drawing.rs +++ b/src/drawing/drawing.rs @@ -26,9 +26,9 @@ use crate::drawing::{ SeqLooseSegIndex, SeqLooseSegWeight, }, }; -use crate::geometry::grouping::GroupingManagerTrait; +use crate::geometry::compound::CompoundManagerTrait; use crate::geometry::with_rtree::BboxedIndex; -use crate::geometry::Node; +use crate::geometry::NodeWeight; use crate::geometry::{ primitive::{PrimitiveShape, PrimitiveShapeTrait}, with_rtree::GeometryWithRtree, @@ -70,13 +70,13 @@ pub struct Collision(pub PrimitiveShape, pub PrimitiveIndex); pub struct AlreadyConnected(pub usize, pub PrimitiveIndex); #[derive(Debug)] -pub struct Drawing { +pub struct Drawing { geometry_with_rtree: GeometryWithRtree< PrimitiveWeight, DotWeight, SegWeight, BendWeight, - GW, + CW, PrimitiveIndex, DotIndex, SegIndex, @@ -85,7 +85,7 @@ pub struct Drawing { rules: R, } -impl Drawing { +impl Drawing { pub fn new(rules: R) -> Self { Self { geometry_with_rtree: GeometryWithRtree::new(2), @@ -639,7 +639,7 @@ impl Drawing { .rtree() .iter() .filter_map(|wrapper| { - if let Node::Primitive(primitive_node) = wrapper.data { + if let NodeWeight::Primitive(primitive_node) = wrapper.data { Some(primitive_node) } else { None @@ -655,7 +655,7 @@ impl Drawing { [f64::INFINITY, f64::INFINITY, layer as f64], )) .filter_map(|wrapper| { - if let Node::Primitive(primitive_node) = wrapper.data { + if let NodeWeight::Primitive(primitive_node) = wrapper.data { Some(primitive_node) } else { None @@ -668,7 +668,7 @@ impl Drawing { } } -impl Drawing { +impl Drawing { #[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 move_dot(&mut self, dot: DotIndex, to: Point) -> Result<(), Infringement> { @@ -750,7 +750,7 @@ impl Drawing { .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 NodeWeight::Primitive(primitive_node) = wrapper.data { Some(primitive_node) } else { None @@ -785,7 +785,7 @@ impl Drawing { .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 NodeWeight::Primitive(primitive_node) = wrapper.data { Some(primitive_node) } else { None @@ -812,7 +812,7 @@ impl Drawing { } } -impl Drawing { +impl Drawing { #[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 geometry( @@ -822,7 +822,7 @@ impl Drawing { DotWeight, SegWeight, BendWeight, - GW, + CW, PrimitiveIndex, DotIndex, SegIndex, @@ -833,7 +833,7 @@ impl Drawing { #[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>>> { + pub fn rtree(&self) -> &RTree>>> { self.geometry_with_rtree.rtree() } @@ -845,50 +845,50 @@ impl Drawing { #[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 guide(&self) -> Guide { + pub fn guide(&self) -> Guide { Guide::new(self) } #[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 collect(&self) -> Collect { + pub fn collect(&self) -> Collect { Collect::new(self) } #[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 primitive(&self, index: GenericIndex) -> GenericPrimitive { + pub fn primitive(&self, index: GenericIndex) -> GenericPrimitive { GenericPrimitive::new(index, self) } #[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 wraparoundable(&self, index: WraparoundableIndex) -> Wraparoundable { + pub fn wraparoundable(&self, index: WraparoundableIndex) -> Wraparoundable { Wraparoundable::new(index, self) } #[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 loose(&self, index: LooseIndex) -> Loose { + pub fn loose(&self, index: LooseIndex) -> Loose { Loose::new(index, self) } } -impl GroupingManagerTrait> for Drawing { - fn add_grouping(&mut self, weight: GW) -> GenericIndex { - self.geometry_with_rtree.add_grouping(weight) +impl CompoundManagerTrait> for Drawing { + fn add_compound(&mut self, weight: CW) -> GenericIndex { + self.geometry_with_rtree.add_compound(weight) } - fn remove_grouping(&mut self, grouping: GenericIndex) { - self.geometry_with_rtree.remove_grouping(grouping); + fn remove_compound(&mut self, compound: GenericIndex) { + self.geometry_with_rtree.remove_compound(compound); } - fn assign_to_grouping(&mut self, primitive: GenericIndex, grouping: GenericIndex) { + fn add_to_compound(&mut self, primitive: GenericIndex, compound: GenericIndex) { self.geometry_with_rtree - .assign_to_grouping(primitive, grouping); + .add_to_compound(primitive, compound); } - fn groupings(&self, node: GenericIndex) -> impl Iterator> { - self.geometry_with_rtree.groupings(node) + fn compounds(&self, node: GenericIndex) -> impl Iterator> { + self.geometry_with_rtree.compounds(node) } } diff --git a/src/drawing/graph.rs b/src/drawing/graph.rs index 83e8b58..4232bfe 100644 --- a/src/drawing/graph.rs +++ b/src/drawing/graph.rs @@ -32,10 +32,10 @@ pub trait GetMaybeNet { #[enum_dispatch] pub trait MakePrimitive { - fn primitive<'a, GW: Copy, R: RulesTrait>( + fn primitive<'a, CW: Copy, R: RulesTrait>( &self, - drawing: &'a Drawing, - ) -> Primitive<'a, GW, R>; + drawing: &'a Drawing, + ) -> Primitive<'a, CW, R>; } macro_rules! impl_weight { @@ -61,10 +61,10 @@ macro_rules! impl_weight { pub type $index_struct = GenericIndex<$weight_struct>; impl MakePrimitive for $index_struct { - fn primitive<'a, GW: Copy, R: RulesTrait>( + fn primitive<'a, CW: Copy, R: RulesTrait>( &self, - drawing: &'a Drawing, - ) -> Primitive<'a, GW, R> { + drawing: &'a Drawing, + ) -> Primitive<'a, CW, R> { Primitive::$weight_variant(GenericPrimitive::new(*self, drawing)) } } diff --git a/src/drawing/guide.rs b/src/drawing/guide.rs index 44570b8..a290d88 100644 --- a/src/drawing/guide.rs +++ b/src/drawing/guide.rs @@ -56,12 +56,12 @@ impl HeadTrait for SegbendHead { } } -pub struct Guide<'a, GW: Copy, R: RulesTrait> { - drawing: &'a Drawing, +pub struct Guide<'a, CW: Copy, R: RulesTrait> { + drawing: &'a Drawing, } -impl<'a, GW: Copy, R: RulesTrait> Guide<'a, GW, R> { - pub fn new(drawing: &'a Drawing) -> Self { +impl<'a, CW: Copy, R: RulesTrait> Guide<'a, CW, R> { + pub fn new(drawing: &'a Drawing) -> Self { Self { drawing } } diff --git a/src/drawing/loose.rs b/src/drawing/loose.rs index 7f824c8..e22e6d7 100644 --- a/src/drawing/loose.rs +++ b/src/drawing/loose.rs @@ -41,15 +41,15 @@ impl From for PrimitiveIndex { } #[enum_dispatch(GetNextLoose, GetDrawing, GetNodeIndex)] -pub enum Loose<'a, GW: Copy, R: RulesTrait> { - Dot(LooseDot<'a, GW, R>), - LoneSeg(LoneLooseSeg<'a, GW, R>), - SeqSeg(SeqLooseSeg<'a, GW, R>), - Bend(LooseBend<'a, GW, R>), +pub enum Loose<'a, CW: Copy, R: RulesTrait> { + Dot(LooseDot<'a, CW, R>), + LoneSeg(LoneLooseSeg<'a, CW, R>), + SeqSeg(SeqLooseSeg<'a, CW, R>), + Bend(LooseBend<'a, CW, R>), } -impl<'a, GW: Copy, R: RulesTrait> Loose<'a, GW, R> { - pub fn new(index: LooseIndex, drawing: &'a Drawing) -> Self { +impl<'a, CW: Copy, R: RulesTrait> Loose<'a, CW, R> { + pub fn new(index: LooseIndex, drawing: &'a Drawing) -> Self { match index { LooseIndex::Dot(dot) => drawing.primitive(dot).into(), LooseIndex::LoneSeg(seg) => drawing.primitive(seg).into(), @@ -59,7 +59,7 @@ impl<'a, GW: Copy, R: RulesTrait> Loose<'a, GW, R> { } } -impl<'a, GW: Copy, R: RulesTrait> GetNextLoose for LooseDot<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetNextLoose for LooseDot<'a, CW, R> { fn next_loose(&self, maybe_prev: Option) -> Option { let bend = self.bend(); let Some(prev) = maybe_prev else { @@ -74,13 +74,13 @@ impl<'a, GW: Copy, R: RulesTrait> GetNextLoose for LooseDot<'a, GW, R> { } } -impl<'a, GW: Copy, R: RulesTrait> GetNextLoose for LoneLooseSeg<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetNextLoose for LoneLooseSeg<'a, CW, R> { fn next_loose(&self, _maybe_prev: Option) -> Option { None } } -impl<'a, GW: Copy, R: RulesTrait> GetNextLoose for SeqLooseSeg<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetNextLoose for SeqLooseSeg<'a, CW, R> { fn next_loose(&self, maybe_prev: Option) -> Option { let ends = self.joints(); let Some(prev) = maybe_prev else { @@ -98,7 +98,7 @@ impl<'a, GW: Copy, R: RulesTrait> GetNextLoose for SeqLooseSeg<'a, GW, R> { } } -impl<'a, GW: Copy, R: RulesTrait> GetNextLoose for LooseBend<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetNextLoose for LooseBend<'a, CW, R> { fn next_loose(&self, maybe_prev: Option) -> Option { let ends = self.joints(); let Some(prev) = maybe_prev else { diff --git a/src/drawing/primitive.rs b/src/drawing/primitive.rs index 938ac08..d0e4e5b 100644 --- a/src/drawing/primitive.rs +++ b/src/drawing/primitive.rs @@ -20,7 +20,7 @@ use crate::{ }, Drawing, }, - geometry::Node, + geometry::NodeWeight, }; #[enum_dispatch] @@ -117,8 +117,8 @@ pub trait GetInnerOuter<'a, R: RulesTrait>: GetDrawing<'a, R> + GetBendIndex { macro_rules! impl_primitive { ($primitive_struct:ident, $weight_struct:ident) => { - impl<'a, GW: Copy, R: RulesTrait> GetWeight<$weight_struct> - for $primitive_struct<'a, GW, R> + impl<'a, CW: Copy, R: RulesTrait> GetWeight<$weight_struct> + for $primitive_struct<'a, CW, R> { fn weight(&self) -> $weight_struct { if let PrimitiveWeight::$primitive_struct(weight) = self.tagged_weight() { @@ -129,13 +129,13 @@ macro_rules! impl_primitive { } } - impl<'a, GW: Copy, R: RulesTrait> GetLayer for $primitive_struct<'a, GW, R> { + impl<'a, CW: Copy, R: RulesTrait> GetLayer for $primitive_struct<'a, CW, R> { fn layer(&self) -> u64 { self.weight().layer() } } - impl<'a, GW: Copy, R: RulesTrait> GetMaybeNet for $primitive_struct<'a, GW, R> { + impl<'a, CW: Copy, R: RulesTrait> GetMaybeNet for $primitive_struct<'a, CW, R> { fn maybe_net(&self) -> Option { self.weight().maybe_net() } @@ -164,29 +164,29 @@ macro_rules! impl_loose_primitive { GetLimbs, GetConditions )] -pub enum Primitive<'a, GW: Copy, R: RulesTrait> { - FixedDot(FixedDot<'a, GW, R>), - LooseDot(LooseDot<'a, GW, R>), - FixedSeg(FixedSeg<'a, GW, R>), - LoneLooseSeg(LoneLooseSeg<'a, GW, R>), - SeqLooseSeg(SeqLooseSeg<'a, GW, R>), - FixedBend(FixedBend<'a, GW, R>), - LooseBend(LooseBend<'a, GW, R>), +pub enum Primitive<'a, CW: Copy, R: RulesTrait> { + FixedDot(FixedDot<'a, CW, R>), + LooseDot(LooseDot<'a, CW, R>), + FixedSeg(FixedSeg<'a, CW, R>), + LoneLooseSeg(LoneLooseSeg<'a, CW, R>), + SeqLooseSeg(SeqLooseSeg<'a, CW, R>), + FixedBend(FixedBend<'a, CW, R>), + LooseBend(LooseBend<'a, CW, R>), } #[derive(Debug)] -pub struct GenericPrimitive<'a, W, GW: Copy, R: RulesTrait> { +pub struct GenericPrimitive<'a, W, CW: Copy, R: RulesTrait> { pub index: GenericIndex, - drawing: &'a Drawing, + drawing: &'a Drawing, } -impl<'a, W, GW: Copy, R: RulesTrait> GenericPrimitive<'a, W, GW, R> { - pub fn new(index: GenericIndex, drawing: &'a Drawing) -> Self { +impl<'a, W, CW: Copy, R: RulesTrait> GenericPrimitive<'a, W, CW, R> { + pub fn new(index: GenericIndex, drawing: &'a Drawing) -> Self { Self { index, drawing } } fn tagged_weight(&self) -> PrimitiveWeight { - if let Node::Primitive(weight) = *self + if let NodeWeight::Primitive(weight) = *self .drawing .geometry() .graph() @@ -199,43 +199,43 @@ impl<'a, W, GW: Copy, R: RulesTrait> GenericPrimitive<'a, W, GW, R> { } } - fn primitive(&self, index: GenericIndex) -> GenericPrimitive { + fn primitive(&self, index: GenericIndex) -> GenericPrimitive { GenericPrimitive::new(index, &self.drawing) } } -impl<'a, W, GW: Copy, R: RulesTrait> GetInterior - for GenericPrimitive<'a, W, GW, R> +impl<'a, W, CW: Copy, R: RulesTrait> GetInterior + for GenericPrimitive<'a, W, CW, R> { fn interior(&self) -> Vec { vec![self.tagged_weight().retag(self.index.node_index())] } } -impl<'a, W, GW: Copy, R: RulesTrait> GetDrawing<'a, R> for GenericPrimitive<'a, W, GW, R> { +impl<'a, W, CW: Copy, R: RulesTrait> GetDrawing<'a, R> for GenericPrimitive<'a, W, CW, R> { fn drawing(&self) -> &Drawing { self.drawing } } -impl<'a, W, GW: Copy, R: RulesTrait> GetNodeIndex for GenericPrimitive<'a, W, GW, R> { +impl<'a, W, CW: Copy, R: RulesTrait> GetNodeIndex for GenericPrimitive<'a, W, CW, R> { fn node_index(&self) -> NodeIndex { self.index.node_index() } } -impl<'a, W: GetWidth, GW: Copy, R: RulesTrait> GetWidth for GenericPrimitive<'a, W, GW, R> +impl<'a, W: GetWidth, CW: Copy, R: RulesTrait> GetWidth for GenericPrimitive<'a, W, CW, R> where - GenericPrimitive<'a, W, GW, R>: GetWeight, + GenericPrimitive<'a, W, CW, R>: GetWeight, { fn width(&self) -> f64 { self.weight().width() } } -impl<'a, W, GW: Copy, R: RulesTrait> GetConditions for GenericPrimitive<'a, W, GW, R> +impl<'a, W, CW: Copy, R: RulesTrait> GetConditions for GenericPrimitive<'a, W, CW, R> where - GenericPrimitive<'a, W, GW, R>: GetMaybeNet, + GenericPrimitive<'a, W, CW, R>: GetMaybeNet, { fn conditions(&self) -> Conditions { Conditions { @@ -246,10 +246,10 @@ where } } -pub type FixedDot<'a, GW, R> = GenericPrimitive<'a, FixedDotWeight, GW, R>; +pub type FixedDot<'a, CW, R> = GenericPrimitive<'a, FixedDotWeight, CW, R>; impl_fixed_primitive!(FixedDot, FixedDotWeight); -impl<'a, GW: Copy, R: RulesTrait> FixedDot<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> FixedDot<'a, CW, R> { pub fn first_loose(&self, _band: BandIndex) -> Option { self.drawing .geometry() @@ -262,9 +262,15 @@ impl<'a, GW: Copy, R: RulesTrait> FixedDot<'a, GW, R> { .graph() .node_weight(ni.node_index()) .unwrap(); - if matches!(weight, Node::Primitive(PrimitiveWeight::LoneLooseSeg(..))) { + if matches!( + weight, + NodeWeight::Primitive(PrimitiveWeight::LoneLooseSeg(..)) + ) { Some(LoneLooseSegIndex::new(ni.node_index()).into()) - } else if matches!(weight, Node::Primitive(PrimitiveWeight::SeqLooseSeg(..))) { + } else if matches!( + weight, + NodeWeight::Primitive(PrimitiveWeight::SeqLooseSeg(..)) + ) { Some(SeqLooseSegIndex::new(ni.node_index()).into()) } else { None @@ -273,13 +279,13 @@ impl<'a, GW: Copy, R: RulesTrait> FixedDot<'a, GW, R> { } } -impl<'a, GW: Copy, R: RulesTrait> MakeShape for FixedDot<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> MakeShape for FixedDot<'a, CW, R> { fn shape(&self) -> PrimitiveShape { self.drawing.geometry().dot_shape(self.index.into()) } } -impl<'a, GW: Copy, R: RulesTrait> GetLimbs for FixedDot<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetLimbs for FixedDot<'a, CW, R> { fn segs(&self) -> Vec { self.drawing .geometry() @@ -295,12 +301,12 @@ impl<'a, GW: Copy, R: RulesTrait> GetLimbs for FixedDot<'a, GW, R> { } } -impl<'a, GW: Copy, R: RulesTrait> GetFirstRail<'a, R> for FixedDot<'a, GW, R> {} +impl<'a, CW: Copy, R: RulesTrait> GetFirstRail<'a, R> for FixedDot<'a, CW, R> {} -pub type LooseDot<'a, GW, R> = GenericPrimitive<'a, LooseDotWeight, GW, R>; +pub type LooseDot<'a, CW, R> = GenericPrimitive<'a, LooseDotWeight, CW, R>; impl_loose_primitive!(LooseDot, LooseDotWeight); -impl<'a, GW: Copy, R: RulesTrait> LooseDot<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> LooseDot<'a, CW, R> { pub fn seg(&self) -> Option { self.drawing .geometry() @@ -319,13 +325,13 @@ impl<'a, GW: Copy, R: RulesTrait> LooseDot<'a, GW, R> { } } -impl<'a, GW: Copy, R: RulesTrait> MakeShape for LooseDot<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> MakeShape for LooseDot<'a, CW, R> { fn shape(&self) -> PrimitiveShape { self.drawing.geometry().dot_shape(self.index.into()) } } -impl<'a, GW: Copy, R: RulesTrait> GetLimbs for LooseDot<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetLimbs for LooseDot<'a, CW, R> { fn segs(&self) -> Vec { if let Some(seg) = self.seg() { vec![seg.into()] @@ -339,18 +345,18 @@ impl<'a, GW: Copy, R: RulesTrait> GetLimbs for LooseDot<'a, GW, R> { } } -pub type FixedSeg<'a, GW, R> = GenericPrimitive<'a, FixedSegWeight, GW, R>; +pub type FixedSeg<'a, CW, R> = GenericPrimitive<'a, FixedSegWeight, CW, R>; impl_fixed_primitive!(FixedSeg, FixedSegWeight); -impl<'a, GW: Copy, R: RulesTrait> MakeShape for FixedSeg<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> MakeShape for FixedSeg<'a, CW, R> { fn shape(&self) -> PrimitiveShape { self.drawing.geometry().seg_shape(self.index.into()) } } -impl<'a, GW: Copy, R: RulesTrait> GetLimbs for FixedSeg<'a, GW, R> {} +impl<'a, CW: Copy, R: RulesTrait> GetLimbs for FixedSeg<'a, CW, R> {} -impl<'a, GW: Copy, R: RulesTrait> GetJoints for FixedSeg<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetJoints for FixedSeg<'a, CW, R> { fn joints(&self) -> (FixedDotIndex, FixedDotIndex) { let (from, to) = self.drawing.geometry().seg_joints(self.index.into()); ( @@ -360,24 +366,24 @@ impl<'a, GW: Copy, R: RulesTrait> GetJoints for Fi } } -impl<'a, GW: Copy, R: RulesTrait> GetOtherJoint - for FixedSeg<'a, GW, R> +impl<'a, CW: Copy, R: RulesTrait> GetOtherJoint + for FixedSeg<'a, CW, R> { } -pub type LoneLooseSeg<'a, GW, R> = GenericPrimitive<'a, LoneLooseSegWeight, GW, R>; +pub type LoneLooseSeg<'a, CW, R> = GenericPrimitive<'a, LoneLooseSegWeight, CW, R>; impl_loose_primitive!(LoneLooseSeg, LoneLooseSegWeight); -impl<'a, GW: Copy, R: RulesTrait> MakeShape for LoneLooseSeg<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> MakeShape for LoneLooseSeg<'a, CW, R> { fn shape(&self) -> PrimitiveShape { self.drawing.geometry().seg_shape(self.index.into()) } } -impl<'a, GW: Copy, R: RulesTrait> GetLimbs for LoneLooseSeg<'a, GW, R> {} +impl<'a, CW: Copy, R: RulesTrait> GetLimbs for LoneLooseSeg<'a, CW, R> {} -impl<'a, GW: Copy, R: RulesTrait> GetJoints - for LoneLooseSeg<'a, GW, R> +impl<'a, CW: Copy, R: RulesTrait> GetJoints + for LoneLooseSeg<'a, CW, R> { fn joints(&self) -> (FixedDotIndex, FixedDotIndex) { let (from, to) = self.drawing.geometry().seg_joints(self.index.into()); @@ -388,23 +394,23 @@ impl<'a, GW: Copy, R: RulesTrait> GetJoints } } -impl<'a, GW: Copy, R: RulesTrait> GetOtherJoint - for LoneLooseSeg<'a, GW, R> +impl<'a, CW: Copy, R: RulesTrait> GetOtherJoint + for LoneLooseSeg<'a, CW, R> { } -pub type SeqLooseSeg<'a, GW, R> = GenericPrimitive<'a, SeqLooseSegWeight, GW, R>; +pub type SeqLooseSeg<'a, CW, R> = GenericPrimitive<'a, SeqLooseSegWeight, CW, R>; impl_loose_primitive!(SeqLooseSeg, SeqLooseSegWeight); -impl<'a, GW: Copy, R: RulesTrait> MakeShape for SeqLooseSeg<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> MakeShape for SeqLooseSeg<'a, CW, R> { fn shape(&self) -> PrimitiveShape { self.drawing.geometry().seg_shape(self.index.into()) } } -impl<'a, GW: Copy, R: RulesTrait> GetLimbs for SeqLooseSeg<'a, GW, R> {} +impl<'a, CW: Copy, R: RulesTrait> GetLimbs for SeqLooseSeg<'a, CW, R> {} -impl<'a, GW: Copy, R: RulesTrait> GetJoints for SeqLooseSeg<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetJoints for SeqLooseSeg<'a, CW, R> { fn joints(&self) -> (DotIndex, LooseDotIndex) { let joints = self.drawing.geometry().seg_joints(self.index.into()); if let DotWeight::Fixed(..) = self.drawing.geometry().dot_weight(joints.0) { @@ -426,29 +432,29 @@ impl<'a, GW: Copy, R: RulesTrait> GetJoints for SeqLoos } } -impl<'a, GW: Copy, R: RulesTrait> GetOtherJoint - for SeqLooseSeg<'a, GW, R> +impl<'a, CW: Copy, R: RulesTrait> GetOtherJoint + for SeqLooseSeg<'a, CW, R> { } -pub type FixedBend<'a, GW, R> = GenericPrimitive<'a, FixedBendWeight, GW, R>; +pub type FixedBend<'a, CW, R> = GenericPrimitive<'a, FixedBendWeight, CW, R>; impl_fixed_primitive!(FixedBend, FixedBendWeight); -impl<'a, GW: Copy, R: RulesTrait> GetBendIndex for FixedBend<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetBendIndex for FixedBend<'a, CW, R> { fn bend_index(&self) -> BendIndex { self.index.into() } } -impl<'a, GW: Copy, R: RulesTrait> MakeShape for FixedBend<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> MakeShape for FixedBend<'a, CW, R> { fn shape(&self) -> PrimitiveShape { self.drawing.geometry().bend_shape(self.index.into()) } } -impl<'a, GW: Copy, R: RulesTrait> GetLimbs for FixedBend<'a, GW, R> {} +impl<'a, CW: Copy, R: RulesTrait> GetLimbs for FixedBend<'a, CW, R> {} -impl<'a, GW: Copy, R: RulesTrait> GetJoints for FixedBend<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetJoints for FixedBend<'a, CW, R> { fn joints(&self) -> (FixedDotIndex, FixedDotIndex) { let (from, to) = self.drawing.geometry().bend_joints(self.index.into()); ( @@ -458,44 +464,44 @@ impl<'a, GW: Copy, R: RulesTrait> GetJoints for Fi } } -impl<'a, GW: Copy, R: RulesTrait> GetOtherJoint - for FixedBend<'a, GW, R> +impl<'a, CW: Copy, R: RulesTrait> GetOtherJoint + for FixedBend<'a, CW, R> { } -impl<'a, GW: Copy, R: RulesTrait> GetFirstRail<'a, R> for FixedBend<'a, GW, R> {} -impl<'a, GW: Copy, R: RulesTrait> GetCore<'a, R> for FixedBend<'a, GW, R> {} // TODO: Fixed bends don't have cores actually. - //impl<'a, R: QueryRules> GetInnerOuter for FixedBend<'a, GW, R> {} +impl<'a, CW: Copy, R: RulesTrait> GetFirstRail<'a, R> for FixedBend<'a, CW, R> {} +impl<'a, CW: Copy, R: RulesTrait> GetCore<'a, R> for FixedBend<'a, CW, R> {} // TODO: Fixed bends don't have cores actually. + //impl<'a, R: QueryRules> GetInnerOuter for FixedBend<'a, CW, R> {} -pub type LooseBend<'a, GW, R> = GenericPrimitive<'a, LooseBendWeight, GW, R>; +pub type LooseBend<'a, CW, R> = GenericPrimitive<'a, LooseBendWeight, CW, R>; impl_loose_primitive!(LooseBend, LooseBendWeight); -impl<'a, GW: Copy, R: RulesTrait> GetBendIndex for LooseBend<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetBendIndex for LooseBend<'a, CW, R> { fn bend_index(&self) -> BendIndex { self.index.into() } } -impl<'a, GW: Copy, R: RulesTrait> From> for BendIndex { - fn from(bend: LooseBend<'a, GW, R>) -> BendIndex { +impl<'a, CW: Copy, R: RulesTrait> From> for BendIndex { + fn from(bend: LooseBend<'a, CW, R>) -> BendIndex { bend.index.into() } } -impl<'a, GW: Copy, R: RulesTrait> MakeShape for LooseBend<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> MakeShape for LooseBend<'a, CW, R> { fn shape(&self) -> PrimitiveShape { self.drawing.geometry().bend_shape(self.index.into()) } } -impl<'a, GW: Copy, R: RulesTrait> GetLimbs for LooseBend<'a, GW, R> {} +impl<'a, CW: Copy, R: RulesTrait> GetLimbs for LooseBend<'a, CW, R> {} -impl<'a, GW: Copy, R: RulesTrait> GetOffset for LooseBend<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetOffset for LooseBend<'a, CW, R> { fn offset(&self) -> f64 { self.weight().offset } } -impl<'a, GW: Copy, R: RulesTrait> GetJoints for LooseBend<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetJoints for LooseBend<'a, CW, R> { fn joints(&self) -> (LooseDotIndex, LooseDotIndex) { let (from, to) = self.drawing.geometry().bend_joints(self.index.into()); ( @@ -505,9 +511,9 @@ impl<'a, GW: Copy, R: RulesTrait> GetJoints for Lo } } -impl<'a, GW: Copy, R: RulesTrait> GetOtherJoint - for LooseBend<'a, GW, R> +impl<'a, CW: Copy, R: RulesTrait> GetOtherJoint + for LooseBend<'a, CW, R> { } -impl<'a, GW: Copy, R: RulesTrait> GetCore<'a, R> for LooseBend<'a, GW, R> {} -impl<'a, GW: Copy, R: RulesTrait> GetInnerOuter<'a, R> for LooseBend<'a, GW, R> {} +impl<'a, CW: Copy, R: RulesTrait> GetCore<'a, R> for LooseBend<'a, CW, R> {} +impl<'a, CW: Copy, R: RulesTrait> GetInnerOuter<'a, R> for LooseBend<'a, CW, R> {} diff --git a/src/dsn/design.rs b/src/dsn/design.rs index 79f66ef..58aa996 100644 --- a/src/dsn/design.rs +++ b/src/dsn/design.rs @@ -10,7 +10,7 @@ use crate::{ rules::DsnRules, structure::{self, DsnFile, Layer, Pcb, Shape}, }, - geometry::grouping::GroupingManagerTrait, + geometry::compound::CompoundManagerTrait, graph::{GenericIndex, GetNodeIndex}, layout::{ zone::{SolidZoneWeight, ZoneIndex}, @@ -348,7 +348,7 @@ impl DsnDesign { layer: u64, net: usize, ) { - let zone = layout.add_grouping( + let zone = layout.add_compound( SolidZoneWeight { layer, maybe_net: Some(net), @@ -539,7 +539,7 @@ impl DsnDesign { layer: u64, net: usize, ) { - let zone = layout.add_grouping( + let zone = layout.add_compound( SolidZoneWeight { layer, maybe_net: Some(net), diff --git a/src/geometry/compound.rs b/src/geometry/compound.rs new file mode 100644 index 0000000..e153cb4 --- /dev/null +++ b/src/geometry/compound.rs @@ -0,0 +1,8 @@ +use crate::graph::{GenericIndex, GetNodeIndex}; + +pub trait CompoundManagerTrait { + fn add_compound(&mut self, weight: CW) -> GenericIndex; + fn remove_compound(&mut self, compound: GenericIndex); + fn add_to_compound(&mut self, node: GenericIndex, compound: GenericIndex); + fn compounds(&self, node: GenericIndex) -> impl Iterator>; +} diff --git a/src/geometry/geometry.rs b/src/geometry/geometry.rs index 321282d..94feaf4 100644 --- a/src/geometry/geometry.rs +++ b/src/geometry/geometry.rs @@ -18,7 +18,7 @@ use crate::{ seg::{FixedSegWeight, LoneLooseSegWeight, SegWeight, SeqLooseSegWeight}, }, geometry::{ - grouping::GroupingManagerTrait, + compound::CompoundManagerTrait, primitive::{BendShape, DotShape, PrimitiveShape, SegShape}, }, graph::{GenericIndex, GetNodeIndex}, @@ -55,18 +55,18 @@ pub enum GeometryLabel { Joined, Outer, Core, - Grouping, + Compound, } #[derive(Debug, Clone, Copy, PartialEq)] -pub enum Node { +pub enum NodeWeight { Primitive(PW), - Grouping(GW), + Compound(CW), } -pub trait DotWeightTrait: GetPos + SetPos + GetWidth + Into + Copy {} -pub trait SegWeightTrait: GetWidth + Into + Copy {} -pub trait BendWeightTrait: GetOffset + SetOffset + GetWidth + Into + Copy {} +pub trait DotWeightTrait: GetPos + SetPos + GetWidth + Into + Copy {} +pub trait SegWeightTrait: GetWidth + Into + Copy {} +pub trait BendWeightTrait: GetOffset + SetOffset + GetWidth + Into + Copy {} #[derive(Debug)] pub struct Geometry< @@ -74,18 +74,18 @@ pub struct Geometry< DW: DotWeightTrait, SW: SegWeightTrait, BW: BendWeightTrait, - GW: Copy, + CW: Copy, PI: GetNodeIndex + TryInto + TryInto + TryInto + Copy, DI: GetNodeIndex + Into + Copy, SI: GetNodeIndex + Into + Copy, BI: GetNodeIndex + Into + Copy, > { - graph: StableDiGraph, GeometryLabel, usize>, + graph: StableDiGraph, GeometryLabel, usize>, weight_marker: PhantomData, dot_weight_marker: PhantomData, seg_weight_marker: PhantomData, bend_weight_marker: PhantomData, - grouping_weight_marker: PhantomData, + compound_weight_marker: PhantomData, index_marker: PhantomData, dot_index_marker: PhantomData, seg_index_marker: PhantomData, @@ -97,12 +97,12 @@ impl< DW: DotWeightTrait, SW: SegWeightTrait, BW: BendWeightTrait, - GW: Copy, + CW: Copy, PI: GetNodeIndex + TryInto + TryInto + TryInto + Copy, DI: GetNodeIndex + Into + Copy, SI: GetNodeIndex + Into + Copy, BI: GetNodeIndex + Into + Copy, - > Geometry + > Geometry { pub fn new() -> Self { Self { @@ -111,7 +111,7 @@ impl< dot_weight_marker: PhantomData, seg_weight_marker: PhantomData, bend_weight_marker: PhantomData, - grouping_weight_marker: PhantomData, + compound_weight_marker: PhantomData, index_marker: PhantomData, dot_index_marker: PhantomData, seg_index_marker: PhantomData, @@ -120,7 +120,7 @@ impl< } pub fn add_dot>(&mut self, weight: W) -> GenericIndex { - GenericIndex::::new(self.graph.add_node(Node::Primitive(weight.into()))) + GenericIndex::::new(self.graph.add_node(NodeWeight::Primitive(weight.into()))) } pub fn add_seg>( @@ -129,7 +129,7 @@ impl< to: DI, weight: W, ) -> GenericIndex { - let seg = GenericIndex::::new(self.graph.add_node(Node::Primitive(weight.into()))); + let seg = GenericIndex::::new(self.graph.add_node(NodeWeight::Primitive(weight.into()))); self.graph .update_edge(from.node_index(), seg.node_index(), GeometryLabel::Joined); @@ -146,7 +146,8 @@ impl< core: DI, weight: W, ) -> GenericIndex { - let bend = GenericIndex::::new(self.graph.add_node(Node::Primitive(weight.into()))); + let bend = + GenericIndex::::new(self.graph.add_node(NodeWeight::Primitive(weight.into()))); self.graph .update_edge(from.node_index(), bend.node_index(), GeometryLabel::Joined); @@ -165,13 +166,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() = + NodeWeight::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() = + NodeWeight::Primitive(weight.into()); } pub fn flip_bend(&mut self, bend: BI) { @@ -267,7 +270,7 @@ impl< } fn primitive_weight(&self, index: NodeIndex) -> PW { - if let Node::Primitive(weight) = *self.graph.node_weight(index).unwrap() { + if let NodeWeight::Primitive(weight) = *self.graph.node_weight(index).unwrap() { weight } else { unreachable!() @@ -292,8 +295,10 @@ impl< .unwrap_or_else(|_| unreachable!()) } - pub fn grouping_weight(&self, grouping: GenericIndex) -> GW { - if let Node::Grouping(weight) = *self.graph.node_weight(grouping.node_index()).unwrap() { + pub fn compound_weight(&self, compound: GenericIndex) -> CW { + if let NodeWeight::Compound(weight) = + *self.graph.node_weight(compound.node_index()).unwrap() + { weight } else { unreachable!() @@ -449,15 +454,15 @@ impl< self.joineds(dot.into()).filter_map(|ni| ni.try_into().ok()) } - pub fn grouping_members(&self, grouping: GenericIndex) -> impl Iterator + '_ { + pub fn compound_members(&self, compound: GenericIndex) -> impl Iterator + '_ { self.graph - .neighbors_directed(grouping.node_index(), Incoming) + .neighbors_directed(compound.node_index(), Incoming) .filter(move |ni| { matches!( self.graph - .edge_weight(self.graph.find_edge(*ni, grouping.node_index()).unwrap()) + .edge_weight(self.graph.find_edge(*ni, compound.node_index()).unwrap()) .unwrap(), - GeometryLabel::Grouping + GeometryLabel::Compound ) }) .map(|ni| { @@ -468,7 +473,7 @@ impl< }) } - pub fn graph(&self) -> &StableDiGraph, GeometryLabel, usize> { + pub fn graph(&self) -> &StableDiGraph, GeometryLabel, usize> { &self.graph } } @@ -478,30 +483,30 @@ impl< DW: DotWeightTrait, SW: SegWeightTrait, BW: BendWeightTrait, - GW: Copy, + CW: Copy, PI: GetNodeIndex + TryInto + TryInto + TryInto + Copy, DI: GetNodeIndex + Into + Copy, SI: GetNodeIndex + Into + Copy, BI: GetNodeIndex + Into + Copy, - > GroupingManagerTrait> for Geometry + > CompoundManagerTrait> for Geometry { - fn add_grouping(&mut self, weight: GW) -> GenericIndex { - GenericIndex::::new(self.graph.add_node(Node::Grouping(weight))) + fn add_compound(&mut self, weight: CW) -> GenericIndex { + GenericIndex::::new(self.graph.add_node(NodeWeight::Compound(weight))) } - fn remove_grouping(&mut self, grouping: GenericIndex) { - self.graph.remove_node(grouping.node_index()); + fn remove_compound(&mut self, compound: GenericIndex) { + self.graph.remove_node(compound.node_index()); } - fn assign_to_grouping(&mut self, primitive: GenericIndex, grouping: GenericIndex) { + fn add_to_compound(&mut self, primitive: GenericIndex, compound: GenericIndex) { self.graph.update_edge( primitive.node_index(), - grouping.node_index(), - GeometryLabel::Grouping, + compound.node_index(), + GeometryLabel::Compound, ); } - fn groupings(&self, node: GenericIndex) -> impl Iterator> { + fn compounds(&self, node: GenericIndex) -> impl Iterator> { self.graph .neighbors(node.node_index()) .filter(move |ni| { @@ -509,7 +514,7 @@ impl< self.graph .edge_weight(self.graph.find_edge(node.node_index(), *ni).unwrap()) .unwrap(), - GeometryLabel::Grouping + GeometryLabel::Compound ) }) .map(|ni| GenericIndex::new(ni)) diff --git a/src/geometry/grouping.rs b/src/geometry/grouping.rs deleted file mode 100644 index 52680b9..0000000 --- a/src/geometry/grouping.rs +++ /dev/null @@ -1,8 +0,0 @@ -use crate::graph::{GenericIndex, GetNodeIndex}; - -pub trait GroupingManagerTrait { - fn add_grouping(&mut self, weight: GW) -> GenericIndex; - fn remove_grouping(&mut self, grouping: GenericIndex); - fn assign_to_grouping(&mut self, node: GenericIndex, grouping: GenericIndex); - fn groupings(&self, node: GenericIndex) -> impl Iterator>; -} diff --git a/src/geometry/mod.rs b/src/geometry/mod.rs index 37c50dc..13d5121 100644 --- a/src/geometry/mod.rs +++ b/src/geometry/mod.rs @@ -1,6 +1,6 @@ #[macro_use] mod geometry; -pub mod grouping; +pub mod compound; pub mod primitive; mod shape; pub mod with_rtree; diff --git a/src/geometry/with_rtree.rs b/src/geometry/with_rtree.rs index 6779bcd..e6bc9ab 100644 --- a/src/geometry/with_rtree.rs +++ b/src/geometry/with_rtree.rs @@ -8,9 +8,10 @@ use rstar::{primitives::GeomWithData, Envelope, RTree, RTreeObject, AABB}; use crate::{ drawing::graph::{GetLayer, Retag}, geometry::{ - grouping::GroupingManagerTrait, + compound::CompoundManagerTrait, primitive::{PrimitiveShape, PrimitiveShapeTrait}, - BendWeightTrait, DotWeightTrait, Geometry, GeometryLabel, GetWidth, Node, SegWeightTrait, + BendWeightTrait, DotWeightTrait, Geometry, GeometryLabel, GetWidth, NodeWeight, + SegWeightTrait, }, graph::{GenericIndex, GetNodeIndex}, }; @@ -41,14 +42,14 @@ pub struct GeometryWithRtree< DW: DotWeightTrait + GetLayer, SW: SegWeightTrait + GetLayer, BW: BendWeightTrait + GetLayer, - GW: Copy, + CW: Copy, PI: GetNodeIndex + TryInto + TryInto + TryInto + Copy, DI: GetNodeIndex + Into + Copy, SI: GetNodeIndex + Into + Copy, BI: GetNodeIndex + Into + Copy, > { - geometry: Geometry, - rtree: RTree>>>, + geometry: Geometry, + rtree: RTree>>>, layer_count: u64, weight_marker: PhantomData, dot_weight_marker: PhantomData, @@ -67,16 +68,16 @@ impl< DW: DotWeightTrait + GetLayer, SW: SegWeightTrait + GetLayer, BW: BendWeightTrait + GetLayer, - GW: Copy, + CW: Copy, PI: GetNodeIndex + TryInto + TryInto + TryInto + PartialEq + Copy, DI: GetNodeIndex + Into + Copy, SI: GetNodeIndex + Into + Copy, BI: GetNodeIndex + Into + Copy, - > GeometryWithRtree + > GeometryWithRtree { pub fn new(layer_count: u64) -> Self { Self { - geometry: Geometry::::new(), + geometry: Geometry::::new(), rtree: RTree::new(), layer_count, weight_marker: PhantomData, @@ -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()), + NodeWeight::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()), + NodeWeight::Primitive(seg.into()), )); seg } @@ -144,19 +145,15 @@ impl< .bend_shape(bend.into().try_into().unwrap_or_else(|_| unreachable!())) .envelope_3d(0.0, weight.layer()), ), - Node::Primitive(bend.into()), + NodeWeight::Primitive(bend.into()), )); bend } - pub fn assign_to_grouping( - &mut self, - primitive: GenericIndex, - grouping: GenericIndex, - ) { - self.rtree.remove(&self.make_grouping_bbox(grouping)); - self.geometry.assign_to_grouping(primitive, grouping); - self.rtree.insert(self.make_grouping_bbox(grouping)); + pub fn add_to_compound(&mut self, primitive: GenericIndex, compound: GenericIndex) { + self.rtree.remove(&self.make_compound_bbox(compound)); + self.geometry.add_to_compound(primitive, compound); + self.rtree.insert(self.make_compound_bbox(compound)); } pub fn remove_dot(&mut self, dot: DI) -> Result<(), ()> { @@ -183,9 +180,9 @@ impl< self.geometry.remove_primitive(bend.into()); } - pub fn remove_grouping(&mut self, grouping: GenericIndex) { - self.rtree.remove(&self.make_grouping_bbox(grouping)); - self.geometry.remove_grouping(grouping); + pub fn remove_compound(&mut self, compound: GenericIndex) { + self.rtree.remove(&self.make_compound_bbox(compound)); + self.geometry.remove_compound(compound); } pub fn move_dot(&mut self, dot: DI, to: Point) { @@ -261,14 +258,14 @@ impl< DW: DotWeightTrait + GetLayer, SW: SegWeightTrait + GetLayer, BW: BendWeightTrait + GetLayer, - GW: Copy, + CW: Copy, PI: GetNodeIndex + TryInto + TryInto + TryInto + PartialEq + Copy, DI: GetNodeIndex + Into + Copy, SI: GetNodeIndex + Into + Copy, BI: GetNodeIndex + Into + Copy, - > GeometryWithRtree + > GeometryWithRtree { - fn make_bbox(&self, primitive: PI) -> BboxedIndex>> { + fn make_bbox(&self, primitive: PI) -> BboxedIndex>> { if let Ok(dot) = >::try_into(primitive) { self.make_dot_bbox(dot) } else if let Ok(seg) = >::try_into(primitive) { @@ -280,50 +277,50 @@ impl< } } - fn make_dot_bbox(&self, dot: DI) -> BboxedIndex>> { + fn make_dot_bbox(&self, dot: DI) -> BboxedIndex>> { BboxedIndex::new( Bbox::new( self.geometry .dot_shape(dot) .envelope_3d(0.0, self.layer(dot.into())), ), - Node::Primitive(dot.into()), + NodeWeight::Primitive(dot.into()), ) } - fn make_seg_bbox(&self, seg: SI) -> BboxedIndex>> { + fn make_seg_bbox(&self, seg: SI) -> BboxedIndex>> { BboxedIndex::new( Bbox::new( self.geometry .seg_shape(seg) .envelope_3d(0.0, self.layer(seg.into())), ), - Node::Primitive(seg.into()), + NodeWeight::Primitive(seg.into()), ) } - fn make_bend_bbox(&self, bend: BI) -> BboxedIndex>> { + fn make_bend_bbox(&self, bend: BI) -> BboxedIndex>> { BboxedIndex::new( Bbox::new( self.geometry .bend_shape(bend) .envelope_3d(0.0, self.layer(bend.into())), ), - Node::Primitive(bend.into()), + NodeWeight::Primitive(bend.into()), ) } - fn make_grouping_bbox( + fn make_compound_bbox( &self, - grouping: GenericIndex, - ) -> BboxedIndex>> { + compound: GenericIndex, + ) -> BboxedIndex>> { let mut aabb = AABB::<[f64; 3]>::new_empty(); - for member in self.geometry.grouping_members(grouping) { + for member in self.geometry.compound_members(compound) { aabb.merge(&self.make_bbox(member).geom().aabb); } - BboxedIndex::new(Bbox::new(aabb), Node::Grouping(grouping)) + BboxedIndex::new(Bbox::new(aabb), NodeWeight::Compound(compound)) } fn shape(&self, primitive: PI) -> PrimitiveShape { @@ -350,30 +347,30 @@ impl< } } - pub fn geometry(&self) -> &Geometry { + pub fn geometry(&self) -> &Geometry { &self.geometry } - // XXX: The type appears wrong? I don't think it should contain GW? - pub fn rtree(&self) -> &RTree>>> { + // XXX: The type appears wrong? I don't think it should contain CW? + pub fn rtree(&self) -> &RTree>>> { &self.rtree } - pub fn graph(&self) -> &StableDiGraph, GeometryLabel, usize> { + pub fn graph(&self) -> &StableDiGraph, GeometryLabel, usize> { self.geometry.graph() } fn test_envelopes(&self) -> bool { !self.rtree.iter().any(|wrapper| { - // TODO: Test envelopes of groupings too. - let Node::Primitive(primitive_node) = wrapper.data else { + // TODO: Test envelopes of compounds too. + let NodeWeight::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), + NodeWeight::Primitive(primitive_node), ); !self .rtree @@ -388,30 +385,30 @@ impl< DW: DotWeightTrait + GetLayer, SW: SegWeightTrait + GetLayer, BW: BendWeightTrait + GetLayer, - GW: Copy, + CW: Copy, PI: GetNodeIndex + TryInto + TryInto + TryInto + PartialEq + Copy, DI: GetNodeIndex + Into + Copy, SI: GetNodeIndex + Into + Copy, BI: GetNodeIndex + Into + Copy, - > GroupingManagerTrait> - for GeometryWithRtree + > CompoundManagerTrait> + for GeometryWithRtree { - fn add_grouping(&mut self, weight: GW) -> GenericIndex { - let grouping = self.geometry.add_grouping(weight); - self.rtree.insert(self.make_grouping_bbox(grouping)); - grouping + fn add_compound(&mut self, weight: CW) -> GenericIndex { + let compound = self.geometry.add_compound(weight); + self.rtree.insert(self.make_compound_bbox(compound)); + compound } - fn remove_grouping(&mut self, grouping: GenericIndex) { - self.rtree.remove(&self.make_grouping_bbox(grouping)); - self.geometry.remove_grouping(grouping); + fn remove_compound(&mut self, compound: GenericIndex) { + self.rtree.remove(&self.make_compound_bbox(compound)); + self.geometry.remove_compound(compound); } - fn assign_to_grouping(&mut self, primitive: GenericIndex, grouping: GenericIndex) { - self.geometry.assign_to_grouping(primitive, grouping); + fn add_to_compound(&mut self, primitive: GenericIndex, compound: GenericIndex) { + self.geometry.add_to_compound(primitive, compound); } - fn groupings(&self, node: GenericIndex) -> impl Iterator> { - self.geometry.groupings(node) + fn compounds(&self, node: GenericIndex) -> impl Iterator> { + self.geometry.compounds(node) } } diff --git a/src/layout/layout.rs b/src/layout/layout.rs index 834fd86..99105d0 100644 --- a/src/layout/layout.rs +++ b/src/layout/layout.rs @@ -16,8 +16,8 @@ use crate::{ Drawing, Infringement, LayoutException, }, geometry::{ - grouping::GroupingManagerTrait, BendWeightTrait, DotWeightTrait, Geometry, GeometryLabel, - GetWidth, Node, SegWeightTrait, + compound::CompoundManagerTrait, BendWeightTrait, DotWeightTrait, Geometry, GeometryLabel, + GetWidth, NodeWeight, SegWeightTrait, }, graph::{GenericIndex, GetNodeIndex}, layout::{ @@ -96,7 +96,7 @@ impl Layout { if let Ok(dot) = maybe_dot { self.drawing - .assign_to_grouping(dot, GenericIndex::new(zone.node_index())); + .add_to_compound(dot, GenericIndex::new(zone.node_index())); } maybe_dot @@ -122,7 +122,7 @@ impl Layout { if let Ok(seg) = maybe_seg { self.drawing - .assign_to_grouping(seg, GenericIndex::new(zone.node_index())); + .add_to_compound(seg, GenericIndex::new(zone.node_index())); } maybe_seg @@ -170,8 +170,8 @@ impl Layout { pub fn zones(&self) -> impl Iterator + '_ { self.drawing.rtree().iter().filter_map(|wrapper| { - if let Node::Grouping(zone) = wrapper.data { - Some(match self.drawing.geometry().grouping_weight(zone) { + if let NodeWeight::Compound(zone) = wrapper.data { + Some(match self.drawing.geometry().compound_weight(zone) { ZoneWeight::Solid(..) => { ZoneIndex::Solid(SolidZoneIndex::new(zone.node_index())) } @@ -191,8 +191,8 @@ impl Layout { [f64::INFINITY, f64::INFINITY, layer as f64], )) .filter_map(|wrapper| { - if let Node::Grouping(zone) = wrapper.data { - Some(match self.drawing.geometry().grouping_weight(zone) { + if let NodeWeight::Compound(zone) = wrapper.data { + Some(match self.drawing.geometry().compound_weight(zone) { ZoneWeight::Solid(..) => { ZoneIndex::Solid(SolidZoneIndex::new(zone.node_index())) } @@ -209,7 +209,7 @@ impl Layout { pub fn zone_members(&self, zone: ZoneIndex) -> impl Iterator + '_ { self.drawing .geometry() - .grouping_members(GenericIndex::new(zone.node_index())) + .compound_members(GenericIndex::new(zone.node_index())) } pub fn drawing(&self) -> &Drawing { @@ -217,27 +217,27 @@ impl Layout { } } -impl GroupingManagerTrait> for Layout { - fn add_grouping(&mut self, weight: ZoneWeight) -> GenericIndex { - self.drawing.add_grouping(weight) +impl CompoundManagerTrait> for Layout { + fn add_compound(&mut self, weight: ZoneWeight) -> GenericIndex { + self.drawing.add_compound(weight) } - fn remove_grouping(&mut self, grouping: GenericIndex) { - self.drawing.remove_grouping(grouping); + fn remove_compound(&mut self, compound: GenericIndex) { + self.drawing.remove_compound(compound); } - fn assign_to_grouping( + fn add_to_compound( &mut self, primitive: GenericIndex, - grouping: GenericIndex, + compound: GenericIndex, ) { - self.drawing.assign_to_grouping(primitive, grouping); + self.drawing.add_to_compound(primitive, compound); } - fn groupings( + fn compounds( &self, node: GenericIndex, ) -> impl Iterator> { - self.drawing.groupings(node) + self.drawing.compounds(node) } } diff --git a/src/layout/zone.rs b/src/layout/zone.rs index 14e3eed..328af91 100644 --- a/src/layout/zone.rs +++ b/src/layout/zone.rs @@ -60,7 +60,7 @@ impl MakePolygon for SolidZoneIndex { LineString::from( drawing .geometry() - .grouping_members(GenericIndex::new(self.node_index())) + .compound_members(GenericIndex::new(self.node_index())) .filter_map(|primitive_node| { if let Ok(dot) = DotIndex::try_from(primitive_node) { Some(drawing.geometry().dot_weight(dot).pos()) @@ -101,7 +101,7 @@ impl MakePolygon for PourZoneIndex { LineString::from( drawing .geometry() - .grouping_members(GenericIndex::new(self.node_index())) + .compound_members(GenericIndex::new(self.node_index())) .filter_map(|primitive_node| { if let Ok(dot) = DotIndex::try_from(primitive_node) { Some(drawing.geometry().dot_weight(dot).pos()) diff --git a/src/wraparoundable.rs b/src/wraparoundable.rs index bde3a75..611751a 100644 --- a/src/wraparoundable.rs +++ b/src/wraparoundable.rs @@ -46,14 +46,14 @@ impl From for WraparoundableIndex { } #[enum_dispatch(GetWraparound, GetDrawing, GetNodeIndex)] -pub enum Wraparoundable<'a, GW: Copy, R: RulesTrait> { - FixedDot(FixedDot<'a, GW, R>), - FixedBend(FixedBend<'a, GW, R>), - LooseBend(LooseBend<'a, GW, R>), +pub enum Wraparoundable<'a, CW: Copy, R: RulesTrait> { + FixedDot(FixedDot<'a, CW, R>), + FixedBend(FixedBend<'a, CW, R>), + LooseBend(LooseBend<'a, CW, R>), } -impl<'a, GW: Copy, R: RulesTrait> Wraparoundable<'a, GW, R> { - pub fn new(index: WraparoundableIndex, drawing: &'a Drawing) -> Self { +impl<'a, CW: Copy, R: RulesTrait> Wraparoundable<'a, CW, R> { + pub fn new(index: WraparoundableIndex, drawing: &'a Drawing) -> Self { match index { WraparoundableIndex::FixedDot(dot) => drawing.primitive(dot).into(), WraparoundableIndex::FixedBend(bend) => drawing.primitive(bend).into(), @@ -62,19 +62,19 @@ impl<'a, GW: Copy, R: RulesTrait> Wraparoundable<'a, GW, R> { } } -impl<'a, GW: Copy, R: RulesTrait> GetWraparound for FixedDot<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetWraparound for FixedDot<'a, CW, R> { fn wraparound(&self) -> Option { self.first_rail() } } -impl<'a, GW: Copy, R: RulesTrait> GetWraparound for LooseBend<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetWraparound for LooseBend<'a, CW, R> { fn wraparound(&self) -> Option { self.outer() } } -impl<'a, GW: Copy, R: RulesTrait> GetWraparound for FixedBend<'a, GW, R> { +impl<'a, CW: Copy, R: RulesTrait> GetWraparound for FixedBend<'a, CW, R> { fn wraparound(&self) -> Option { self.first_rail() }