mod chart;
mod csv;
mod form;
mod metric;
#[cfg(test)]
mod tests;
pub use chart::{
chart_path, chart_x_percent, current_x_percent, hover_text, nearest_row, series_range_text,
};
pub use csv::sweep_csv;
pub use form::{
DEFAULT_SWEEP_HALF_RANGE_DEG, DEFAULT_SWEEP_STEP_DEG, default_range, estimate_seconds,
format_angle_input, format_duration_estimate, parse_sweep_range, plan_summary,
};
pub use metric::{BestFlags, SweepMetric, best_flags};
use crate::{
EditChange, EditorSession,
metric_deltas::measure_tilt_average,
retarget::plan::tier_display_name,
session::SessionEditError,
solve_policy::{design_to_gpu_planes_from_solved, solve_cancellably},
};
use indicatrix::{
color::metrics::evaluate_gem_optical_metrics,
geometry::{
meet_solver::{SolveError, SolveStrategy},
stone_metrics::{SolidStatus, build_solid_mesh, measure_solid},
},
optics::{materials::GemMaterial, raytracer::EnvironmentSource},
};
use indicatrix_cut_core::{
DEFAULT_MIN_FACET_AREA_FRACTION_OF_W2, Design, DesignSolveError, Edit, EditError,
ManufacturabilityWarning, check_manufacturability, design::snap_noise, volumetric_yield,
};
use std::{
fmt,
sync::atomic::{AtomicBool, AtomicUsize, Ordering},
};
pub const MAX_SWEEP_STEPS: usize = 200;
pub const MIN_SWEEP_ANGLE_DEG: f64 = 0.1;
pub const MAX_SWEEP_ANGLE_DEG: f64 = 89.9;
const FLAT_TIER_DEG: f64 = 1e-9;
const CURRENT_MATCH_DEG: f64 = 1e-4;
const TABLE_UP_PITCH_RAD: f32 = std::f32::consts::FRAC_PI_2;
#[cfg(not(target_arch = "wasm32"))]
const MAX_WORKERS: usize = 16;
#[derive(Debug, Clone, PartialEq)]
pub enum SweepError {
NoSuchTier {
tier: usize,
tier_count: usize,
},
Driven {
tier: String,
relation: String,
},
Flat {
tier: String,
},
Vertical {
tier: String,
},
BadNumber(String),
StepNotPositive,
OutOfBounds {
value: f64,
},
TooManySteps {
steps: usize,
max: usize,
},
}
impl fmt::Display for SweepError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::NoSuchTier { .. } => f.write_str("That tier is not in the design."),
Self::Driven { tier, relation } => write!(
f,
"{tier} follows a relation ({tier} = {relation}), so its angle is not free to \
sweep. Sweep a tier it reads instead, or remove the relation."
),
Self::Flat { tier } => write!(
f,
"{tier} is flat (a table or a culet), so it has no angle to sweep."
),
Self::Vertical { tier } => write!(
f,
"{tier} is a girdle tier (vertical), so it has no angle to sweep."
),
Self::BadNumber(message) => f.write_str(message),
Self::StepNotPositive => f.write_str("The step must be more than 0."),
Self::OutOfBounds { value } => write!(
f,
"An angle of {:.2} degrees is outside what a sweep takes: between \
{MIN_SWEEP_ANGLE_DEG} and {MAX_SWEEP_ANGLE_DEG} degrees from flat.",
value.abs()
),
Self::TooManySteps { steps, max } => write!(
f,
"That is {steps} angles, and a sweep takes at most {max}. Use a larger step \
or a shorter range."
),
}
}
}
impl std::error::Error for SweepError {}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SweepRange {
pub from_deg: f64,
pub to_deg: f64,
pub step_deg: f64,
}
#[derive(Debug, Clone, PartialEq)]
pub struct SweepPlan {
pub tier: usize,
pub tier_name: String,
pub current_deg: f64,
pub angles: Vec<f64>,
pub current_row: usize,
}
#[derive(Debug, Clone, Copy)]
pub struct SweepOptions {
pub tilt_average: bool,
pub workers: usize,
}
impl Default for SweepOptions {
fn default() -> Self {
Self {
tilt_average: false,
workers: default_worker_count(),
}
}
}
#[derive(Clone, Copy)]
pub struct SweepScene<'a> {
pub material: &'a GemMaterial,
pub environment: EnvironmentSource<'a>,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TiltAverages {
pub brilliance_pct: f32,
pub windowing_pct: f32,
pub extinction_pct: f32,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct RowMetrics {
pub brilliance_pct: f32,
pub windowing_pct: f32,
pub extinction_pct: f32,
pub fire_index: f32,
pub scintillation_pct: f32,
pub yield_pct: Option<f64>,
pub warning_count: usize,
pub has_girdle: bool,
pub tilt: Option<TiltAverages>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct SweepRow {
pub angle_deg: f64,
pub is_current: bool,
pub metrics: Option<RowMetrics>,
pub notes: Vec<String>,
}
impl SweepRow {
#[must_use]
pub const fn is_valid(&self) -> bool {
self.metrics.is_some()
}
#[must_use]
pub fn notes_text(&self) -> String {
self.notes.join("; ")
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct SweepOutcome {
pub tier: usize,
pub tier_name: String,
pub current_deg: f64,
pub requested: usize,
pub cancelled: bool,
pub tilt_average: bool,
pub rows: Vec<SweepRow>,
}
impl SweepOutcome {
#[must_use]
pub fn current_row(&self) -> Option<&SweepRow> {
self.rows.iter().find(|row| row.is_current)
}
#[must_use]
pub fn valid_count(&self) -> usize {
self.rows.iter().filter(|row| row.is_valid()).count()
}
}
#[cfg(not(target_arch = "wasm32"))]
#[must_use]
pub fn default_worker_count() -> usize {
std::thread::available_parallelism()
.map_or(1, |cores| cores.get().saturating_sub(1).max(1))
.min(MAX_WORKERS)
}
#[cfg(target_arch = "wasm32")]
#[must_use]
pub const fn default_worker_count() -> usize {
1
}
fn tier_refusal(design: &Design, tier: usize) -> Option<SweepError> {
let Some(swept) = design.tiers.get(tier) else {
return Some(SweepError::NoSuchTier {
tier,
tier_count: design.tiers.len(),
});
};
let name = tier_display_name(design, tier);
if let Some(relation) = design.relation_text(tier) {
return Some(SweepError::Driven {
tier: name,
relation,
});
}
let magnitude = swept.angle_deg.abs();
if magnitude < FLAT_TIER_DEG {
return Some(SweepError::Flat { tier: name });
}
if magnitude > MAX_SWEEP_ANGLE_DEG {
return Some(SweepError::Vertical { tier: name });
}
None
}
#[must_use]
pub fn sweepable_tiers(design: &Design) -> Vec<usize> {
(0..design.tiers.len())
.filter(|&tier| tier_refusal(design, tier).is_none())
.collect()
}
pub fn plan_sweep(
design: &Design,
tier: usize,
range: SweepRange,
) -> Result<SweepPlan, SweepError> {
if let Some(refusal) = tier_refusal(design, tier) {
return Err(refusal);
}
let Some(swept) = design.tiers.get(tier) else {
return Err(SweepError::NoSuchTier {
tier,
tier_count: design.tiers.len(),
});
};
let name = tier_display_name(design, tier);
let current_deg = swept.angle_deg;
if !(range.step_deg.is_finite() && range.step_deg > 0.0) {
return Err(SweepError::StepNotPositive);
}
for end in [range.from_deg, range.to_deg] {
if !end.is_finite() || !(MIN_SWEEP_ANGLE_DEG..=MAX_SWEEP_ANGLE_DEG).contains(&end.abs()) {
return Err(SweepError::OutOfBounds { value: end });
}
}
let side = if current_deg.is_sign_negative() {
-1.0
} else {
1.0
};
let current_magnitude = current_deg.abs();
let low = range.from_deg.abs().min(range.to_deg.abs());
let high = range.from_deg.abs().max(range.to_deg.abs());
let grid_count = ((high - low) / range.step_deg + 1e-9).floor() + 1.0;
if grid_count >= (MAX_SWEEP_STEPS + 1) as f64 {
return Err(SweepError::TooManySteps {
steps: grid_count as usize,
max: MAX_SWEEP_STEPS,
});
}
let mut magnitudes: Vec<f64> = (0..grid_count as usize)
.map(|k| snap_noise((k as f64).mul_add(range.step_deg, low)))
.collect();
let current_row = if let Some(found) = magnitudes
.iter()
.position(|magnitude| (magnitude - current_magnitude).abs() < CURRENT_MATCH_DEG)
{
magnitudes[found] = current_magnitude;
found
} else {
let at = magnitudes.partition_point(|magnitude| *magnitude < current_magnitude);
magnitudes.insert(at, current_magnitude);
at
};
let mut angles: Vec<f64> = magnitudes
.into_iter()
.map(|magnitude| side * magnitude)
.collect();
angles[current_row] = current_deg;
if angles.len() > MAX_SWEEP_STEPS {
return Err(SweepError::TooManySteps {
steps: angles.len(),
max: MAX_SWEEP_STEPS,
});
}
Ok(SweepPlan {
tier,
tier_name: name,
current_deg,
angles,
current_row,
})
}
struct Shared<'a> {
design: &'a Design,
plan: &'a SweepPlan,
scene: &'a SweepScene<'a>,
options: &'a SweepOptions,
preform_volume: Option<f64>,
cancel: &'a AtomicBool,
progress: &'a (dyn Fn(usize, usize) + Sync),
next: AtomicUsize,
done: AtomicUsize,
}
enum Step {
Row(SweepRow),
Cancelled,
}
#[must_use]
pub fn sweep_tier_angle(
design: &Design,
plan: &SweepPlan,
scene: &SweepScene<'_>,
options: &SweepOptions,
cancel: &AtomicBool,
progress: &(dyn Fn(usize, usize) + Sync),
) -> SweepOutcome {
let shared = Shared {
design,
plan,
scene,
options,
preform_volume: measure_solid(&design.preform.planes()).map(|solid| solid.volume),
cancel,
progress,
next: AtomicUsize::new(0),
done: AtomicUsize::new(0),
};
let workers = options.workers.clamp(1, plan.angles.len().max(1));
let mut found = run_workers(&shared, workers);
found.sort_by_key(|(index, _)| *index);
let mut rows: Vec<SweepRow> = found.into_iter().map(|(_, row)| row).collect();
note_lost_girdles(&mut rows);
SweepOutcome {
tier: plan.tier,
tier_name: plan.tier_name.clone(),
current_deg: plan.current_deg,
requested: plan.angles.len(),
cancelled: rows.len() < plan.angles.len(),
tilt_average: options.tilt_average,
rows,
}
}
#[cfg(not(target_arch = "wasm32"))]
fn run_workers(shared: &Shared<'_>, workers: usize) -> Vec<(usize, SweepRow)> {
if workers <= 1 {
return claim_rows(shared);
}
std::thread::scope(|scope| {
let mut handles = Vec::with_capacity(workers);
for _ in 0..workers {
handles.push(scope.spawn(|| claim_rows(shared)));
}
let mut found = Vec::new();
for handle in handles {
found.extend(handle.join().expect("a sweep worker must not panic"));
}
found
})
}
#[cfg(target_arch = "wasm32")]
fn run_workers(shared: &Shared<'_>, _workers: usize) -> Vec<(usize, SweepRow)> {
claim_rows(shared)
}
fn claim_rows(shared: &Shared<'_>) -> Vec<(usize, SweepRow)> {
let total = shared.plan.angles.len();
let mut finished = Vec::new();
loop {
if shared.cancel.load(Ordering::Relaxed) {
break;
}
let index = shared.next.fetch_add(1, Ordering::Relaxed);
let Some(&angle_deg) = shared.plan.angles.get(index) else {
break;
};
let is_current = index == shared.plan.current_row;
match evaluate_step(shared, angle_deg, is_current) {
Step::Row(row) => finished.push((index, row)),
Step::Cancelled => break,
}
let done = shared.done.fetch_add(1, Ordering::Relaxed) + 1;
(shared.progress)(done, total);
}
finished
}
fn evaluate_step(shared: &Shared<'_>, angle_deg: f64, is_current: bool) -> Step {
let mut row = SweepRow {
angle_deg,
is_current,
metrics: None,
notes: Vec::new(),
};
let mut scratch = shared.design.clone();
if let Err(message) = set_swept_angle(&mut scratch, shared.plan.tier, angle_deg) {
row.notes.push(message);
return Step::Row(row);
}
let solved = match solve_cancellably(&scratch, shared.cancel) {
Ok(solved) => solved,
Err(DesignSolveError::Solve(SolveError::Cancelled)) => return Step::Cancelled,
Err(error) => {
row.notes
.push(format!("The design does not solve: {error}"));
return Step::Row(row);
}
};
let failed = solved
.iter()
.filter(|tier| matches!(tier.strategy, SolveStrategy::Failed))
.count();
if failed > 0 {
row.notes.push(format!(
"The solver could not place {failed} tier{}.",
if failed == 1 { "" } else { "s" }
));
return Step::Row(row);
}
let planes = scratch.planes_from_solved(&solved);
if !matches!(build_solid_mesh(&planes), SolidStatus::Closed(_)) {
row.notes
.push("The facets do not close into a stone at this angle.".to_owned());
return Step::Row(row);
}
let Some(solid) = measure_solid(&planes) else {
row.notes
.push("The stone cannot be measured at this angle.".to_owned());
return Step::Row(row);
};
let warning_count = count_warnings(
&check_manufacturability(&scratch, &solved, DEFAULT_MIN_FACET_AREA_FRACTION_OF_W2),
&mut row.notes,
);
let gpu_planes = design_to_gpu_planes_from_solved(&scratch, &solved);
let fast = evaluate_gem_optical_metrics(
&gpu_planes,
shared.scene.material,
0.0,
TABLE_UP_PITCH_RAD,
shared.scene.environment,
);
let tilt = if shared.options.tilt_average {
let Some(averages) = measure_tilt_average(
&gpu_planes,
shared.scene.material,
shared.scene.environment,
&mut |_| !shared.cancel.load(Ordering::Relaxed),
) else {
return Step::Cancelled;
};
Some(averages)
} else {
None
};
row.metrics = Some(RowMetrics {
brilliance_pct: fast.brilliance_pct,
windowing_pct: fast.windowing_pct,
extinction_pct: fast.extinction_pct,
fire_index: fast.fire_index,
scintillation_pct: fast.scintillation_pct,
yield_pct: shared
.preform_volume
.and_then(|preform| volumetric_yield(solid.volume, preform))
.map(|fraction| fraction * 100.0),
warning_count,
has_girdle: solid
.girdle_thickness
.is_some_and(|thickness| thickness > 0.0),
tilt,
});
Step::Row(row)
}
fn set_swept_angle(scratch: &mut Design, tier: usize, angle_deg: f64) -> Result<(), String> {
if let Some(swept) = scratch.tiers.get_mut(tier) {
swept.angle_deg = angle_deg;
}
let updates = scratch
.evaluate_relations()
.map_err(|error| error.to_string())?;
for (position, deg) in updates {
if let Some(driven) = scratch.tiers.get_mut(position) {
driven.angle_deg = deg;
}
}
Ok(())
}
fn count_warnings(warnings: &[ManufacturabilityWarning], notes: &mut Vec<String>) -> usize {
let vanishing = warnings
.iter()
.filter(|warning| matches!(warning, ManufacturabilityWarning::VanishingFacet { .. }))
.count();
let undersized = warnings
.iter()
.filter(|warning| matches!(warning, ManufacturabilityWarning::UndersizedFacet { .. }))
.count();
if vanishing > 0 {
notes.push(format!(
"{vanishing} facet{} vanish{}.",
if vanishing == 1 { "" } else { "s" },
if vanishing == 1 { "es" } else { "" }
));
}
if undersized > 0 {
notes.push(format!(
"{undersized} facet{} very small.",
if undersized == 1 { " is" } else { "s are" }
));
}
vanishing + undersized
}
fn note_lost_girdles(rows: &mut [SweepRow]) {
let had_girdle = rows
.iter()
.find(|row| row.is_current)
.and_then(|row| row.metrics)
.is_some_and(|metrics| metrics.has_girdle);
if !had_girdle {
return;
}
for row in rows.iter_mut().filter(|row| !row.is_current) {
if row.metrics.is_some_and(|metrics| !metrics.has_girdle) {
row.notes
.push("The girdle band is gone at this angle.".to_owned());
}
}
}
pub fn apply_sweep_angle(
session: &mut EditorSession,
tier: usize,
new_deg: f64,
) -> Result<Option<EditChange>, SessionEditError> {
let Some(old_deg) = session.design.tiers.get(tier).map(|t| t.angle_deg) else {
return Err(SessionEditError::Edit(EditError {
index: tier,
tier_count: session.design.tiers.len(),
}));
};
if (old_deg - new_deg).abs() < 1e-9 {
return Ok(None);
}
session
.try_apply(Edit::RetargetAngles {
changes: vec![(tier, old_deg, new_deg)],
})
.map(Some)
}