use indicatrix::geometry::meet_solver::SolvedTier;
use indicatrix_cut_core::{ConcaveTierDelta, Design, TierDelta, diff_concave_tiers, diff_tiers};
pub const MAST_DIFF_TOLERANCE: f64 = 1e-4;
#[derive(Clone)]
pub struct DesignSnapshot {
pub design: Design,
pub solved: Option<Vec<SolvedTier>>,
pub label: String,
pub from_retarget_apply: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DiffRowView {
pub tier_index: usize,
pub name: String,
pub old_angle: String,
pub new_angle: String,
pub mast_delta: String,
pub status_label: &'static str,
pub status_rgb: (u8, u8, u8),
pub badge: String,
}
fn diff_status_label_and_rgb(delta: &TierDelta) -> (&'static str, (u8, u8, u8)) {
if delta.added() {
("Added", (0x38, 0xbd, 0xf8))
} else if delta.removed() {
("Removed", (0xf4, 0x3f, 0x5e))
} else if delta.angle_changed()
|| delta.indices_changed()
|| delta.mast_changed(MAST_DIFF_TOLERANCE)
{
("Changed", (0xf5, 0x9e, 0x0b))
} else {
("Same", (0x10, 0xb9, 0x81))
}
}
fn angle_text(angle_deg: Option<f64>) -> String {
angle_deg.map_or_else(|| "-".to_string(), |v| format!("{:.2}\u{b0}", v.abs()))
}
#[must_use]
pub fn diff_row_view(delta: &TierDelta) -> DiffRowView {
let mast_delta = match (delta.mast_before, delta.mast_after) {
(Some(before), Some(after)) => format!("{:+.4}", after - before),
_ => "-".to_string(),
};
let (status_label, status_rgb) = diff_status_label_and_rgb(delta);
DiffRowView {
tier_index: delta.index,
name: delta.name.clone(),
old_angle: angle_text(delta.angle_before),
new_angle: angle_text(delta.angle_after),
mast_delta,
status_label,
status_rgb,
badge: String::new(),
}
}
#[must_use]
pub fn concave_diff_row_view(delta: &ConcaveTierDelta) -> DiffRowView {
let (status_label, status_rgb) = match (&delta.before, &delta.after) {
(None, _) => ("Added", (0x38, 0xbd, 0xf8)),
(_, None) => ("Removed", (0xf4, 0x3f, 0x5e)),
_ => ("Changed", (0xf5, 0x9e, 0x0b)),
};
let badge = match (&delta.before, &delta.after) {
(Some(before), Some(after)) if before.tool != after.tool => {
format!("{} -> {}", before.tool.code(), after.tool.code())
}
(Some(t), _) | (None, Some(t)) => t.tool.code().to_string(),
(None, None) => String::new(),
};
DiffRowView {
tier_index: delta.position,
name: delta
.after
.as_ref()
.or(delta.before.as_ref())
.map_or_else(String::new, |t| t.name.clone()),
old_angle: angle_text(delta.before.as_ref().map(|t| t.angle_deg)),
new_angle: angle_text(delta.after.as_ref().map(|t| t.angle_deg)),
mast_delta: "-".to_string(),
status_label,
status_rgb,
badge,
}
}
#[must_use]
pub fn compare_rows(
snapshot: &DesignSnapshot,
design: &Design,
current_solved: Option<&[SolvedTier]>,
) -> Vec<DiffRowView> {
let flat = diff_tiers(
&snapshot.design.tiers,
snapshot.solved.as_deref(),
&design.tiers,
current_solved,
);
let concave = diff_concave_tiers(&snapshot.design.concave_tiers, &design.concave_tiers);
flat.iter()
.map(diff_row_view)
.chain(concave.iter().map(concave_diff_row_view))
.collect()
}
#[must_use]
pub fn compare_label(snapshot_label: &str, current_label: &str) -> String {
format!("\"{snapshot_label}\" vs. current (\"{current_label}\")")
}
#[cfg(test)]
mod tests {
use super::*;
use crate::EditorSession;
#[test]
fn an_untouched_design_compares_all_same_and_a_moved_angle_reads_changed() {
let session = EditorSession::from_template(
indicatrix_cut_core::FreshDesignSpec {
gear_teeth: 96,
symmetry_order: 8,
mirror: true,
material: indicatrix_cut_core::MaterialSelection::none(),
preform: indicatrix_cut_core::PreformSpec::cylinder(96, 1.5, 1.0, 1.5),
},
1,
);
let solved = session.design.solve().ok();
let snapshot = DesignSnapshot {
design: session.design.clone(),
solved: solved.clone(),
label: "before".to_string(),
from_retarget_apply: false,
};
let same = compare_rows(&snapshot, &session.design, solved.as_deref());
assert_eq!(same.len(), session.design.tiers.len());
assert!(same.iter().all(|row| row.status_label == "Same"));
let mut moved = session.design;
moved.tiers[0].angle_deg += 1.0;
let rows = compare_rows(&snapshot, &moved, None);
assert_eq!(rows[0].status_label, "Changed");
assert_eq!(rows[0].mast_delta, "-");
assert_eq!(
compare_label("a", "b"),
"\"a\" vs. current (\"b\")".to_string()
);
}
#[test]
fn compare_rows_include_concave_deltas() {
let design = Design::concave_fixture();
let solved = design.solve().ok();
let snapshot = DesignSnapshot {
design: design.clone(),
solved: solved.clone(),
label: "before".to_string(),
from_retarget_apply: false,
};
let same = compare_rows(&snapshot, &design, solved.as_deref());
assert_eq!(same.len(), design.tiers.len(), "no concave row when equal");
assert!(same.iter().all(|row| row.badge.is_empty()));
let mut edited = design;
edited.concave_tiers[0].tool = indicatrix_cut_core::design::ConcaveTool::Cone;
edited.concave_tiers[0].tool_angle_deg = Some(60.0);
edited.concave_tiers.pop();
let rows = compare_rows(&snapshot, &edited, solved.as_deref());
let concave: Vec<&DiffRowView> = rows.iter().filter(|r| !r.badge.is_empty()).collect();
assert_eq!(concave.len(), 2);
assert_eq!(concave[0].status_label, "Changed");
assert_eq!(concave[0].badge, "CYL -> CON");
assert_eq!(concave[0].name, "Groove");
assert_eq!(concave[1].status_label, "Removed");
assert_eq!(concave[1].badge, "SPH");
assert_eq!(concave[1].new_angle, "-");
}
#[test]
fn compare_angles_read_as_positive_numbers_and_a_missing_side_stays_a_dash() {
let delta = TierDelta {
index: 3,
name: "P1".to_string(),
angle_before: Some(-40.3),
angle_after: Some(-41.0),
indices_before: None,
indices_after: None,
mast_before: None,
mast_after: None,
};
let row = diff_row_view(&delta);
assert_eq!(row.old_angle, "40.30\u{b0}");
assert_eq!(row.new_angle, "41.00\u{b0}");
let added = TierDelta {
angle_before: None,
angle_after: Some(-39.0),
..delta.clone()
};
let row = diff_row_view(&added);
assert_eq!(row.old_angle, "-");
assert_eq!(row.new_angle, "39.00\u{b0}");
let crown = TierDelta {
angle_before: Some(34.5),
angle_after: Some(35.0),
..delta
};
let row = diff_row_view(&crown);
assert_eq!(row.old_angle, "34.50\u{b0}");
assert_eq!(row.new_angle, "35.00\u{b0}");
}
#[test]
fn a_concave_compare_row_shows_the_facet_angle_as_a_magnitude() {
let design = Design::concave_fixture();
let snapshot = DesignSnapshot {
design: design.clone(),
solved: None,
label: "before".to_string(),
from_retarget_apply: false,
};
let mut edited = design;
edited.concave_tiers[0].angle_deg = -35.0;
let rows = compare_rows(&snapshot, &edited, None);
let concave: Vec<&DiffRowView> = rows.iter().filter(|r| !r.badge.is_empty()).collect();
assert_eq!(
concave[0].old_angle, "42.00\u{b0}",
"the fixture's Groove is -42"
);
assert_eq!(concave[0].new_angle, "35.00\u{b0}");
}
}