Pair unique layer-only shape changes

This commit is contained in:
Jan Petykiewicz 2026-11-18 23:16:09 -08:00
commit ab308f7b7f
2 changed files with 253 additions and 38 deletions

View file

@ -1543,7 +1543,7 @@ impl Comparison {
let body_start = out.len();
let mut removed_cells = String::new();
let mut added_cells = String::new();
let mut layers = changes::LayerRows::new(&self.layer_legend);
let mut layers = changes::LayerRows::new(&self.layer_legend, &self.layer_names);
let mut annotations = Vec::new();
let mut covered_edges = BTreeSet::new();
let mut detail_total = 0;
@ -1587,12 +1587,19 @@ impl Comparison {
let mut paired_old = BTreeSet::new();
let mut paired_new = BTreeSet::new();
for replacement in &cell.replacements {
paired_old.insert(replacement.removed);
paired_new.insert(replacement.added);
let a = &cell.removed[replacement.removed];
let b = &cell.added[replacement.added];
if max_objects - shown >= 2 && visible(a) && visible(b) {
if is_polygon(a.kind) {
if !visible(a) || !visible(b) {
continue;
}
paired_old.insert(replacement.removed);
paired_new.insert(replacement.added);
if max_objects - shown >= 2 {
if a.layer != b.layer {
out.push_str(" ~ ");
changes::write_layer_transition(&mut out, a, b, Some(&mut layers));
out.push('\n');
} else if is_polygon(a.kind) {
polygons.replacement(a, b);
} else {
out.push_str(" ~ ");

View file

@ -25,38 +25,82 @@ fn group(object: &ObjectChange, bounds: bool) -> Group {
)
}
fn unique_groups<'a, K: Ord>(
objects: &'a [ObjectChange],
key: impl Fn(usize, &'a ObjectChange) -> Option<K>,
) -> BTreeMap<K, Option<usize>> {
let mut groups = BTreeMap::new();
for (index, object) in objects.iter().enumerate() {
if let Some(key) = key(index, object) {
groups
.entry(key)
.and_modify(|value| *value = None)
.or_insert(Some(index));
}
}
groups
}
type ShapeKey<'a> = (u16, Vec<(u16, &'a [u8])>, &'a [(u16, Vec<u8>)]);
fn shape_without_layer(object: &ObjectChange) -> Option<ShapeKey<'_>> {
if object.layer.is_none() || !(is_polygon(object.kind) || object.kind == RTAG_PATH) {
return None;
}
let fields = object
.fields
.iter()
.filter(|field| !matches_layer_field(object.kind, field.tag))
.map(|field| (field.tag, field.data.as_slice()))
.collect();
Some((object.kind, fields, &object.properties))
}
fn layer_replacements(old: &[ObjectChange], new: &[ObjectChange]) -> Vec<Replacement> {
// Most small edits touch a single numeric pair.
let Some(layer) = old.iter().chain(new).find_map(|object| object.layer) else {
return Vec::new();
};
if !old
.iter()
.chain(new)
.any(|object| object.layer.is_some_and(|pair| pair != layer))
{
return Vec::new();
}
let a = unique_groups(old, |_, object| shape_without_layer(object));
let b = unique_groups(new, |_, object| shape_without_layer(object));
a.into_iter()
.filter_map(|(key, removed)| {
let removed = removed?;
let added = b.get(&key).copied().flatten()?;
(old[removed].layer != new[added].layer).then_some(Replacement {
removed,
added,
match_rule: "unique_layer_change",
})
})
.collect()
}
/// Pair only unique candidates in the remaining multisets. Ambiguous groups
/// remain additions/removals; no identity or geometric equivalence is inferred.
pub(super) fn replacements(old: &[ObjectChange], new: &[ObjectChange]) -> Vec<Replacement> {
if old.is_empty() || new.is_empty() {
return Vec::new();
}
let (mut used_old, mut used_new) = (BTreeSet::new(), BTreeSet::new());
let mut result = Vec::new();
let mut result = layer_replacements(old, new);
let (mut used_old, mut used_new): (BTreeSet<_>, BTreeSet<_>) =
result.iter().map(|pair| (pair.removed, pair.added)).unzip();
for bounds in [true, false] {
let (mut a, mut b) = (
BTreeMap::<Group, Vec<usize>>::new(),
BTreeMap::<Group, Vec<usize>>::new(),
);
for (i, object) in old
.iter()
.enumerate()
.filter(|(i, _)| !used_old.contains(i))
{
a.entry(group(object, bounds)).or_default().push(i);
}
for (i, object) in new
.iter()
.enumerate()
.filter(|(i, _)| !used_new.contains(i))
{
b.entry(group(object, bounds)).or_default().push(i);
}
for (key, indices) in a {
if let (1, Some(others)) = (indices.len(), b.get(&key))
&& others.len() == 1
{
let (i, j) = (indices[0], others[0]);
let a = unique_groups(old, |i, object| {
(!used_old.contains(&i)).then(|| group(object, bounds))
});
let b = unique_groups(new, |i, object| {
(!used_new.contains(&i)).then(|| group(object, bounds))
});
for (key, index) in a {
if let (Some(i), Some(&Some(j))) = (index, b.get(&key)) {
result.push(Replacement {
removed: i,
added: j,
@ -407,17 +451,37 @@ impl ShownReferences {
pub(super) struct LayerRows<'a> {
names: &'a BTreeMap<Layer, String>,
name_changes: &'a [LayerNameChange],
rows: BTreeMap<Layer, Option<usize>>,
}
impl<'a> LayerRows<'a> {
pub fn new(names: &'a BTreeMap<Layer, String>) -> Self {
pub fn new(names: &'a BTreeMap<Layer, String>, name_changes: &'a [LayerNameChange]) -> Self {
Self {
names,
name_changes,
rows: BTreeMap::new(),
}
}
fn write_transition_layer(&mut self, out: &mut String, layer: Layer, side: Side) {
self.record(Some(layer), out.len());
write!(out, "{}/{}", layer.0, layer.1).unwrap();
if let Ok(index) = self
.name_changes
.binary_search_by_key(&layer, |change| change.layer)
{
let change = &self.name_changes[index];
let name = match side {
Side::Old => &change.old,
Side::New => &change.new,
};
if let Some(name) = name {
write!(out, " ({})", cell_label(name)).unwrap();
}
}
}
pub fn record(&mut self, layer: Option<Layer>, row_start: usize) {
if let Some(layer) = layer
&& self.names.contains_key(&layer)
@ -433,8 +497,11 @@ impl<'a> LayerRows<'a> {
for (layer, first) in self.rows {
let name = &self.names[&layer];
if let Some(at) = first {
// Each recorded heading starts with the numeric layer/type and a colon.
let at = at + text[at..].find(':').unwrap();
let at = at
+ text[at..]
.bytes()
.take_while(|b| b.is_ascii_digit() || *b == b'/')
.count();
annotations.push((at, format!(" ({})", cell_label(name))));
} else {
writeln!(legend, "{}/{}: name {name:?}", layer.0, layer.1).unwrap();
@ -443,6 +510,24 @@ impl<'a> LayerRows<'a> {
}
}
pub(super) fn write_layer_transition(
out: &mut String,
old: &ObjectChange,
new: &ObjectChange,
layers: Option<&mut LayerRows<'_>>,
) {
let (from, to) = (old.layer.unwrap(), new.layer.unwrap());
if let Some(layers) = layers {
layers.write_transition_layer(out, from, Side::Old);
out.push_str(" → ");
layers.write_transition_layer(out, to, Side::New);
} else {
write!(out, "{}/{} → {}/{}", from.0, from.1, to.0, to.1).unwrap();
}
let rectangular = is_polygon(old.kind) && rectangle_size(object_xy(old)).is_some();
write!(out, " · {}", object_name(old.kind, rectangular)).unwrap();
}
fn polygon_replacement(old: &ObjectChange, new: &ObjectChange) -> String {
let before = object_xy(old);
let after = object_xy(new);
@ -471,6 +556,11 @@ fn polygon_replacement(old: &ObjectChange, new: &ObjectChange) -> String {
}
pub(super) fn replacement_summary(old: &ObjectChange, new: &ObjectChange) -> String {
if old.layer != new.layer && old.layer.is_some() && new.layer.is_some() {
let mut out = String::new();
write_layer_transition(&mut out, old, new, None);
return out;
}
let polygon = is_polygon(old.kind);
let mut out = if polygon {
polygon_replacement(old, new)