use super::request::{PlanJob, PlannedFrame};
use crate::{
facet_map::FacetMap,
live_update::{self, CutLimit},
raster::SolidStyle,
};
use indicatrix::geometry::{meet_solver::SolvedTier, tool::ToolPrimitive};
use indicatrix_cut_core::design::Design;
use std::time::Duration;
#[must_use]
pub fn build_planned_frame(
job: PlanJob,
budget: Duration,
clock: &dyn live_update::Clock,
) -> PlannedFrame {
let limit = job.cut_limit();
let PlanJob {
design,
dirty,
last_solved,
camera,
size,
selected_tier,
n_d,
view_mode,
generation,
show_preform,
enlarged_panel,
tier_cutoff: _,
cut_steps: _,
} = job;
let plan = live_update::plan_preview_limited(
&design,
last_solved.as_deref(),
&dirty,
budget,
&live_update::RealSolver,
clock,
limit,
);
let empty_pending = std::collections::BTreeSet::new();
let pending_tiers = match &plan.freshness {
live_update::Freshness::Stale { pending } => pending,
_ => &empty_pending,
};
let drawn = drawn_masts(plan.solved.as_deref(), last_solved.as_deref(), &design);
let (tools, placements) = concave_tools_for_display(&design, drawn, limit);
let visible_tiers = live_update::limit_visible_tiers(&design, limit);
let facet_map = FacetMap::from_design_cut(
&design,
drawn.unwrap_or(&[]),
&placements,
visible_tiers.as_deref(),
);
let overlay = facet_map.overlay_flags(&design, n_d, selected_tier, pending_tiers);
let unsolvable_status = match &plan.freshness {
live_update::Freshness::Unsolvable(err) => {
Some(format!("Preview cannot be solved: {err}."))
}
_ => None,
};
let preform_plane_count = facet_map.preform_plane_count();
let style = SolidStyle {
flagged: overlay.flagged,
pending: overlay.pending,
selected: overlay.selected,
preform_plane_count,
show_preform,
..SolidStyle::default()
};
let out_of_date = matches!(plan.freshness, live_update::Freshness::Stale { .. });
let solved = plan.solved;
PlannedFrame {
design,
planes: plan.planes,
tools,
placements,
style,
solved,
stale: out_of_date,
unsolvable_status,
camera,
size,
view_mode,
generation,
n_d,
enlarged_panel,
visible_tiers,
}
}
fn drawn_masts<'a>(
solved: Option<&'a [SolvedTier]>,
previous: Option<&'a [SolvedTier]>,
design: &Design,
) -> Option<&'a [SolvedTier]> {
solved.or_else(|| previous.filter(|masts| masts.len() == design.tiers.len()))
}
fn concave_tools_for_display(
design: &Design,
solved: Option<&[SolvedTier]>,
limit: CutLimit,
) -> (Vec<ToolPrimitive>, Vec<(usize, usize)>) {
solved.map_or_else(
|| (Vec::new(), Vec::new()),
|solved| live_update::display_tools(design, solved, limit),
)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::preview::CameraPose;
use indicatrix::geometry::meet_solver::MeetConstraint;
use std::sync::Arc;
#[test]
fn concave_tools_follow_the_same_visible_tiers_as_the_planes() {
let mut design = Design::concave_fixture();
design.tiers.reverse();
let solved = design.solve().expect("the fixture solves");
let (all, _) = concave_tools_for_display(&design, Some(&solved), CutLimit::Finished);
let (through, placements) =
concave_tools_for_display(&design, Some(&solved), CutLimit::ThroughTier(0));
assert_eq!(all.len(), 12, "eight groove placements and four dimples");
assert_eq!(through.len(), 8);
assert!(placements.iter().all(|&(tier, _)| tier == 0));
}
#[test]
fn no_masts_means_no_tools() {
let design = Design::concave_fixture();
let (tools, placements) = concave_tools_for_display(&design, None, CutLimit::Finished);
assert!(tools.is_empty() && placements.is_empty());
}
#[test]
fn a_plan_that_solved_nothing_draws_from_the_previous_masts() {
let design = Design::concave_fixture();
let own = design.solve().expect("the fixture solves");
let previous = design.solve().expect("the fixture solves");
let drawn = drawn_masts(Some(&own), Some(&previous[..1]), &design);
assert!(
drawn.is_some_and(|masts| std::ptr::eq(masts, own.as_slice())),
"the plan's own solve wins"
);
let held_over = drawn_masts(None, Some(&previous), &design);
assert!(held_over.is_some_and(|masts| std::ptr::eq(masts, previous.as_slice())));
assert!(
drawn_masts(None, Some(&previous[..1]), &design).is_none(),
"a list left over from before a tier was added or removed draws nothing"
);
assert!(drawn_masts(None, None, &design).is_none());
}
#[test]
fn an_unsolvable_frame_keeps_the_concave_tools_of_the_stone_it_shows() {
let fixture = Design::concave_fixture();
let previous = fixture.solve().expect("the fixture solves");
let mut broken = fixture.clone();
for tier in &mut broken.tiers {
tier.constraint = MeetConstraint::MeetExisting;
}
let tier_count = broken.tiers.len();
let frame = build_planned_frame(
PlanJob {
design: Arc::new(broken),
dirty: (0..tier_count).collect(),
last_solved: Some(previous),
camera: CameraPose {
yaw: 0.0,
pitch: 0.0,
distance: 5.0,
},
size: (16, 16),
selected_tier: None,
n_d: fixture.effective_refractive_index(),
view_mode: 0,
generation: 9,
show_preform: true,
enlarged_panel: -1,
tier_cutoff: None,
cut_steps: None,
},
Duration::from_secs(60),
&ZeroClock,
);
assert!(
frame.unsolvable_status.is_some(),
"the premise: the design does not solve"
);
assert!(
frame.solved.is_none(),
"an unsolvable frame carries no masts"
);
assert!(!frame.planes.is_empty(), "the held-over stone is drawn");
assert_eq!(
frame.tools.len(),
12,
"eight groove placements and four dimples stay with the stone"
);
assert_eq!(frame.placements.len(), frame.tools.len());
}
struct ZeroClock;
impl live_update::Clock for ZeroClock {
fn now_ms(&self) -> f64 {
0.0
}
}
}