use indicatrix_cut_core::{
MaterialClass, ProportionMetric, ShapeClass, critical_angle_deg,
design::labelling::name_indicates_pavilion, proportions_windows::window_for,
};
use crate::loading::eval_number;
pub const ANGLE_STEP_DEG: f64 = 0.05;
pub const ANGLE_FINE_STEP_DEG: f64 = 0.01;
pub const ANGLE_MARK_DEG: f64 = 0.5;
pub const CROWN_MIN_DEG: f64 = 5.0;
pub const CROWN_MAX_DEG: f64 = 55.0;
pub const PAVILION_MIN_DEG: f64 = 30.0;
pub const PAVILION_MAX_DEG: f64 = 55.0;
pub const BAND_NEAR_DEG: f64 = 1.0;
pub const BAND_FAR_DEG: f64 = 6.0;
const SAFE_MARGIN_DEG: f64 = 2.0;
const GIRDLE_DEG: f64 = 90.0;
const GIRDLE_TOLERANCE_DEG: f64 = 1e-6;
const SLIDER_CEILING_DEG: f64 = 85.0;
const USABLE_INDEX: std::ops::RangeInclusive<f64> = 1.05..=6.0;
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct SliderRange {
pub min: f64,
pub max: f64,
pub step: f64,
pub fine_step: f64,
pub mark: f64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AngleSide {
Pavilion,
Crown,
}
impl AngleSide {
#[must_use]
pub const fn name(self) -> &'static str {
match self {
Self::Pavilion => "Pavilion",
Self::Crown => "Crown",
}
}
#[must_use]
pub fn from_name(name: &str) -> Option<Self> {
match name {
"Pavilion" => Some(Self::Pavilion),
"Crown" => Some(Self::Crown),
_ => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct AngleSlider {
pub range: SliderRange,
pub critical_deg: Option<f64>,
pub band: Option<(f64, f64)>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct AnglePreset {
pub label: String,
pub value_deg: f64,
pub value_text: String,
pub reason: String,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum AngleField {
Degrees(f64),
Relation,
Unreadable,
}
#[derive(Debug, Clone, PartialEq, Default)]
pub struct SliderSpecData {
pub visible: bool,
pub usable: bool,
pub side: String,
pub value: f64,
pub range: SliderRange,
pub band: Option<(f64, f64)>,
pub note: String,
pub value_text: String,
}
fn usable_index(n_d: f64) -> bool {
n_d.is_finite() && USABLE_INDEX.contains(&n_d)
}
fn parse_index_text(text: &str) -> f64 {
text.trim().parse().unwrap_or(f64::NAN)
}
fn round_hundredths(value: f64) -> f64 {
(value * 100.0).round() / 100.0
}
fn ceil_to_step(value: f64, step: f64) -> f64 {
let steps = ((value / step) * 1e6).round() / 1e6;
round_hundredths(steps.ceil() * step)
}
fn angle_over_critical(critical: f64, margin: f64) -> f64 {
let value = ceil_to_step(critical + margin, ANGLE_STEP_DEG);
if value - critical < margin {
round_hundredths(value + ANGLE_STEP_DEG)
} else {
value
}
}
fn floor_to(value: f64, unit: f64) -> f64 {
(value / unit).floor() * unit
}
fn ceil_to(value: f64, unit: f64) -> f64 {
(value / unit).ceil() * unit
}
fn two_decimals(value: f64) -> String {
let rounded = round_hundredths(value);
if rounded == 0.0 {
"0.00".to_owned()
} else {
format!("{rounded:.2}")
}
}
#[must_use]
pub fn angle_slider(side: AngleSide, n_d: f64) -> AngleSlider {
let critical_deg = usable_index(n_d).then(|| critical_angle_deg(n_d));
let (mut min, mut max) = match side {
AngleSide::Pavilion => (PAVILION_MIN_DEG, PAVILION_MAX_DEG),
AngleSide::Crown => (CROWN_MIN_DEG, CROWN_MAX_DEG),
};
let band = critical_deg
.filter(|_| side == AngleSide::Pavilion)
.map(|critical| (critical + BAND_NEAR_DEG, critical + BAND_FAR_DEG));
if let Some((from, to)) = band {
min = min.min(floor_to(from, 5.0)).max(5.0);
max = max.max(ceil_to(to, 5.0)).min(SLIDER_CEILING_DEG);
}
AngleSlider {
range: SliderRange {
min,
max,
step: ANGLE_STEP_DEG,
fine_step: ANGLE_FINE_STEP_DEG,
mark: ANGLE_MARK_DEG,
},
critical_deg,
band,
}
}
#[must_use]
pub fn read_angle_field(text: &str) -> AngleField {
let trimmed = text.trim();
if trimmed.starts_with('=') {
return AngleField::Relation;
}
if trimmed.is_empty() {
return AngleField::Degrees(0.0);
}
match eval_number(trimmed, None) {
Ok(value) if value.is_finite() => AngleField::Degrees(value),
_ => AngleField::Unreadable,
}
}
#[must_use]
pub fn format_angle_text(value_deg: f64, like: &str) -> String {
let magnitude = round_hundredths(value_deg.abs());
if magnitude > 0.0 && like.trim_start().starts_with('-') {
format!("-{magnitude:.2}")
} else {
format!("{magnitude:.2}")
}
}
#[must_use]
pub fn stepped_angle_text(current: &str, delta_deg: f64) -> Option<String> {
let trimmed = current.trim();
let start = if trimmed.is_empty() {
0.0
} else {
trimmed
.parse::<f64>()
.ok()
.filter(|value| value.is_finite())?
};
let stepped = round_hundredths(start + delta_deg);
if !stepped.is_finite() {
return None;
}
Some(if stepped == 0.0 {
if trimmed.starts_with('-') {
"-0.00".to_owned()
} else {
"0.00".to_owned()
}
} else {
format!("{stepped:.2}")
})
}
#[must_use]
pub fn margin_preview_text(side: Option<AngleSide>, text: &str) -> String {
if side == Some(AngleSide::Pavilion)
&& let AngleField::Degrees(value) = read_angle_field(text)
&& value > 0.0
{
format!("-{value}")
} else {
text.to_owned()
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct AngleSliderState {
pub side: AngleSide,
pub value_deg: Option<f64>,
pub slider: AngleSlider,
}
#[must_use]
pub fn angle_slider_state(
kind: &str,
text: &str,
name: &str,
n_d: f64,
) -> Option<AngleSliderState> {
let value_deg = match read_angle_field(text) {
AngleField::Relation => return None,
AngleField::Degrees(value) => Some(value.abs()),
AngleField::Unreadable => None,
};
let side = match kind {
"Driven" | "Girdle" | "Horizontal" => return None,
"Pavilion" => AngleSide::Pavilion,
"Crown" => AngleSide::Crown,
_ if text.trim_start().starts_with('-') || name_indicates_pavilion(name) => {
AngleSide::Pavilion
}
_ => AngleSide::Crown,
};
if value_deg.is_some_and(|value| (value - GIRDLE_DEG).abs() < GIRDLE_TOLERANCE_DEG) {
return None;
}
Some(AngleSliderState {
side,
value_deg,
slider: angle_slider(side, n_d),
})
}
fn material_label(material_name: &str) -> String {
let name = material_name.trim();
if name.is_empty() || name == "(none)" {
"this stone".to_owned()
} else {
name.to_owned()
}
}
const fn class_words(class: MaterialClass) -> &'static str {
match class {
MaterialClass::High => "high-index stones such as diamond",
MaterialClass::Mid | MaterialClass::Low => "colored stones",
}
}
fn preset(label: String, value_deg: f64, reason: String) -> AnglePreset {
AnglePreset {
label,
value_deg,
value_text: format!("{value_deg:.2}\u{b0}"),
reason,
}
}
fn pavilion_presets(n_d: f64, material_name: &str) -> Vec<AnglePreset> {
let critical = critical_angle_deg(n_d);
let class = MaterialClass::from_ri(n_d);
let mut presets = Vec::with_capacity(3);
if let Some(window) = window_for(ShapeClass::Round, class, ProportionMetric::PavilionAngle) {
let middle = ceil_to_step(f64::midpoint(window.min, window.max), ANGLE_STEP_DEG);
let safe = angle_over_critical(critical, SAFE_MARGIN_DEG);
let raised = safe > middle;
let usual = format!(
"The middle of the usual {:.1}\u{b0} to {:.1}\u{b0} range for {}.",
window.min,
window.max,
class_words(class)
);
let reason = if raised {
format!("{usual} Raised to keep 2\u{b0} over the critical angle ({critical:.1}\u{b0}).")
} else {
usual
};
presets.push(preset(
format!("Standard for {}", material_label(material_name)),
if raised { safe } else { middle },
reason,
));
}
presets.push(preset(
"Critical angle + 2\u{b0} (bright, safe)".to_owned(),
angle_over_critical(critical, SAFE_MARGIN_DEG),
format!(
"The lowest angle the margin bar calls Safe: the critical angle ({critical:.1}\u{b0}) plus 2\u{b0}."
),
));
presets.push(preset(
"Critical angle + 4\u{b0} (extra margin)".to_owned(),
angle_over_critical(critical, 2.0 * SAFE_MARGIN_DEG),
"More room for a cutting error or a change of stone.".to_owned(),
));
presets
}
fn crown_presets(n_d: f64, material_name: &str) -> Vec<AnglePreset> {
let class = if usable_index(n_d) {
MaterialClass::from_ri(n_d)
} else {
MaterialClass::Mid
};
let mut presets = Vec::with_capacity(4);
if let Some(window) = window_for(ShapeClass::Round, class, ProportionMetric::CrownAngle) {
presets.push(preset(
format!("Standard for {}", material_label(material_name)),
ceil_to_step(f64::midpoint(window.min, window.max), ANGLE_STEP_DEG),
format!(
"The middle of the usual {:.1}\u{b0} to {:.1}\u{b0} range for {}.",
window.min,
window.max,
class_words(class)
),
));
}
presets.push(preset(
"Low crown".to_owned(),
25.0,
"A flat crown: a large table and little height.".to_owned(),
));
presets.push(preset(
"Medium crown".to_owned(),
32.0,
"A balanced crown.".to_owned(),
));
presets.push(preset(
"High crown".to_owned(),
40.0,
"A steep crown: a small table and more height.".to_owned(),
));
presets
}
#[must_use]
pub fn angle_presets(side: AngleSide, n_d: f64, material_name: &str) -> Vec<AnglePreset> {
let mut presets = match side {
AngleSide::Pavilion if usable_index(n_d) => pavilion_presets(n_d, material_name),
AngleSide::Pavilion => Vec::new(),
AngleSide::Crown => crown_presets(n_d, material_name),
};
let mut seen: Vec<f64> = Vec::with_capacity(presets.len());
presets.retain(|entry| {
if seen
.iter()
.any(|value| (value - entry.value_deg).abs() < ANGLE_STEP_DEG / 2.0)
{
false
} else {
seen.push(entry.value_deg);
true
}
});
presets
}
fn angle_note(side: AngleSide, slider: &AngleSlider, n_d: f64) -> String {
match (side, slider.band, slider.critical_deg) {
(AngleSide::Pavilion, Some((from, to)), Some(critical)) => format!(
"Green band: {from:.1}\u{b0} to {to:.1}\u{b0}, which is 1\u{b0} to 6\u{b0} over this stone's critical angle ({critical:.1}\u{b0})."
),
(AngleSide::Crown, ..) => {
let class = if usable_index(n_d) {
MaterialClass::from_ri(n_d)
} else {
MaterialClass::Mid
};
window_for(ShapeClass::Round, class, ProportionMetric::CrownAngle).map_or_else(
String::new,
|window| {
format!(
"The usual crown range for {} is {:.0}\u{b0} to {:.0}\u{b0}.",
class_words(class),
window.min,
window.max
)
},
)
}
_ => String::new(),
}
}
#[must_use]
pub fn angle_spec_data(kind: &str, text: &str, name: &str, ri_text: &str) -> SliderSpecData {
let n_d = parse_index_text(ri_text);
let Some(AngleSliderState {
side,
value_deg,
slider,
}) = angle_slider_state(kind, text, name, n_d)
else {
return SliderSpecData::default();
};
SliderSpecData {
visible: true,
usable: value_deg.is_some(),
side: side.name().to_owned(),
value: value_deg.unwrap_or(0.0),
range: slider.range,
band: slider.band,
note: angle_note(side, &slider, n_d),
value_text: value_deg.map_or_else(String::new, |value| format!("{value:.2} degrees")),
}
}
#[must_use]
pub fn angle_presets_for(side: &str, ri_text: &str, material_name: &str) -> Vec<AnglePreset> {
AngleSide::from_name(side).map_or_else(Vec::new, |side| {
angle_presets(side, parse_index_text(ri_text), material_name)
})
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PreformField {
HalfWidth,
LengthOverWidth,
Depth,
YOffsetMm,
}
impl PreformField {
#[must_use]
pub fn from_name(name: &str) -> Option<Self> {
match name {
"half_width" => Some(Self::HalfWidth),
"length_over_width" => Some(Self::LengthOverWidth),
"depth" => Some(Self::Depth),
"y_offset" => Some(Self::YOffsetMm),
_ => None,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct NumberSlider {
pub range: SliderRange,
pub value: Option<f64>,
pub usable: bool,
pub note: String,
}
const HALF_WIDTH_RANGE: SliderRange = SliderRange {
min: 1.0,
max: 3.0,
step: 0.05,
fine_step: 0.01,
mark: 0.25,
};
const LENGTH_OVER_WIDTH_RANGE: SliderRange = SliderRange {
min: 1.0,
max: 2.5,
step: 0.05,
fine_step: 0.01,
mark: 0.25,
};
const DEPTH_RANGE: SliderRange = SliderRange {
min: 1.0,
max: 3.5,
step: 0.05,
fine_step: 0.01,
mark: 0.5,
};
const Y_OFFSET_PLACEHOLDER_RANGE: SliderRange = SliderRange {
min: -1.0,
max: 1.0,
step: 0.05,
fine_step: 0.01,
mark: 0.5,
};
fn positive_number(text: &str) -> Option<f64> {
eval_number(text, None)
.ok()
.filter(|value| value.is_finite() && *value > 0.0)
}
fn y_offset_range(depth_text: &str, girdle_diameter_text: &str) -> Option<SliderRange> {
let depth = positive_number(depth_text)?;
let girdle = positive_number(girdle_diameter_text)?;
let reach = ceil_to(depth * girdle / 4.0, 0.5).max(0.5);
Some(SliderRange {
min: -reach,
max: reach,
step: 0.05,
fine_step: 0.01,
mark: 0.5,
})
}
#[must_use]
pub fn preform_slider(
field: PreformField,
text: &str,
depth_text: &str,
girdle_diameter_text: &str,
) -> NumberSlider {
let value = eval_number(text, None)
.ok()
.filter(|value| value.is_finite());
let (range, scale_known) = match field {
PreformField::HalfWidth => (HALF_WIDTH_RANGE, true),
PreformField::LengthOverWidth => (LENGTH_OVER_WIDTH_RANGE, true),
PreformField::Depth => (DEPTH_RANGE, true),
PreformField::YOffsetMm => y_offset_range(depth_text, girdle_diameter_text)
.map_or((Y_OFFSET_PLACEHOLDER_RANGE, false), |range| (range, true)),
};
let note = if scale_known {
String::new()
} else {
"Set a Girdle Diameter (Yield section below) to use this slider.".to_owned()
};
NumberSlider {
range,
value,
usable: value.is_some() && scale_known,
note,
}
}
#[must_use]
pub fn format_slider_number(value: f64) -> String {
two_decimals(value)
}
#[must_use]
pub fn preform_spec_data(
field: &str,
text: &str,
depth_text: &str,
girdle_diameter_text: &str,
) -> SliderSpecData {
let Some(field) = PreformField::from_name(field) else {
return SliderSpecData::default();
};
let slider = preform_slider(field, text, depth_text, girdle_diameter_text);
SliderSpecData {
visible: true,
usable: slider.usable,
side: String::new(),
value: slider.value.unwrap_or(0.0),
range: slider.range,
band: None,
note: slider.note,
value_text: slider
.value
.map_or_else(String::new, |value| format!("{value:.2}")),
}
}
#[cfg(test)]
mod tests;