Pair unique layer-only shape changes
This commit is contained in:
parent
87683db7e8
commit
ab308f7b7f
1 changed files with 253 additions and 38 deletions
|
|
@ -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)
|
||||
|
|
|
|||
Loading…
Reference in a new issue