use super::SweepRow;
const TIE_TOLERANCE: f64 = 0.005;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum SweepMetric {
Brilliance,
Windowing,
Extinction,
Fire,
Scintillation,
Yield,
TiltBrilliance,
TiltWindowing,
TiltExtinction,
}
impl SweepMetric {
pub const ALL: [Self; 9] = [
Self::Brilliance,
Self::Windowing,
Self::Extinction,
Self::Fire,
Self::Scintillation,
Self::Yield,
Self::TiltBrilliance,
Self::TiltWindowing,
Self::TiltExtinction,
];
#[must_use]
pub fn from_index(index: usize) -> Option<Self> {
Self::ALL.get(index).copied()
}
#[must_use]
pub const fn index(self) -> usize {
match self {
Self::Brilliance => 0,
Self::Windowing => 1,
Self::Extinction => 2,
Self::Fire => 3,
Self::Scintillation => 4,
Self::Yield => 5,
Self::TiltBrilliance => 6,
Self::TiltWindowing => 7,
Self::TiltExtinction => 8,
}
}
#[must_use]
pub const fn label(self) -> &'static str {
match self {
Self::Brilliance => "Brilliance",
Self::Windowing => "Windowing",
Self::Extinction => "Extinction",
Self::Fire => "Fire",
Self::Scintillation => "Scintillation",
Self::Yield => "Yield",
Self::TiltBrilliance => "Tilt brilliance",
Self::TiltWindowing => "Tilt windowing",
Self::TiltExtinction => "Tilt extinction",
}
}
#[must_use]
pub const fn column_title(self) -> &'static str {
match self {
Self::Brilliance => "Brilliance %",
Self::Windowing => "Windowing %",
Self::Extinction => "Extinction %",
Self::Fire => "Fire",
Self::Scintillation => "Scint. %",
Self::Yield => "Yield %",
Self::TiltBrilliance => "Tilt brill. %",
Self::TiltWindowing => "Tilt wind. %",
Self::TiltExtinction => "Tilt ext. %",
}
}
#[must_use]
pub const fn csv_name(self) -> &'static str {
match self {
Self::Brilliance => "brilliance_pct",
Self::Windowing => "windowing_pct",
Self::Extinction => "extinction_pct",
Self::Fire => "fire_index",
Self::Scintillation => "scintillation_pct",
Self::Yield => "yield_pct",
Self::TiltBrilliance => "tilt_brilliance_pct",
Self::TiltWindowing => "tilt_windowing_pct",
Self::TiltExtinction => "tilt_extinction_pct",
}
}
#[must_use]
pub const fn unit(self) -> &'static str {
match self {
Self::Fire => "",
_ => " %",
}
}
#[must_use]
pub const fn higher_is_better(self) -> bool {
!matches!(
self,
Self::Windowing | Self::Extinction | Self::TiltWindowing | Self::TiltExtinction
)
}
#[must_use]
pub const fn is_tilt(self) -> bool {
matches!(
self,
Self::TiltBrilliance | Self::TiltWindowing | Self::TiltExtinction
)
}
#[must_use]
pub fn value(self, row: &SweepRow) -> Option<f64> {
let metrics = row.metrics.as_ref()?;
Some(match self {
Self::Brilliance => f64::from(metrics.brilliance_pct),
Self::Windowing => f64::from(metrics.windowing_pct),
Self::Extinction => f64::from(metrics.extinction_pct),
Self::Fire => f64::from(metrics.fire_index),
Self::Scintillation => f64::from(metrics.scintillation_pct),
Self::Yield => return metrics.yield_pct,
Self::TiltBrilliance => f64::from(metrics.tilt.as_ref()?.brilliance_pct),
Self::TiltWindowing => f64::from(metrics.tilt.as_ref()?.windowing_pct),
Self::TiltExtinction => f64::from(metrics.tilt.as_ref()?.extinction_pct),
})
}
#[must_use]
pub fn cell_text(self, row: &SweepRow) -> String {
self.value(row)
.map_or_else(|| "-".to_owned(), |value| format!("{value:.2}"))
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct BestFlags {
pub brilliance: bool,
pub windowing: bool,
pub extinction: bool,
pub fire: bool,
pub scintillation: bool,
pub yield_pct: bool,
pub tilt_brilliance: bool,
pub tilt_windowing: bool,
pub tilt_extinction: bool,
}
impl BestFlags {
#[must_use]
pub const fn get(self, metric: SweepMetric) -> bool {
match metric {
SweepMetric::Brilliance => self.brilliance,
SweepMetric::Windowing => self.windowing,
SweepMetric::Extinction => self.extinction,
SweepMetric::Fire => self.fire,
SweepMetric::Scintillation => self.scintillation,
SweepMetric::Yield => self.yield_pct,
SweepMetric::TiltBrilliance => self.tilt_brilliance,
SweepMetric::TiltWindowing => self.tilt_windowing,
SweepMetric::TiltExtinction => self.tilt_extinction,
}
}
const fn mark(&mut self, metric: SweepMetric) {
match metric {
SweepMetric::Brilliance => self.brilliance = true,
SweepMetric::Windowing => self.windowing = true,
SweepMetric::Extinction => self.extinction = true,
SweepMetric::Fire => self.fire = true,
SweepMetric::Scintillation => self.scintillation = true,
SweepMetric::Yield => self.yield_pct = true,
SweepMetric::TiltBrilliance => self.tilt_brilliance = true,
SweepMetric::TiltWindowing => self.tilt_windowing = true,
SweepMetric::TiltExtinction => self.tilt_extinction = true,
}
}
}
#[must_use]
pub fn best_flags(rows: &[SweepRow]) -> Vec<BestFlags> {
let mut flags = vec![BestFlags::default(); rows.len()];
for metric in SweepMetric::ALL {
let values: Vec<Option<f64>> = rows.iter().map(|row| metric.value(row)).collect();
let (low, high) = values
.iter()
.flatten()
.fold((f64::INFINITY, f64::NEG_INFINITY), |(low, high), &value| {
(low.min(value), high.max(value))
});
if high - low <= TIE_TOLERANCE {
continue;
}
let best = if metric.higher_is_better() { high } else { low };
for (flag, value) in flags.iter_mut().zip(&values) {
if value.is_some_and(|value| (value - best).abs() <= TIE_TOLERANCE) {
flag.mark(metric);
}
}
}
flags
}