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

refactor(geometry/geometry): Remove `.graph()` and its remaining usages 

This will allow us to store the dots, segs, bends differently than currently.
This commit is contained in:
Mikolaj Wielgus 2025-09-14 23:42:47 +02:00
parent f1e65267da
commit 50597653ad
9 changed files with 58 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/autorouter/ratsnest.rs
View File

@ -9,7 +9,7 @@ use std::{
use enum_dispatch::enum_dispatch; use enum_dispatch::enum_dispatch;
use geo::Point; use geo::Point;
use petgraph::{data::Element, prelude::StableUnGraph, visit::NodeIndexable}; use petgraph::{data::Element, prelude::StableUnGraph};
use spade::{handles::FixedVertexHandle, HasPosition, InsertionError, Point2}; use spade::{handles::FixedVertexHandle, HasPosition, InsertionError, Point2};
use crate::{ use crate::{

9
src/drawing/cane.rs
View File

@ -5,8 +5,7 @@
use super::{ use super::{
bend::LooseBendIndex, bend::LooseBendIndex,
dot::LooseDotIndex, dot::LooseDotIndex,
graph::PrimitiveIndex, primitive::{GetJoints, GetOtherJoint, LooseBendRef, LooseDotRef},
primitive::{GetInterior, GetJoints, GetOtherJoint, LooseBendRef, LooseDotRef},
rules::AccessRules, rules::AccessRules,
seg::SeqLooseSegIndex, seg::SeqLooseSegIndex,
Drawing, Drawing,
@ -37,12 +36,6 @@ impl Cane {
} }
} }
impl GetInterior<PrimitiveIndex> for Cane {
fn interior(&self) -> Vec<PrimitiveIndex> {
vec![self.bend.into(), self.dot.into(), self.seg.into()]
}
}
impl GetJoints for Cane { impl GetJoints for Cane {
type F = SeqLooseSegIndex; type F = SeqLooseSegIndex;
type T = LooseBendIndex; type T = LooseBendIndex;

137
src/drawing/drawing.rs
View File

@ -184,7 +184,7 @@ impl<CW, Cel, R> Drawing<CW, Cel, R> {
} }
pub fn node_count(&self) -> usize { pub fn node_count(&self) -> usize {
self.recording_geometry_with_rtree.graph().node_count() self.recording_geometry_with_rtree.node_count()
} }
} }
@ -293,9 +293,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
Ok(()) Ok(())
} }
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))] #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
pub fn add_fixed_dot( pub fn add_fixed_dot(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -304,15 +303,13 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
self.add_dot(recorder, weight, &|_drawing, _infringer, _infringee| true) self.add_dot(recorder, weight, &|_drawing, _infringer, _infringee| true)
} }
#[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() - 1))] #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() - 1))]
#[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
pub fn remove_fixed_dot(&mut self, recorder: &mut DrawingEdit<CW, Cel>, dot: FixedDotIndex) { pub fn remove_fixed_dot(&mut self, recorder: &mut DrawingEdit<CW, Cel>, dot: FixedDotIndex) {
self.recording_geometry_with_rtree self.recording_geometry_with_rtree
.remove_dot(recorder, dot.into()); .remove_dot(recorder, dot.into());
} }
#[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
#[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
pub fn add_fixed_dot_infringably( pub fn add_fixed_dot_infringably(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -321,8 +318,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
self.add_dot_infringably(recorder, weight) self.add_dot_infringably(recorder, weight)
} }
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))] #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
fn add_dot<W: AccessDotWeight + Into<PrimitiveWeight> + GetLayer>( fn add_dot<W: AccessDotWeight + Into<PrimitiveWeight> + GetLayer>(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -338,9 +335,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
Ok(dot) Ok(dot)
} }
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))] #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
pub fn add_fixed_seg( pub fn add_fixed_seg(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -357,8 +353,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
) )
} }
#[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
#[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 2))]
pub fn add_fixed_seg_infringably( pub fn add_fixed_seg_infringably(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -369,10 +364,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
self.add_seg_infringably(recorder, from.into(), to.into(), weight) self.add_seg_infringably(recorder, from.into(), to.into(), weight)
} }
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 2))] #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
pub fn add_lone_loose_seg( pub fn add_lone_loose_seg(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -390,10 +383,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
Ok(seg) Ok(seg)
} }
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 2))] #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
pub fn add_seq_loose_seg( pub fn add_seq_loose_seg(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -412,8 +403,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
Ok(seg) Ok(seg)
} }
#[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() - 1))] #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() - 1))]
#[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() - 2))]
pub fn remove_termseg( pub fn remove_termseg(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -423,10 +413,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
.remove_seg(recorder, termseg.into()) .remove_seg(recorder, termseg.into())
} }
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() >= old(self.recording_geometry_with_rtree.graph().edge_count() + 2))] #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
fn add_seg<W: AccessSegWeight + Into<PrimitiveWeight> + GetLayer>( fn add_seg<W: AccessSegWeight + Into<PrimitiveWeight> + GetLayer>(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -484,11 +472,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
Ok(seg) Ok(seg)
} }
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 3) #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
|| self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 4))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
fn add_loose_bend( fn add_loose_bend(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -530,10 +515,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
} }
} }
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))] #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 3))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
fn add_core_bend<W: AccessBendWeight + Into<PrimitiveWeight> + GetLayer>( fn add_core_bend<W: AccessBendWeight + Into<PrimitiveWeight> + GetLayer>(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -554,10 +537,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
Ok(bend) Ok(bend)
} }
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))] #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 4))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
fn add_outer_bend( fn add_outer_bend(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -567,29 +548,10 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
weight: LooseBendWeight, weight: LooseBendWeight,
filter: &impl Fn(&Self, PrimitiveIndex, PrimitiveIndex) -> bool, filter: &impl Fn(&Self, PrimitiveIndex, PrimitiveIndex) -> bool,
) -> Result<GenericIndex<LooseBendWeight>, Infringement> { ) -> Result<GenericIndex<LooseBendWeight>, Infringement> {
let core = *self let core = match inner {
.recording_geometry_with_rtree BendIndex::Fixed(bend) => self.primitive(bend).core(),
.graph() BendIndex::Loose(bend) => self.primitive(bend).core(),
.neighbors(inner.index().into()) };
.filter(|ni| {
matches!(
self.recording_geometry_with_rtree
.graph()
.edge_weight(
self.recording_geometry_with_rtree
.graph()
.find_edge(inner.index().into(), *ni)
.unwrap()
)
.unwrap(),
GeometryLabel::Core
)
})
.map(|node| FixedDotIndex::new(node.index()))
.collect::<Vec<FixedDotIndex>>()
.first()
.unwrap();
let bend = self.recording_geometry_with_rtree.add_bend( let bend = self.recording_geometry_with_rtree.add_bend(
recorder, recorder,
from.into(), from.into(),
@ -604,17 +566,13 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
Ok(bend) Ok(bend)
} }
#[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))] #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
pub fn flip_bend(&mut self, recorder: &mut DrawingEdit<CW, Cel>, bend: FixedBendIndex) { pub fn flip_bend(&mut self, recorder: &mut DrawingEdit<CW, Cel>, bend: FixedBendIndex) {
self.recording_geometry_with_rtree self.recording_geometry_with_rtree
.flip_bend(recorder, bend.into()); .flip_bend(recorder, bend.into());
} }
#[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))] #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count())
|| self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() - 1)
|| self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 1))]
fn reattach_bend( fn reattach_bend(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -628,10 +586,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
); );
} }
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 4))] #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 4))]
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() >= old(self.recording_geometry_with_rtree.graph().edge_count() + 5))] #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
pub fn insert_cane( pub fn insert_cane(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -670,8 +626,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
Ok(cane) Ok(cane)
} }
#[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))] #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
fn update_this_and_outward_bows( fn update_this_and_outward_bows(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -751,10 +706,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
Ok(()) Ok(())
} }
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 4))] #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 4))]
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() >= old(self.recording_geometry_with_rtree.graph().edge_count() + 5))] #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
pub fn add_cane( pub fn add_cane(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -820,7 +773,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
}) })
} }
#[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() - 4))] #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() - 4))]
pub fn remove_cane( pub fn remove_cane(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -856,8 +809,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
Cane::from_dot(dot, self) Cane::from_dot(dot, self)
} }
#[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))] #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
pub fn move_dot( pub fn move_dot(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -880,8 +832,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
} }
} }
#[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))] #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
fn move_dot_with_infringement_filtering( fn move_dot_with_infringement_filtering(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -916,8 +867,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
Ok(()) Ok(())
} }
#[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))] #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
fn shift_bend_with_infringement_filtering( fn shift_bend_with_infringement_filtering(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -945,8 +895,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
} }
impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> { impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
#[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
#[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
fn add_dot_infringably<W: AccessDotWeight + Into<PrimitiveWeight> + GetLayer>( fn add_dot_infringably<W: AccessDotWeight + Into<PrimitiveWeight> + GetLayer>(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -958,8 +907,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
self.recording_geometry_with_rtree.add_dot(recorder, weight) self.recording_geometry_with_rtree.add_dot(recorder, weight)
} }
#[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
#[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 2))]
fn add_seg_infringably<W: AccessSegWeight + Into<PrimitiveWeight> + GetLayer>( fn add_seg_infringably<W: AccessSegWeight + Into<PrimitiveWeight> + GetLayer>(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,
@ -1007,9 +955,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
); );
} }
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))] #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
#[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))] #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() - 1))]
#[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() - 1))]
fn fail_and_remove_if_infringes_except( fn fail_and_remove_if_infringes_except(
&mut self, &mut self,
recorder: &mut DrawingEdit<CW, Cel>, recorder: &mut DrawingEdit<CW, Cel>,

30
src/drawing/primitive.rs
View File

@ -13,7 +13,7 @@ use crate::{
seg::{FixedSegWeight, LoneLooseSegWeight, SegIndex, SeqLooseSegIndex, SeqLooseSegWeight}, seg::{FixedSegWeight, LoneLooseSegWeight, SegIndex, SeqLooseSegIndex, SeqLooseSegWeight},
Drawing, Drawing,
}, },
geometry::{primitive::PrimitiveShape, GenericNode, GetLayer, GetOffset, GetWidth, Retag}, geometry::{primitive::PrimitiveShape, GetLayer, GetOffset, GetWidth},
graph::{GenericIndex, GetIndex}, graph::{GenericIndex, GetIndex},
}; };
@ -55,10 +55,6 @@ pub trait GetLimbs {
} }
} }
pub trait GetInterior<T> {
fn interior(&self) -> Vec<T>;
}
pub trait GetOtherJoint: GetJoints { pub trait GetOtherJoint: GetJoints {
type J; type J;
fn other_joint(&self, end: Self::J) -> Self::J; fn other_joint(&self, end: Self::J) -> Self::J;
@ -117,7 +113,9 @@ macro_rules! impl_primitive {
impl<CW, Cel, R> GetWeight for $primitive_refstruct<'_, CW, Cel, R> { impl<CW, Cel, R> GetWeight for $primitive_refstruct<'_, CW, Cel, R> {
type Weight = $weight_struct; type Weight = $weight_struct;
fn weight(&self) -> $weight_struct { fn weight(&self) -> $weight_struct {
if let PrimitiveWeight::$primitive_variant(weight) = self.tagged_weight() { if let PrimitiveWeight::$primitive_variant(weight) =
self.drawing.geometry().primitive_weight(self.index.index())
{
weight weight
} else { } else {
unreachable!() unreachable!()
@ -193,26 +191,6 @@ impl<'a, W, CW, Cel, R> GenericPrimitive<'a, W, CW, Cel, R> {
pub fn new(index: GenericIndex<W>, drawing: &'a Drawing<CW, Cel, R>) -> Self { pub fn new(index: GenericIndex<W>, drawing: &'a Drawing<CW, Cel, R>) -> Self {
Self { index, drawing } Self { index, drawing }
} }
fn tagged_weight(&self) -> PrimitiveWeight {
if let GenericNode::Primitive(weight) = self
.drawing
.geometry()
.graph()
.node_weight(self.index.index().into())
.unwrap()
{
*weight
} else {
unreachable!()
}
}
}
impl<W, CW, Cel, R> GetInterior<PrimitiveIndex> for GenericPrimitive<'_, W, CW, Cel, R> {
fn interior(&self) -> Vec<PrimitiveIndex> {
vec![self.tagged_weight().retag(self.index.index())]
}
} }
impl<W, CW, Cel, R> GetDrawing for GenericPrimitive<'_, W, CW, Cel, R> { impl<W, CW, Cel, R> GetDrawing for GenericPrimitive<'_, W, CW, Cel, R> {

10
src/geometry/geometry.rs
View File

@ -141,15 +141,11 @@ impl<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI> Geometry<PW, DW, SW, BW, CW, Cel,
} }
} }
// we could use `derive_getters` to generate these, but `Geometry` only wraps a single pub fn node_count(&self) -> usize {
// field that actually contains data... self.graph.node_count()
#[inline(always)]
pub fn graph(&self) -> &StableDiGraph<GenericNode<PW, CW>, GeometryLabel<Cel>, usize> {
&self.graph
} }
fn primitive_weight(&self, index: usize) -> PW pub fn primitive_weight(&self, index: usize) -> PW
where where
PW: Copy, PW: Copy,
{ {

4
src/geometry/recording_with_rtree.rs
View File

@ -48,8 +48,8 @@ impl<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>
*self.geometry_with_rtree.layer_count() *self.geometry_with_rtree.layer_count()
} }
pub fn graph(&self) -> &StableDiGraph<GenericNode<PW, CW>, GeometryLabel<Cel>, usize> { pub fn node_count(&self) -> usize {
self.geometry_with_rtree.graph() self.geometry_with_rtree.node_count()
} }
} }

4
src/geometry/with_rtree.rs
View File

@ -62,8 +62,8 @@ impl<PW: Clone, DW, SW, BW, CW: Clone, Cel: Clone, PI: Clone, DI, SI, BI> Clone
impl<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI> impl<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>
GeometryWithRtree<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI> GeometryWithRtree<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>
{ {
pub fn graph(&self) -> &StableDiGraph<GenericNode<PW, CW>, GeometryLabel<Cel>, usize> { pub fn node_count(&self) -> usize {
self.geometry.graph() self.geometry.node_count()
} }
} }

9
src/layout/layout.rs
View File

@ -356,15 +356,12 @@ impl<R: AccessRules> Layout<R> {
fn handle_fixed_dot<R: AccessRules>( fn handle_fixed_dot<R: AccessRules>(
drawing: &Drawing<CompoundWeight, CompoundEntryLabel, R>, drawing: &Drawing<CompoundWeight, CompoundEntryLabel, R>,
index: PrimitiveIndex, index: PrimitiveIndex,
) -> Option<(FixedDotIndex, &FixedDotWeight)> { ) -> Option<(FixedDotIndex, FixedDotWeight)> {
let PrimitiveIndex::FixedDot(dot) = index else { let PrimitiveIndex::FixedDot(dot) = index else {
return None; return None;
}; };
if let GenericNode::Primitive(PrimitiveWeight::FixedDot(weight)) = drawing if let PrimitiveWeight::FixedDot(weight) =
.geometry() drawing.geometry().primitive_weight(dot.index())
.graph()
.node_weight(dot.index().into())
.unwrap()
{ {
Some((dot, weight)) Some((dot, weight))
} else { } else {

1
src/router/prenavmesh.rs
View File

@ -7,7 +7,6 @@ use std::ops::{Index, IndexMut};
use derive_getters::Getters; use derive_getters::Getters;
use enum_dispatch::enum_dispatch; use enum_dispatch::enum_dispatch;
use geo::Point; use geo::Point;
use petgraph::visit::NodeIndexable;
use spade::{handles::FixedVertexHandle, HasPosition, InsertionError, Point2}; use spade::{handles::FixedVertexHandle, HasPosition, InsertionError, Point2};
use crate::{ use crate::{