From 9007b850c4bb579027262face62527de2f6627be Mon Sep 17 00:00:00 2001 From: Mikolaj Wielgus Date: Tue, 16 Jan 2024 01:31:36 +0000 Subject: [PATCH] geometry: rename `Index` to `GeometryIndex` --- src/draw.rs | 8 ++-- src/geometry.rs | 38 ++++++++-------- src/graph.rs | 2 +- src/layout.rs | 111 ++++++++++++++++++++++++----------------------- src/main.rs | 4 +- src/mesh.rs | 8 ++-- src/primitive.rs | 12 ++--- src/segbend.rs | 6 +-- 8 files changed, 95 insertions(+), 94 deletions(-) diff --git a/src/draw.rs b/src/draw.rs index f1b8672..00429f3 100644 --- a/src/draw.rs +++ b/src/draw.rs @@ -3,16 +3,14 @@ use geo::{EuclideanLength, Point}; use thiserror::Error; use crate::{ - connectivity::{ComponentIndex, GetNet}, geometry::{ - BendIndex, DotIndex, FixedDotIndex, FixedSegWeight, GetBandIndex, GetComponentIndex, - LoneLooseSegWeight, LooseBendWeight, LooseDotIndex, LooseDotWeight, MakePrimitive, - SeqLooseSegWeight, WraparoundableIndex, + BendIndex, DotIndex, FixedDotIndex, GetBandIndex, LoneLooseSegWeight, LooseBendWeight, + LooseDotIndex, LooseDotWeight, MakePrimitive, SeqLooseSegWeight, WraparoundableIndex, }, guide::{Guide, Head, HeadTrait, SegbendHead}, layout::{Infringement, Layout, LayoutException}, math::{Circle, NoTangents}, - primitive::{GetOtherEnd, GetWeight}, + primitive::GetOtherEnd, rules::{Conditions, Rules}, }; diff --git a/src/geometry.rs b/src/geometry.rs index 1fde656..2e834a8 100644 --- a/src/geometry.rs +++ b/src/geometry.rs @@ -2,7 +2,7 @@ use enum_dispatch::enum_dispatch; use petgraph::stable_graph::{NodeIndex, StableDiGraph}; use crate::{ - connectivity::{BandIndex, BandWeight, ComponentIndex, ComponentWeight, ConnectivityWeight}, + connectivity::{BandIndex, ComponentIndex}, graph::GenericIndex, layout::Layout, math::Circle, @@ -11,7 +11,7 @@ use crate::{ #[enum_dispatch] pub trait Retag { - fn retag(&self, index: NodeIndex) -> Index; + fn retag(&self, index: NodeIndex) -> GeometryIndex; } #[enum_dispatch] @@ -39,8 +39,8 @@ pub trait GetOffset { macro_rules! impl_weight { ($weight_struct:ident, $weight_variant:ident, $index_struct:ident) => { impl Retag for $weight_struct { - fn retag(&self, index: NodeIndex) -> Index { - Index::$weight_variant($index_struct::new(index)) + fn retag(&self, index: NodeIndex) -> GeometryIndex { + GeometryIndex::$weight_variant($index_struct::new(index)) } } @@ -100,7 +100,7 @@ pub enum GeometryWeight { #[enum_dispatch(GetNodeIndex, MakePrimitive)] #[derive(Debug, Clone, Copy, PartialEq)] -pub enum Index { +pub enum GeometryIndex { FixedDot(FixedDotIndex), LooseDot(LooseDotIndex), FixedSeg(FixedSegIndex), @@ -117,11 +117,11 @@ pub enum DotIndex { Loose(LooseDotIndex), } -impl From for Index { +impl From for GeometryIndex { fn from(dot: DotIndex) -> Self { match dot { - DotIndex::Fixed(fixed) => Index::FixedDot(fixed), - DotIndex::Loose(loose) => Index::LooseDot(loose), + DotIndex::Fixed(fixed) => GeometryIndex::FixedDot(fixed), + DotIndex::Loose(loose) => GeometryIndex::LooseDot(loose), } } } @@ -134,12 +134,12 @@ pub enum SegIndex { SeqLoose(SeqLooseSegIndex), } -impl From for Index { +impl From for GeometryIndex { fn from(seg: SegIndex) -> Self { match seg { - SegIndex::Fixed(seg) => Index::FixedSeg(seg), - SegIndex::LoneLoose(seg) => Index::LoneLooseSeg(seg), - SegIndex::SeqLoose(seg) => Index::SeqLooseSeg(seg), + SegIndex::Fixed(seg) => GeometryIndex::FixedSeg(seg), + SegIndex::LoneLoose(seg) => GeometryIndex::LoneLooseSeg(seg), + SegIndex::SeqLoose(seg) => GeometryIndex::SeqLooseSeg(seg), } } } @@ -151,11 +151,11 @@ pub enum BendIndex { Loose(LooseBendIndex), } -impl From for Index { +impl From for GeometryIndex { fn from(bend: BendIndex) -> Self { match bend { - BendIndex::Fixed(bend) => Index::FixedBend(bend), - BendIndex::Loose(bend) => Index::LooseBend(bend), + BendIndex::Fixed(bend) => GeometryIndex::FixedBend(bend), + BendIndex::Loose(bend) => GeometryIndex::LooseBend(bend), } } } @@ -177,12 +177,12 @@ pub enum WraparoundableIndex { LooseBend(LooseBendIndex), } -impl From for Index { +impl From for GeometryIndex { fn from(wraparoundable: WraparoundableIndex) -> Self { match wraparoundable { - WraparoundableIndex::FixedDot(dot) => Index::FixedDot(dot), - WraparoundableIndex::FixedBend(bend) => Index::FixedBend(bend), - WraparoundableIndex::LooseBend(bend) => Index::LooseBend(bend), + WraparoundableIndex::FixedDot(dot) => GeometryIndex::FixedDot(dot), + WraparoundableIndex::FixedBend(bend) => GeometryIndex::FixedBend(bend), + WraparoundableIndex::LooseBend(bend) => GeometryIndex::LooseBend(bend), } } } diff --git a/src/graph.rs b/src/graph.rs index f2a5b01..a68dbe2 100644 --- a/src/graph.rs +++ b/src/graph.rs @@ -8,7 +8,7 @@ use petgraph::stable_graph::NodeIndex; // Due to apparent limitations of enum_dispatch we're forced to import some types backwards. -use crate::geometry::{BendIndex, DotIndex, Index, SegIndex, WraparoundableIndex}; +use crate::geometry::{BendIndex, DotIndex, GeometryIndex, SegIndex, WraparoundableIndex}; #[enum_dispatch] pub trait GetNodeIndex { diff --git a/src/layout.rs b/src/layout.rs index 318eed2..f2c66df 100644 --- a/src/layout.rs +++ b/src/layout.rs @@ -14,10 +14,9 @@ use crate::connectivity::{ }; use crate::geometry::{ BendWeight, DotIndex, DotWeight, FixedBendIndex, FixedDotIndex, FixedDotWeight, FixedSegIndex, - FixedSegWeight, GeometryGraph, GeometryLabel, GeometryWeight, GetComponentIndex, Index, - LoneLooseSegIndex, LoneLooseSegWeight, LooseBendIndex, LooseBendWeight, LooseDotIndex, - LooseDotWeight, MakePrimitive, Retag, SegWeight, SeqLooseSegIndex, SeqLooseSegWeight, - WraparoundableIndex, + FixedSegWeight, GeometryGraph, GeometryIndex, GeometryLabel, GeometryWeight, LoneLooseSegIndex, + LoneLooseSegWeight, LooseBendIndex, LooseBendWeight, LooseDotIndex, LooseDotWeight, + MakePrimitive, Retag, SegWeight, SeqLooseSegIndex, SeqLooseSegWeight, WraparoundableIndex, }; use crate::graph::{GenericIndex, GetNodeIndex}; use crate::guide::Guide; @@ -29,7 +28,7 @@ use crate::primitive::{ use crate::segbend::Segbend; use crate::shape::{Shape, ShapeTrait}; -pub type RTreeWrapper = GeomWithData; +pub type RTreeWrapper = GeomWithData; #[enum_dispatch] #[derive(Error, Debug, Clone, Copy)] @@ -47,15 +46,15 @@ pub enum LayoutException { // TODO add real error messages + these should eventually use Display #[derive(Error, Debug, Clone, Copy)] #[error("{0:?} infringes on {1:?}")] -pub struct Infringement(pub Shape, pub Index); +pub struct Infringement(pub Shape, pub GeometryIndex); #[derive(Error, Debug, Clone, Copy)] #[error("{0:?} collides with {1:?}")] -pub struct Collision(pub Shape, pub Index); +pub struct Collision(pub Shape, pub GeometryIndex); #[derive(Error, Debug, Clone, Copy)] #[error("{1:?} is already connected to net {0}")] -pub struct AlreadyConnected(pub i64, pub Index); +pub struct AlreadyConnected(pub i64, pub GeometryIndex); #[derive(Debug)] pub struct Layout { @@ -99,12 +98,12 @@ impl Layout { } #[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count() - 1))] - fn remove(&mut self, index: Index) { + fn remove(&mut self, node: GeometryIndex) { // Unnecessary retag. It should be possible to elide it. - let weight = *self.geometry.node_weight(index.node_index()).unwrap(); + let weight = *self.geometry.node_weight(node.node_index()).unwrap(); - self.remove_from_rtree(weight.retag(index.node_index())); - self.geometry.remove_node(index.node_index()); + self.remove_from_rtree(weight.retag(node.node_index())); + self.geometry.remove_node(node.node_index()); } // TODO: This method shouldn't be public. @@ -149,10 +148,10 @@ impl Layout { fn add_dot_infringably( &mut self, weight: W, - infringables: &[Index], + infringables: &[GeometryIndex], ) -> Result, Infringement> where - GenericIndex: Into + Copy, + GenericIndex: Into + Copy, { let dot = GenericIndex::::new(self.geometry.add_node(weight.into())); @@ -228,7 +227,7 @@ impl Layout { #[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] - fn inner_bow_and_outer_bow(&self, bend: LooseBendIndex) -> Vec { + fn inner_bow_and_outer_bow(&self, bend: LooseBendIndex) -> Vec { let bend_primitive = self.primitive(bend); let mut v = vec![]; @@ -248,7 +247,7 @@ impl Layout { #[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] - fn inner_bow_and_outer_bows(&self, bend: LooseBendIndex) -> Vec { + fn inner_bow_and_outer_bows(&self, bend: LooseBendIndex) -> Vec { let bend_primitive = self.primitive(bend); let mut v = vec![]; @@ -271,7 +270,7 @@ impl Layout { #[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] - fn this_and_wraparound_bow(&self, around: WraparoundableIndex) -> Vec { + fn this_and_wraparound_bow(&self, around: WraparoundableIndex) -> Vec { match around { WraparoundableIndex::FixedDot(dot) => { let mut v = vec![around.into()]; @@ -300,8 +299,8 @@ impl Layout { // XXX: Move this to primitives? #[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] - fn bow(&self, bend: LooseBendIndex) -> Vec { - let mut bow: Vec = vec![]; + fn bow(&self, bend: LooseBendIndex) -> Vec { + let mut bow: Vec = vec![]; bow.push(bend.into()); let ends = self.primitive(bend).ends(); @@ -321,7 +320,7 @@ impl Layout { #[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] - fn outer_bows(&self, bend: LooseBendIndex) -> Vec { + fn outer_bows(&self, bend: LooseBendIndex) -> Vec { let mut outer_bows = vec![]; let mut rail = bend; @@ -473,7 +472,7 @@ impl Layout { dot_weight: LooseDotWeight, seg_weight: SeqLooseSegWeight, bend_weight: LooseBendWeight, - infringables: &[Index], + infringables: &[GeometryIndex], ) -> Result { let seg_to = self.add_dot_infringably(dot_weight, infringables)?; let seg = self @@ -541,10 +540,10 @@ impl Layout { from: impl GetNodeIndex, to: impl GetNodeIndex, weight: W, - infringables: &[Index], + infringables: &[GeometryIndex], ) -> Result, Infringement> where - GenericIndex: Into + Copy, + GenericIndex: Into + Copy, { let seg = GenericIndex::::new(self.geometry.add_node(weight.into())); @@ -565,12 +564,12 @@ impl Layout { &mut self, from: FixedDotIndex, to: FixedDotIndex, - around: Index, + around: GeometryIndex, weight: FixedBendWeight, ) -> Result { match around { - Index::FixedDot(core) => self.add_core_bend(from, to, core, weight), - Index::FixedBend(around) => self.add_outer_bend(from, to, around, weight), + GeometryIndex::FixedDot(core) => self.add_core_bend(from, to, core, weight), + GeometryIndex::FixedBend(around) => self.add_outer_bend(from, to, around, weight), _ => unreachable!(), } }*/ @@ -586,7 +585,7 @@ impl Layout { to: LooseDotIndex, around: WraparoundableIndex, weight: LooseBendWeight, - infringables: &[Index], + infringables: &[GeometryIndex], ) -> Result { // It makes no sense to wrap something around or under one of its connectables. let net = self @@ -632,10 +631,10 @@ impl Layout { to: impl GetNodeIndex, core: FixedDotIndex, weight: W, - infringables: &[Index], + infringables: &[GeometryIndex], ) -> Result where - GenericIndex: Into + Copy, + GenericIndex: Into + Copy, { let bend = LooseBendIndex::new(self.geometry.add_node(weight.into())); @@ -664,7 +663,7 @@ impl Layout { to: impl GetNodeIndex, inner: impl GetNodeIndex, weight: W, - infringables: &[Index], + infringables: &[GeometryIndex], ) -> Result { let core = *self .geometry @@ -730,17 +729,17 @@ impl Layout { #[debug_ensures(ret.is_err() -> self.geometry.node_count() == old(self.geometry.node_count() - 1))] fn fail_and_remove_if_infringes_except( &mut self, - index: Index, - except: &[Index], + node: GeometryIndex, + except: &[GeometryIndex], ) -> Result<(), Infringement> { - if let Some(infringement) = self.detect_infringement_except(index, except) { - self.remove(index); + if let Some(infringement) = self.detect_infringement_except(node, except) { + self.remove(node); return Err(infringement); } Ok(()) } - pub fn nodes(&self) -> impl Iterator + '_ { + pub fn nodes(&self) -> impl Iterator + '_ { self.rtree.iter().map(|wrapper| wrapper.data) } @@ -752,7 +751,7 @@ impl Layout { self.geometry.node_count() } - fn node_indices(&self) -> impl Iterator + '_ { + fn node_indices(&self) -> impl Iterator + '_ { self.rtree.iter().map(|wrapper| wrapper.data) } } @@ -773,7 +772,7 @@ impl Layout { &mut self, dot: LooseDotIndex, to: Point, - infringables: &[Index], + infringables: &[GeometryIndex], ) -> Result<(), Infringement> { self.primitive(dot) .seg() @@ -812,14 +811,18 @@ impl Layout { #[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] - fn detect_infringement_except(&self, index: Index, except: &[Index]) -> Option { - let shape = index.primitive(self).shape(); + fn detect_infringement_except( + &self, + node: GeometryIndex, + except: &[GeometryIndex], + ) -> Option { + let shape = node.primitive(self).shape(); self.rtree .locate_in_envelope_intersecting(&RTreeObject::envelope(&shape)) .filter(|wrapper| { let other_index = wrapper.data; - !index.primitive(self).connectable(other_index) + !node.primitive(self).connectable(other_index) }) .filter(|wrapper| !except.contains(&wrapper.data)) .filter(|wrapper| shape.intersects(wrapper.geom())) @@ -831,14 +834,14 @@ impl Layout { // TODO: Collision and infringement are the same for now. Change this. #[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] - fn detect_collision(&self, index: Index) -> Option { - let shape = index.primitive(self).shape(); + fn detect_collision(&self, node: GeometryIndex) -> Option { + let shape = node.primitive(self).shape(); self.rtree .locate_in_envelope_intersecting(&RTreeObject::envelope(&shape)) .filter(|wrapper| { let other_index = wrapper.data; - !index.primitive(self).connectable(other_index) + !node.primitive(self).connectable(other_index) }) .filter(|wrapper| shape.intersects(wrapper.geom())) .map(|wrapper| wrapper.data) @@ -848,16 +851,16 @@ impl Layout { #[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] - fn insert_into_rtree(&mut self, index: Index) { - let shape = index.primitive(self).shape(); - self.rtree.insert(RTreeWrapper::new(shape, index)); + fn insert_into_rtree(&mut self, node: GeometryIndex) { + let shape = node.primitive(self).shape(); + self.rtree.insert(RTreeWrapper::new(shape, node)); } #[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] - fn remove_from_rtree(&mut self, index: Index) { - let shape = index.primitive(self).shape(); - let removed_element = self.rtree.remove(&RTreeWrapper::new(shape, index)); + fn remove_from_rtree(&mut self, node: GeometryIndex) { + let shape = node.primitive(self).shape(); + let removed_element = self.rtree.remove(&RTreeWrapper::new(shape, node)); debug_assert!(removed_element.is_some()); } } @@ -877,15 +880,15 @@ impl Layout { #[debug_ensures(self.geometry.node_count() == old(self.geometry.node_count()))] #[debug_ensures(self.geometry.edge_count() == old(self.geometry.edge_count()))] - pub fn primitive(&self, index: GenericIndex) -> GenericPrimitive { - GenericPrimitive::new(index, self) + pub fn primitive(&self, node: GenericIndex) -> GenericPrimitive { + GenericPrimitive::new(node, self) } fn test_envelopes(&self) -> bool { !self.rtree.iter().any(|wrapper| { - let index = wrapper.data; - let shape = index.primitive(self).shape(); - let wrapper = RTreeWrapper::new(shape, index); + let node = wrapper.data; + let shape = node.primitive(self).shape(); + let wrapper = RTreeWrapper::new(shape, node); !self .rtree .locate_in_envelope(&RTreeObject::envelope(&shape)) diff --git a/src/main.rs b/src/main.rs index ec6bee2..97726bd 100644 --- a/src/main.rs +++ b/src/main.rs @@ -27,7 +27,7 @@ mod triangulation; use draw::DrawException; use geo::point; -use geometry::{FixedDotIndex, FixedSegWeight, Index, LooseDotIndex, MakePrimitive}; +use geometry::{FixedDotIndex, FixedSegWeight, GeometryIndex, LooseDotIndex, MakePrimitive}; use layout::{Infringement, Layout, LayoutException}; use mesh::{Mesh, MeshEdgeReference, VertexIndex}; use petgraph::visit::{EdgeRef, IntoEdgeReferences}; @@ -582,7 +582,7 @@ fn render_times( mut mesh: Option, path: &[VertexIndex], ghosts: &[Shape], - highlighteds: &[Index], + highlighteds: &[GeometryIndex], times: i64, ) { let mut i = 0; diff --git a/src/mesh.rs b/src/mesh.rs index 52e571f..9d4b796 100644 --- a/src/mesh.rs +++ b/src/mesh.rs @@ -10,7 +10,7 @@ use spade::{HasPosition, InsertionError, Point2}; use crate::primitive::{GetCore, Primitive}; use crate::triangulation::TriangulationEdgeReference; use crate::{ - geometry::{FixedBendIndex, FixedDotIndex, Index, LooseBendIndex, MakePrimitive}, + geometry::{FixedBendIndex, FixedDotIndex, GeometryIndex, LooseBendIndex, MakePrimitive}, graph::GetNodeIndex, layout::Layout, primitive::MakeShape, @@ -84,14 +84,14 @@ impl Mesh { let center = node.primitive(layout).shape().center(); match node { - Index::FixedDot(dot) => { + GeometryIndex::FixedDot(dot) => { self.triangulation.add_vertex(TriangulationWeight { vertex: dot.into(), rails: vec![], pos: center, })?; } - Index::FixedBend(bend) => { + GeometryIndex::FixedBend(bend) => { self.triangulation.add_vertex(TriangulationWeight { vertex: bend.into(), rails: vec![], @@ -105,7 +105,7 @@ impl Mesh { for node in layout.nodes() { // Add rails as vertices. This is how the mesh differs from the triangulation. match node { - Index::LooseBend(bend) => { + GeometryIndex::LooseBend(bend) => { self.triangulation .weight_mut(layout.primitive(bend).core().into()) .rails diff --git a/src/primitive.rs b/src/primitive.rs index 06e37fd..7378dc6 100644 --- a/src/primitive.rs +++ b/src/primitive.rs @@ -6,8 +6,8 @@ use petgraph::Direction::{Incoming, Outgoing}; use crate::connectivity::GetNet; use crate::geometry::{ - DotIndex, FixedBendWeight, FixedDotIndex, FixedDotWeight, FixedSegWeight, GeometryLabel, - GeometryWeight, GetBandIndex, GetComponentIndex, GetOffset, GetWidth, Index, + DotIndex, FixedBendWeight, FixedDotIndex, FixedDotWeight, FixedSegWeight, GeometryIndex, + GeometryLabel, GeometryWeight, GetBandIndex, GetComponentIndex, GetOffset, GetWidth, LoneLooseSegWeight, LooseBendIndex, LooseBendWeight, LooseDotIndex, LooseDotWeight, MakePrimitive, Retag, SeqLooseSegIndex, SeqLooseSegWeight, }; @@ -23,9 +23,9 @@ pub trait GetLayout { #[enum_dispatch] pub trait GetConnectable: GetNet + GetLayout { - fn connectable(&self, index: Index) -> bool { + fn connectable(&self, node: GeometryIndex) -> bool { let this = self.net(); - let other = index.primitive(self.layout()).net(); + let other = node.primitive(self.layout()).net(); (this == other) || this == -1 || other == -1 } @@ -262,8 +262,8 @@ impl<'a, W> GenericPrimitive<'a, W> { } } -impl<'a, W> GetInterior for GenericPrimitive<'a, W> { - fn interior(&self) -> Vec { +impl<'a, W> GetInterior for GenericPrimitive<'a, W> { + fn interior(&self) -> Vec { vec![self.tagged_weight().retag(self.index.node_index())] } } diff --git a/src/segbend.rs b/src/segbend.rs index 22253ba..1b98343 100644 --- a/src/segbend.rs +++ b/src/segbend.rs @@ -1,5 +1,5 @@ use crate::{ - geometry::{Index, LooseBendIndex, LooseDotIndex, SeqLooseSegIndex}, + geometry::{GeometryIndex, LooseBendIndex, LooseDotIndex, SeqLooseSegIndex}, layout::Layout, primitive::{GetEnds, GetInterior, GetOtherEnd, LooseBend, LooseDot}, }; @@ -20,8 +20,8 @@ impl Segbend { } } -impl GetInterior for Segbend { - fn interior(&self) -> Vec { +impl GetInterior for Segbend { + fn interior(&self) -> Vec { vec![self.bend.into(), self.dot.into(), self.seg.into()] } }