From f91dadf4d3a4f2212fd52e7ae9b7c3b106004eb2 Mon Sep 17 00:00:00 2001 From: Mikolaj Wielgus Date: Tue, 11 Jun 2024 23:57:47 +0200 Subject: [PATCH] drawing,layout,board: categorize methods as possibly infringing and not --- src/board/board.rs | 37 ++--- src/drawing/drawing.rs | 65 ++++++-- src/dsn/design.rs | 346 +++++++++++++++++++---------------------- src/layout/layout.rs | 35 +++++ 4 files changed, 262 insertions(+), 221 deletions(-) diff --git a/src/board/board.rs b/src/board/board.rs index d4d88d6..be5236f 100644 --- a/src/board/board.rs +++ b/src/board/board.rs @@ -36,68 +36,70 @@ impl Board { } } - pub fn add_fixed_dot( + pub fn add_fixed_dot_infringably( &mut self, weight: FixedDotWeight, maybe_pin: Option, - ) -> Result { - let dot = self.layout.add_fixed_dot(weight)?; + ) -> FixedDotIndex { + let dot = self.layout.add_fixed_dot_infringably(weight); if let Some(ref pin) = maybe_pin { self.node_to_pinname .insert(GenericNode::Primitive(dot.into()), pin.clone()); } - Ok(dot) + dot } - pub fn add_zone_fixed_dot( + pub fn add_zone_fixed_dot_infringably( &mut self, weight: FixedDotWeight, zone: GenericIndex, - ) -> Result { - let dot = self.layout.add_zone_fixed_dot(weight, zone)?; + ) -> FixedDotIndex { + let dot = self.layout.add_zone_fixed_dot_infringably(weight, zone); if let Some(pin) = self.node_pinname(GenericNode::Compound(zone.into())) { self.node_to_pinname .insert(GenericNode::Primitive(dot.into()), pin.to_string()); } - Ok(dot) + dot } - pub fn add_fixed_seg( + pub fn add_fixed_seg_infringably( &mut self, from: FixedDotIndex, to: FixedDotIndex, weight: FixedSegWeight, maybe_pin: Option, - ) -> Result { - let seg = self.layout.add_fixed_seg(from, to, weight)?; + ) -> FixedSegIndex { + let seg = self.layout.add_fixed_seg_infringably(from, to, weight); if let Some(pin) = maybe_pin { self.node_to_pinname .insert(GenericNode::Primitive(seg.into()), pin.to_string()); } - Ok(seg) + seg } - pub fn add_zone_fixed_seg( + pub fn add_zone_fixed_seg_infringably( &mut self, from: FixedDotIndex, to: FixedDotIndex, weight: FixedSegWeight, zone: GenericIndex, - ) -> Result { - let seg = self.layout.add_zone_fixed_seg(from, to, weight, zone)?; + ) -> FixedSegIndex { + let seg = self + .layout + .add_zone_fixed_seg_infringably(from, to, weight, zone); if let Some(pin) = self.node_pinname(GenericNode::Compound(zone.into())) { self.node_to_pinname .insert(GenericNode::Primitive(seg.into()), pin.to_string()); } - Ok(seg) + seg } pub fn add_zone( @@ -145,7 +147,7 @@ impl Board { if let Some(apex) = self.layout.zone(zone).maybe_apex() { apex } else { - self.add_zone_fixed_dot( + self.add_zone_fixed_dot_infringably( FixedDotWeight { circle: Circle { pos: self.layout.zone(zone).shape().center(), @@ -156,7 +158,6 @@ impl Board { }, zone, ) - .unwrap() } } diff --git a/src/drawing/drawing.rs b/src/drawing/drawing.rs index 6bd4012..fed8075 100644 --- a/src/drawing/drawing.rs +++ b/src/drawing/drawing.rs @@ -148,14 +148,16 @@ impl Drawing { } } - #[debug_ensures(ret.is_ok() -> self.geometry_with_rtree.graph().node_count() == old(self.geometry_with_rtree.graph().node_count() + 1))] - #[debug_ensures(ret.is_err() -> self.geometry_with_rtree.graph().node_count() == old(self.geometry_with_rtree.graph().node_count()))] + #[debug_ensures(self.geometry_with_rtree.graph().node_count() == old(self.geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(self.geometry_with_rtree.graph().edge_count() == old(self.geometry_with_rtree.graph().edge_count()))] - pub fn add_fixed_dot_infringably( - &mut self, - weight: FixedDotWeight, - ) -> Result { - self.add_dot_with_infringables(weight, None) + pub fn add_fixed_dot(&mut self, weight: FixedDotWeight) -> Result { + self.add_dot_with_infringables(weight, Some(&[])) + } + + #[debug_ensures(self.geometry_with_rtree.graph().node_count() == old(self.geometry_with_rtree.graph().node_count() + 1))] + #[debug_ensures(self.geometry_with_rtree.graph().edge_count() == old(self.geometry_with_rtree.graph().edge_count()))] + pub fn add_fixed_dot_infringably(&mut self, weight: FixedDotWeight) -> FixedDotIndex { + self.add_dot_infringably(weight) } #[debug_ensures(ret.is_ok() -> self.geometry_with_rtree.graph().node_count() == old(self.geometry_with_rtree.graph().node_count() + 1))] @@ -168,23 +170,44 @@ impl Drawing { where GenericIndex: Into + Copy, { - let dot = self.geometry_with_rtree.add_dot(weight); + let dot = self.add_dot_infringably(weight); self.fail_and_remove_if_infringes_except(dot.into(), infringables)?; Ok(dot) } - #[debug_ensures(ret.is_ok() -> self.geometry_with_rtree.graph().node_count() == old(self.geometry_with_rtree.graph().node_count() + 1))] - #[debug_ensures(ret.is_ok() -> self.geometry_with_rtree.graph().edge_count() == old(self.geometry_with_rtree.graph().edge_count() + 2))] - #[debug_ensures(ret.is_err() -> self.geometry_with_rtree.graph().node_count() == old(self.geometry_with_rtree.graph().node_count()))] - #[debug_ensures(ret.is_err() -> self.geometry_with_rtree.graph().edge_count() == old(self.geometry_with_rtree.graph().edge_count()))] - pub fn add_fixed_seg_infringably( + #[debug_ensures(self.geometry_with_rtree.graph().node_count() == old(self.geometry_with_rtree.graph().node_count() + 1))] + #[debug_ensures(self.geometry_with_rtree.graph().edge_count() == old(self.geometry_with_rtree.graph().edge_count()))] + fn add_dot_infringably + GetLayer>( + &mut self, + weight: W, + ) -> GenericIndex + where + GenericIndex: Into + Copy, + { + self.geometry_with_rtree.add_dot(weight) + } + + #[debug_ensures(self.geometry_with_rtree.graph().node_count() == old(self.geometry_with_rtree.graph().node_count() + 1))] + #[debug_ensures(self.geometry_with_rtree.graph().edge_count() == old(self.geometry_with_rtree.graph().edge_count()))] + pub fn add_fixed_seg( &mut self, from: FixedDotIndex, to: FixedDotIndex, weight: FixedSegWeight, ) -> Result { - self.add_seg_with_infringables(from.into(), to.into(), weight, None) + self.add_seg_with_infringables(from.into(), to.into(), weight, Some(&[])) + } + + #[debug_ensures(self.geometry_with_rtree.graph().node_count() == old(self.geometry_with_rtree.graph().node_count() + 1))] + #[debug_ensures(self.geometry_with_rtree.graph().edge_count() == old(self.geometry_with_rtree.graph().edge_count() + 2))] + pub fn add_fixed_seg_infringably( + &mut self, + from: FixedDotIndex, + to: FixedDotIndex, + weight: FixedSegWeight, + ) -> FixedSegIndex { + self.add_seg_infringably(from.into(), to.into(), weight) } #[debug_ensures(ret.is_ok() -> self.geometry_with_rtree.graph().node_count() == old(self.geometry_with_rtree.graph().node_count() + 1))] @@ -229,12 +252,24 @@ impl Drawing { where GenericIndex: Into + Copy, { - let seg = self.geometry_with_rtree.add_seg(from, to, weight); + let seg = self.add_seg_infringably(from, to, weight); self.fail_and_remove_if_infringes_except(seg.into(), infringables)?; Ok(seg) } + fn add_seg_infringably + GetLayer>( + &mut self, + from: DotIndex, + to: DotIndex, + weight: W, + ) -> GenericIndex + where + GenericIndex: Into, + { + self.geometry_with_rtree.add_seg(from, to, weight) + } + #[debug_ensures(ret.is_ok() -> self.geometry_with_rtree.graph().node_count() == old(self.geometry_with_rtree.graph().node_count() + 1))] #[debug_ensures(ret.is_ok() -> self.geometry_with_rtree.graph().edge_count() == old(self.geometry_with_rtree.graph().edge_count() + 3) || self.geometry_with_rtree.graph().edge_count() == old(self.geometry_with_rtree.graph().edge_count() + 4))] diff --git a/src/dsn/design.rs b/src/dsn/design.rs index 1a20f1d..db3049f 100644 --- a/src/dsn/design.rs +++ b/src/dsn/design.rs @@ -378,16 +378,14 @@ impl DsnDesign { r, }; - board - .add_fixed_dot( - FixedDotWeight { - circle, - layer, - maybe_net: Some(net), - }, - maybe_pin.clone(), - ) - .unwrap(); + board.add_fixed_dot_infringably( + FixedDotWeight { + circle, + layer, + maybe_net: Some(net), + }, + maybe_pin.clone(), + ); } fn add_rect( @@ -414,107 +412,91 @@ impl DsnDesign { ); // Corners. - let dot_1_1 = board - .add_zone_fixed_dot( - FixedDotWeight { - circle: Circle { - pos: Self::pos(place_pos, place_rot, pin_pos, pin_rot, x1, y1), - r: 0.5, - }, - layer, - maybe_net: Some(net), + let dot_1_1 = board.add_zone_fixed_dot_infringably( + FixedDotWeight { + circle: Circle { + pos: Self::pos(place_pos, place_rot, pin_pos, pin_rot, x1, y1), + r: 0.5, }, - zone, - ) - .unwrap(); - let dot_2_1 = board - .add_zone_fixed_dot( - FixedDotWeight { - circle: Circle { - pos: Self::pos(place_pos, place_rot, pin_pos, pin_rot, x2, y1), - r: 0.5, - }, - layer, - maybe_net: Some(net), + layer, + maybe_net: Some(net), + }, + zone, + ); + let dot_2_1 = board.add_zone_fixed_dot_infringably( + FixedDotWeight { + circle: Circle { + pos: Self::pos(place_pos, place_rot, pin_pos, pin_rot, x2, y1), + r: 0.5, }, - zone, - ) - .unwrap(); - let dot_2_2 = board - .add_zone_fixed_dot( - FixedDotWeight { - circle: Circle { - pos: Self::pos(place_pos, place_rot, pin_pos, pin_rot, x2, y2), - r: 0.5, - }, - layer, - maybe_net: Some(net), + layer, + maybe_net: Some(net), + }, + zone, + ); + let dot_2_2 = board.add_zone_fixed_dot_infringably( + FixedDotWeight { + circle: Circle { + pos: Self::pos(place_pos, place_rot, pin_pos, pin_rot, x2, y2), + r: 0.5, }, - zone, - ) - .unwrap(); - let dot_1_2 = board - .add_zone_fixed_dot( - FixedDotWeight { - circle: Circle { - pos: Self::pos(place_pos, place_rot, pin_pos, pin_rot, x1, y2), - r: 0.5, - }, - layer, - maybe_net: Some(net), + layer, + maybe_net: Some(net), + }, + zone, + ); + let dot_1_2 = board.add_zone_fixed_dot_infringably( + FixedDotWeight { + circle: Circle { + pos: Self::pos(place_pos, place_rot, pin_pos, pin_rot, x1, y2), + r: 0.5, }, - zone, - ) - .unwrap(); + layer, + maybe_net: Some(net), + }, + zone, + ); // Sides. - board - .add_zone_fixed_seg( - dot_1_1, - dot_2_1, - FixedSegWeight { - width: 1.0, - layer, - maybe_net: Some(net), - }, - zone, - ) - .unwrap(); - board - .add_zone_fixed_seg( - dot_2_1, - dot_2_2, - FixedSegWeight { - width: 1.0, - layer, - maybe_net: Some(net), - }, - zone, - ) - .unwrap(); - board - .add_zone_fixed_seg( - dot_2_2, - dot_1_2, - FixedSegWeight { - width: 1.0, - layer, - maybe_net: Some(net), - }, - zone, - ) - .unwrap(); - board - .add_zone_fixed_seg( - dot_1_2, - dot_1_1, - FixedSegWeight { - width: 1.0, - layer, - maybe_net: Some(net), - }, - zone, - ) - .unwrap(); + board.add_zone_fixed_seg_infringably( + dot_1_1, + dot_2_1, + FixedSegWeight { + width: 1.0, + layer, + maybe_net: Some(net), + }, + zone, + ); + board.add_zone_fixed_seg_infringably( + dot_2_1, + dot_2_2, + FixedSegWeight { + width: 1.0, + layer, + maybe_net: Some(net), + }, + zone, + ); + board.add_zone_fixed_seg_infringably( + dot_2_2, + dot_1_2, + FixedSegWeight { + width: 1.0, + layer, + maybe_net: Some(net), + }, + zone, + ); + board.add_zone_fixed_seg_infringably( + dot_1_2, + dot_1_1, + FixedSegWeight { + width: 1.0, + layer, + maybe_net: Some(net), + }, + zone, + ); } fn add_path( @@ -538,19 +520,17 @@ impl DsnDesign { coords[0].x as f64, coords[0].y as f64, ); - let mut prev_index = board - .add_fixed_dot( - FixedDotWeight { - circle: Circle { - pos: prev_pos, - r: width / 2.0, - }, - layer, - maybe_net: Some(net), + let mut prev_index = board.add_fixed_dot_infringably( + FixedDotWeight { + circle: Circle { + pos: prev_pos, + r: width / 2.0, }, - maybe_pin.clone(), - ) - .unwrap(); + layer, + maybe_net: Some(net), + }, + maybe_pin.clone(), + ); // iterate through path coords starting from the second for coord in coords.iter().skip(1) { @@ -567,33 +547,29 @@ impl DsnDesign { continue; } - let index = board - .add_fixed_dot( - FixedDotWeight { - circle: Circle { - pos, - r: width / 2.0, - }, - layer, - maybe_net: Some(net), + let index = board.add_fixed_dot_infringably( + FixedDotWeight { + circle: Circle { + pos, + r: width / 2.0, }, - maybe_pin.clone(), - ) - .unwrap(); + layer, + maybe_net: Some(net), + }, + maybe_pin.clone(), + ); // add a seg between the current and previous coords - let _ = board - .add_fixed_seg( - prev_index, - index, - FixedSegWeight { - width, - layer, - maybe_net: Some(net), - }, - maybe_pin.clone(), - ) - .unwrap(); + let _ = board.add_fixed_seg_infringably( + prev_index, + index, + FixedSegWeight { + width, + layer, + maybe_net: Some(net), + }, + maybe_pin.clone(), + ); prev_index = index; prev_pos = pos; @@ -622,8 +598,30 @@ impl DsnDesign { ); // add the first coordinate in the wire path as a dot and save its index - let mut prev_index = board - .add_zone_fixed_dot( + let mut prev_index = board.add_zone_fixed_dot_infringably( + FixedDotWeight { + circle: Circle { + pos: Self::pos( + place_pos, + place_rot, + pin_pos, + pin_rot, + coords[0].x as f64, + coords[0].y as f64, + ), + r: width / 2.0, + }, + layer, + maybe_net: Some(net), + }, + // TODO: This manual retagging shouldn't be necessary, `.into()` should suffice. + //GenericIndex::new(zone.node_index()).into(), + zone, + ); + + // iterate through path coords starting from the second + for coord in coords.iter().skip(1) { + let index = board.add_zone_fixed_dot_infringably( FixedDotWeight { circle: Circle { pos: Self::pos( @@ -631,59 +629,31 @@ impl DsnDesign { place_rot, pin_pos, pin_rot, - coords[0].x as f64, - coords[0].y as f64, - ), + coord.x as f64, + coord.y as f64, + ) + .into(), r: width / 2.0, }, layer, maybe_net: Some(net), }, // TODO: This manual retagging shouldn't be necessary, `.into()` should suffice. - //GenericIndex::new(zone.node_index()).into(), zone, - ) - .unwrap(); - - // iterate through path coords starting from the second - for coord in coords.iter().skip(1) { - let index = board - .add_zone_fixed_dot( - FixedDotWeight { - circle: Circle { - pos: Self::pos( - place_pos, - place_rot, - pin_pos, - pin_rot, - coord.x as f64, - coord.y as f64, - ) - .into(), - r: width / 2.0, - }, - layer, - maybe_net: Some(net), - }, - // TODO: This manual retagging shouldn't be necessary, `.into()` should suffice. - zone, - ) - .unwrap(); + ); // add a seg between the current and previous coords - let _ = board - .add_zone_fixed_seg( - prev_index, - index, - FixedSegWeight { - width, - layer, - maybe_net: Some(net), - }, - // TODO: This manual retagging shouldn't be necessary, `.into()` should suffice. - zone, - ) - .unwrap(); + let _ = board.add_zone_fixed_seg_infringably( + prev_index, + index, + FixedSegWeight { + width, + layer, + maybe_net: Some(net), + }, + // TODO: This manual retagging shouldn't be necessary, `.into()` should suffice. + zone, + ); prev_index = index; } diff --git a/src/layout/layout.rs b/src/layout/layout.rs index a7f5ff2..277604b 100644 --- a/src/layout/layout.rs +++ b/src/layout/layout.rs @@ -90,6 +90,10 @@ impl Layout { } pub fn add_fixed_dot(&mut self, weight: FixedDotWeight) -> Result { + self.drawing.add_fixed_dot(weight) + } + + pub fn add_fixed_dot_infringably(&mut self, weight: FixedDotWeight) -> FixedDotIndex { self.drawing.add_fixed_dot_infringably(weight) } @@ -107,6 +111,16 @@ impl Layout { maybe_dot } + pub fn add_zone_fixed_dot_infringably( + &mut self, + weight: FixedDotWeight, + zone: GenericIndex, + ) -> FixedDotIndex { + let dot = self.drawing.add_fixed_dot_infringably(weight); + self.drawing.add_to_compound(dot, zone.into()); + dot + } + pub fn add_fixed_seg( &mut self, from: FixedDotIndex, @@ -116,6 +130,15 @@ impl Layout { self.drawing.add_fixed_seg(from, to, weight) } + pub fn add_fixed_seg_infringably( + &mut self, + from: FixedDotIndex, + to: FixedDotIndex, + weight: FixedSegWeight, + ) -> FixedSegIndex { + self.drawing.add_fixed_seg_infringably(from, to, weight) + } + pub fn add_zone_fixed_seg( &mut self, from: FixedDotIndex, @@ -132,6 +155,18 @@ impl Layout { maybe_seg } + pub fn add_zone_fixed_seg_infringably( + &mut self, + from: FixedDotIndex, + to: FixedDotIndex, + weight: FixedSegWeight, + zone: GenericIndex, + ) -> FixedSegIndex { + let seg = self.add_fixed_seg_infringably(from, to, weight); + self.drawing.add_to_compound(seg, zone.into()); + seg + } + pub fn add_lone_loose_seg( &mut self, from: FixedDotIndex,