use glam::{DVec3, Vec3};
use indicatrix::geometry::{
ToolPrimitive,
cuts::StandardGemCuts,
meet_solver::{MeetConstraint, SolveStrategy, SolvedTier},
};
use indicatrix_cut_core::{
Design, DesignSolveError,
design::{TierRef, ToolPlacements},
};
use std::{collections::BTreeSet, time::Duration};
pub const DEFAULT_PREVIEW_BUDGET: Duration = Duration::from_millis(50);
pub trait Clock {
fn now_ms(&self) -> f64;
}
pub trait DirtySolver {
fn resolve_dirty(
&self,
design: &Design,
previous: &[SolvedTier],
dirty: &BTreeSet<usize>,
) -> Result<Vec<SolvedTier>, DesignSolveError>;
}
#[derive(Debug, Clone, Copy, Default)]
pub struct RealSolver;
impl DirtySolver for RealSolver {
fn resolve_dirty(
&self,
design: &Design,
previous: &[SolvedTier],
dirty: &BTreeSet<usize>,
) -> Result<Vec<SolvedTier>, DesignSolveError> {
design.resolve_dirty(previous, dirty)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Freshness {
Pinned,
Fresh,
Stale { pending: BTreeSet<usize> },
Unsolvable(DesignSolveError),
}
#[derive(Debug, Clone)]
pub struct PreviewPlan {
pub planes: Vec<(Vec3, f32)>,
pub solved: Option<Vec<SolvedTier>>,
pub freshness: Freshness,
}
#[expect(
clippy::cast_possible_truncation,
reason = "f32 is the preview's GPU/storage precision; plane normals and offsets are in the normal float range"
)]
fn narrow_planes(planes: Vec<(DVec3, f64)>) -> Vec<(Vec3, f32)> {
planes
.into_iter()
.map(|(n, m)| (Vec3::new(n.x as f32, n.y as f32, n.z as f32), m as f32))
.collect()
}
pub(crate) fn visible_flat_tiers(design: &Design, cutoff: usize) -> Vec<bool> {
let count = design.tiers.len();
if design.concave_tiers.is_empty() {
return (0..count).map(|i| i <= cutoff).collect();
}
let order = design.cutting_order();
let Some(step) = order.iter().position(|t| *t == TierRef::Flat(cutoff)) else {
return vec![true; count];
};
let mut visible = vec![false; count];
for tier in &order[..=step] {
if let TierRef::Flat(i) = tier {
visible[*i] = true;
}
}
visible
}
#[must_use]
pub fn limit_visible_tiers(design: &Design, limit: CutLimit) -> Option<Vec<bool>> {
match limit {
CutLimit::Finished => None,
CutLimit::ThroughTier(cutoff) => Some(visible_flat_tiers(design, cutoff)),
CutLimit::Steps(steps) => {
let order = design.preview_steps();
if steps >= order.len() {
return None;
}
let mut visible = vec![false; design.tiers.len()];
for step in &order[..steps] {
if let TierRef::Flat(index) = step
&& let Some(slot) = visible.get_mut(*index)
{
*slot = true;
}
}
Some(visible)
}
}
}
fn planes_of_visible_tiers(
design: &Design,
solved: &[SolvedTier],
visible: &[bool],
) -> Vec<(DVec3, f64)> {
let planes = design.planes_from_solved(solved);
let preform_len = design.preform.planes().len();
let schedule = design.to_asc_schedule_from_solved(solved);
let boundaries: Vec<usize> = (0..schedule.tiers.len())
.map(|i| {
let mut prefix = schedule.clone();
prefix.tiers.truncate(i + 1);
StandardGemCuts::from_asc_schedule(&prefix).len()
})
.collect();
planes
.into_iter()
.enumerate()
.filter(|(index, _)| {
index
.checked_sub(preform_len)
.and_then(|local| boundaries.iter().position(|&end| local < end))
.is_none_or(|tier| visible.get(tier).copied().unwrap_or(true))
})
.map(|(_, plane)| plane)
.collect()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CutLimit {
#[default]
Finished,
ThroughTier(usize),
Steps(usize),
}
impl CutLimit {
#[must_use]
pub const fn from_tier_cutoff(tier_cutoff: Option<usize>) -> Self {
match tier_cutoff {
Some(through_tier) => Self::ThroughTier(through_tier),
None => Self::Finished,
}
}
}
#[derive(Debug, Clone, Default)]
pub struct DisplayGeometry {
pub planes: Vec<(DVec3, f64)>,
pub tools: Vec<ToolPrimitive>,
pub placements: ToolPlacements,
}
#[must_use]
pub fn display_geometry(
design: &Design,
solved: &[SolvedTier],
limit: CutLimit,
) -> DisplayGeometry {
let planes = planes_for_display(design, solved, limit);
let (tools, placements) = display_tools(design, solved, limit);
DisplayGeometry {
planes,
tools,
placements,
}
}
fn planes_for_display(
design: &Design,
solved: &[SolvedTier],
limit: CutLimit,
) -> Vec<(DVec3, f64)> {
if let CutLimit::Steps(steps) = limit {
return design
.try_planes_after_steps(solved, steps)
.unwrap_or_default();
}
if solved.len() != design.tiers.len() {
return Vec::new();
}
let CutLimit::ThroughTier(through_tier) = limit else {
return design.planes_from_solved(solved);
};
if design.concave_tiers.is_empty() {
return design.planes_through_tier(solved, through_tier);
}
let visible = visible_flat_tiers(design, through_tier);
let is_stored_prefix = visible
.iter()
.enumerate()
.all(|(i, &shown)| shown == (i <= through_tier));
if is_stored_prefix {
design.planes_through_tier(solved, through_tier)
} else {
planes_of_visible_tiers(design, solved, &visible)
}
}
#[must_use]
pub fn display_tools(
design: &Design,
solved: &[SolvedTier],
limit: CutLimit,
) -> (Vec<ToolPrimitive>, ToolPlacements) {
if design.concave_tiers.is_empty() || solved.len() != design.tiers.len() {
return (Vec::new(), Vec::new());
}
let resolved = match limit {
CutLimit::Finished => design.concave_tools_from_solved(solved),
CutLimit::Steps(steps) => design.concave_tools_after_steps(solved, steps),
CutLimit::ThroughTier(cutoff) => {
let visible = visible_flat_tiers(design, cutoff);
let boundary = design
.cutting_order()
.into_iter()
.find(|tier| matches!(tier, TierRef::Flat(i) if !visible[*i]));
boundary.map_or_else(
|| design.concave_tools_from_solved(solved),
|first_hidden| design.concave_tools_through_tier(solved, first_hidden),
)
}
};
resolved.unwrap_or_default()
}
fn masts_from_pinned_tiers(design: &Design) -> Vec<SolvedTier> {
design
.tiers
.iter()
.map(|tier| {
let MeetConstraint::ScaleReference(mast) = &tier.constraint else {
unreachable!(
"masts_from_pinned_tiers: caller must confirm every tier is \
ScaleReference first"
);
};
SolvedTier {
mast: *mast,
strategy: SolveStrategy::ScaleReference,
detail: "pinned (ScaleReference)".to_string(),
}
})
.collect()
}
#[must_use]
pub fn plan_preview(
design: &Design,
last_solved: Option<&[SolvedTier]>,
dirty: &BTreeSet<usize>,
budget: Duration,
solver: &dyn DirtySolver,
clock: &dyn Clock,
tier_cutoff: Option<usize>,
) -> PreviewPlan {
plan_preview_limited(
design,
last_solved,
dirty,
budget,
solver,
clock,
CutLimit::from_tier_cutoff(tier_cutoff),
)
}
#[must_use]
pub fn plan_preview_limited(
design: &Design,
last_solved: Option<&[SolvedTier]>,
dirty: &BTreeSet<usize>,
budget: Duration,
solver: &dyn DirtySolver,
clock: &dyn Clock,
limit: CutLimit,
) -> PreviewPlan {
if design
.tiers
.iter()
.all(|tier| matches!(tier.constraint, MeetConstraint::ScaleReference(_)))
{
let pinned = masts_from_pinned_tiers(design);
let planes = narrow_planes(planes_for_display(design, &pinned, limit));
return PreviewPlan {
planes,
solved: Some(pinned),
freshness: Freshness::Pinned,
};
}
let aligned_previous = last_solved.filter(|previous| previous.len() == design.tiers.len());
let Some(previous) = aligned_previous else {
return match design.solve() {
Ok(fresh) => {
let planes = narrow_planes(planes_for_display(design, &fresh, limit));
PreviewPlan {
planes,
solved: Some(fresh),
freshness: Freshness::Fresh,
}
}
Err(err) => {
let planes = narrow_planes(planes_for_display(
design,
last_solved.unwrap_or(&[]),
limit,
));
PreviewPlan {
planes,
solved: None,
freshness: Freshness::Unsolvable(err),
}
}
};
};
let start_ms = clock.now_ms();
let result = solver.resolve_dirty(design, previous, dirty);
let elapsed = Duration::from_secs_f64((clock.now_ms() - start_ms).max(0.0) / 1000.0);
match result {
Ok(new_solved) if elapsed <= budget => {
let planes = narrow_planes(planes_for_display(design, &new_solved, limit));
PreviewPlan {
planes,
solved: Some(new_solved),
freshness: Freshness::Fresh,
}
}
Ok(new_solved) => {
let planes = narrow_planes(planes_for_display(design, previous, limit));
PreviewPlan {
planes,
solved: Some(new_solved),
freshness: Freshness::Stale {
pending: dirty.clone(),
},
}
}
Err(err) => {
let planes = narrow_planes(planes_for_display(design, previous, limit));
PreviewPlan {
planes,
solved: None,
freshness: Freshness::Unsolvable(err),
}
}
}
}
#[cfg(test)]
mod tests;