rgb2spec 0.1.1

//  This file contains:
//  1. CIE 1931 curves at sampled at 5nm intervals
//  2. CIE D65, D50 and D60 spectra sampled at 5nm intervals,
//     normalized to have unit luminance.
//  3. A convenience function "cie_interp" to access the discretized
//     data at arbitrary wavelengths (with linear interpolation)

pub(crate) const LAMBDA_MIN: f64 = 360.0;
pub(crate) const LAMBDA_MAX: f64 = 830.0;
pub(crate) const LAMBDA_RANGE: f64 = LAMBDA_MAX - LAMBDA_MIN;
pub(crate) const SAMPLES: usize = 95;

pub(crate) static OBSERVER_X: [f64; SAMPLES] = [
    0.000129900000,
    0.000232100000,
    0.000414900000,
    0.000741600000,
    0.001368000000,
    0.002236000000,
    0.004243000000,
    0.007650000000,
    0.014310000000,
    0.023190000000,
    0.043510000000,
    0.077630000000,
    0.134380000000,
    0.214770000000,
    0.283900000000,
    0.328500000000,
    0.348280000000,
    0.348060000000,
    0.336200000000,
    0.318700000000,
    0.290800000000,
    0.251100000000,
    0.195360000000,
    0.142100000000,
    0.095640000000,
    0.057950010000,
    0.032010000000,
    0.014700000000,
    0.004900000000,
    0.002400000000,
    0.009300000000,
    0.029100000000,
    0.063270000000,
    0.109600000000,
    0.165500000000,
    0.225749900000,
    0.290400000000,
    0.359700000000,
    0.433449900000,
    0.512050100000,
    0.594500000000,
    0.678400000000,
    0.762100000000,
    0.842500000000,
    0.916300000000,
    0.978600000000,
    1.026300000000,
    1.056700000000,
    1.062200000000,
    1.045600000000,
    1.002600000000,
    0.938400000000,
    0.854449900000,
    0.751400000000,
    0.642400000000,
    0.541900000000,
    0.447900000000,
    0.360800000000,
    0.283500000000,
    0.218700000000,
    0.164900000000,
    0.121200000000,
    0.087400000000,
    0.063600000000,
    0.046770000000,
    0.032900000000,
    0.022700000000,
    0.015840000000,
    0.011359160000,
    0.008110916000,
    0.005790346000,
    0.004109457000,
    0.002899327000,
    0.002049190000,
    0.001439971000,
    0.000999949300,
    0.000690078600,
    0.000476021300,
    0.000332301100,
    0.000234826100,
    0.000166150500,
    0.000117413000,
    0.000083075270,
    0.000058706520,
    0.000041509940,
    0.000029353260,
    0.000020673830,
    0.000014559770,
    0.000010253980,
    0.000007221456,
    0.000005085868,
    0.000003581652,
    0.000002522525,
    0.000001776509,
    0.000001251141,
];

pub(crate) static OBSERVER_Y: [f64; SAMPLES] = [
    0.000003917000,
    0.000006965000,
    0.000012390000,
    0.000022020000,
    0.000039000000,
    0.000064000000,
    0.000120000000,
    0.000217000000,
    0.000396000000,
    0.000640000000,
    0.001210000000,
    0.002180000000,
    0.004000000000,
    0.007300000000,
    0.011600000000,
    0.016840000000,
    0.023000000000,
    0.029800000000,
    0.038000000000,
    0.048000000000,
    0.060000000000,
    0.073900000000,
    0.090980000000,
    0.112600000000,
    0.139020000000,
    0.169300000000,
    0.208020000000,
    0.258600000000,
    0.323000000000,
    0.407300000000,
    0.503000000000,
    0.608200000000,
    0.710000000000,
    0.793200000000,
    0.862000000000,
    0.914850100000,
    0.954000000000,
    0.980300000000,
    0.994950100000,
    1.000000000000,
    0.995000000000,
    0.978600000000,
    0.952000000000,
    0.915400000000,
    0.870000000000,
    0.816300000000,
    0.757000000000,
    0.694900000000,
    0.631000000000,
    0.566800000000,
    0.503000000000,
    0.441200000000,
    0.381000000000,
    0.321000000000,
    0.265000000000,
    0.217000000000,
    0.175000000000,
    0.138200000000,
    0.107000000000,
    0.081600000000,
    0.061000000000,
    0.044580000000,
    0.032000000000,
    0.023200000000,
    0.017000000000,
    0.011920000000,
    0.008210000000,
    0.005723000000,
    0.004102000000,
    0.002929000000,
    0.002091000000,
    0.001484000000,
    0.001047000000,
    0.000740000000,
    0.000520000000,
    0.000361100000,
    0.000249200000,
    0.000171900000,
    0.000120000000,
    0.000084800000,
    0.000060000000,
    0.000042400000,
    0.000030000000,
    0.000021200000,
    0.000014990000,
    0.000010600000,
    0.000007465700,
    0.000005257800,
    0.000003702900,
    0.000002607800,
    0.000001836600,
    0.000001293400,
    0.000000910930,
    0.000000641530,
    0.000000451810,
];

pub(crate) static OBSERVER_Z: [f64; SAMPLES] = [
    0.000606100000,
    0.001086000000,
    0.001946000000,
    0.003486000000,
    0.006450001000,
    0.010549990000,
    0.020050010000,
    0.036210000000,
    0.067850010000,
    0.110200000000,
    0.207400000000,
    0.371300000000,
    0.645600000000,
    1.039050100000,
    1.385600000000,
    1.622960000000,
    1.747060000000,
    1.782600000000,
    1.772110000000,
    1.744100000000,
    1.669200000000,
    1.528100000000,
    1.287640000000,
    1.041900000000,
    0.812950100000,
    0.616200000000,
    0.465180000000,
    0.353300000000,
    0.272000000000,
    0.212300000000,
    0.158200000000,
    0.111700000000,
    0.078249990000,
    0.057250010000,
    0.042160000000,
    0.029840000000,
    0.020300000000,
    0.013400000000,
    0.008749999000,
    0.005749999000,
    0.003900000000,
    0.002749999000,
    0.002100000000,
    0.001800000000,
    0.001650001000,
    0.001400000000,
    0.001100000000,
    0.001000000000,
    0.000800000000,
    0.000600000000,
    0.000340000000,
    0.000240000000,
    0.000190000000,
    0.000100000000,
    0.000049999990,
    0.000030000000,
    0.000020000000,
    0.000010000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
    0.000000000000,
];

macro_rules! n {
    ( $x:expr ) => {
        $x / 10566.864005283874576
    };
}

#[allow(clippy::excessive_precision)]
pub(crate) static ILLUMINANT_D65: [f64; SAMPLES] = [
    n!(46.6383),
    n!(49.3637),
    n!(52.0891),
    n!(51.0323),
    n!(49.9755),
    n!(52.3118),
    n!(54.6482),
    n!(68.7015),
    n!(82.7549),
    n!(87.1204),
    n!(91.486),
    n!(92.4589),
    n!(93.4318),
    n!(90.057),
    n!(86.6823),
    n!(95.7736),
    n!(104.865),
    n!(110.936),
    n!(117.008),
    n!(117.41),
    n!(117.812),
    n!(116.336),
    n!(114.861),
    n!(115.392),
    n!(115.923),
    n!(112.367),
    n!(108.811),
    n!(109.082),
    n!(109.354),
    n!(108.578),
    n!(107.802),
    n!(106.296),
    n!(104.79),
    n!(106.239),
    n!(107.689),
    n!(106.047),
    n!(104.405),
    n!(104.225),
    n!(104.046),
    n!(102.023),
    n!(100.0),
    n!(98.1671),
    n!(96.3342),
    n!(96.0611),
    n!(95.788),
    n!(92.2368),
    n!(88.6856),
    n!(89.3459),
    n!(90.0062),
    n!(89.8026),
    n!(89.5991),
    n!(88.6489),
    n!(87.6987),
    n!(85.4936),
    n!(83.2886),
    n!(83.4939),
    n!(83.6992),
    n!(81.863),
    n!(80.0268),
    n!(80.1207),
    n!(80.2146),
    n!(81.2462),
    n!(82.2778),
    n!(80.281),
    n!(78.2842),
    n!(74.0027),
    n!(69.7213),
    n!(70.6652),
    n!(71.6091),
    n!(72.979),
    n!(74.349),
    n!(67.9765),
    n!(61.604),
    n!(65.7448),
    n!(69.8856),
    n!(72.4863),
    n!(75.087),
    n!(69.3398),
    n!(63.5927),
    n!(55.0054),
    n!(46.4182),
    n!(56.6118),
    n!(66.8054),
    n!(65.0941),
    n!(63.3828),
    n!(63.8434),
    n!(64.304),
    n!(61.8779),
    n!(59.4519),
    n!(55.7054),
    n!(51.959),
    n!(54.6998),
    n!(57.4406),
    n!(58.8765),
    n!(60.3125),
];

pub(crate) static ILLUMINANT_E: [f64; SAMPLES] = [1.0 / 106.8; SAMPLES];

macro_rules! m {
    ( $x:expr ) => {
        $x / 10503.2
    };
}

pub(crate) static ILLUMINANT_D50: [f64; SAMPLES] = [
    m!(23.942000),
    m!(25.451000),
    m!(26.961000),
    m!(25.724000),
    m!(24.488000),
    m!(27.179000),
    m!(29.871000),
    m!(39.589000),
    m!(49.308000),
    m!(52.910000),
    m!(56.513000),
    m!(58.273000),
    m!(60.034000),
    m!(58.926000),
    m!(57.818000),
    m!(66.321000),
    m!(74.825000),
    m!(81.036000),
    m!(87.247000),
    m!(88.930000),
    m!(90.612000),
    m!(90.990000),
    m!(91.368000),
    m!(93.238000),
    m!(95.109000),
    m!(93.536000),
    m!(91.963000),
    m!(93.843000),
    m!(95.724000),
    m!(96.169000),
    m!(96.613000),
    m!(96.871000),
    m!(97.129000),
    m!(99.614000),
    m!(102.099000),
    m!(101.427000),
    m!(100.755000),
    m!(101.536000),
    m!(102.317000),
    m!(101.159000),
    m!(100.000000),
    m!(98.868000),
    m!(97.735000),
    m!(98.327000),
    m!(98.918000),
    m!(96.208000),
    m!(93.499000),
    m!(95.593000),
    m!(97.688000),
    m!(98.478000),
    m!(99.269000),
    m!(99.155000),
    m!(99.042000),
    m!(97.382000),
    m!(95.722000),
    m!(97.290000),
    m!(98.857000),
    m!(97.262000),
    m!(95.667000),
    m!(96.929000),
    m!(98.190000),
    m!(100.597000),
    m!(103.003000),
    m!(101.068000),
    m!(99.133000),
    m!(93.257000),
    m!(87.381000),
    m!(89.492000),
    m!(91.604000),
    m!(92.246000),
    m!(92.889000),
    m!(84.872000),
    m!(76.854000),
    m!(81.683000),
    m!(86.511000),
    m!(89.546000),
    m!(92.580000),
    m!(85.405000),
    m!(78.230000),
    m!(67.961000),
    m!(57.692000),
    m!(70.307000),
    m!(82.923000),
    m!(80.599000),
    m!(78.274000),
    // These values are wrong to match the original repo
    m!(0.0),
    m!(0.0),
    m!(0.0),
    m!(0.0),
    m!(0.0),
    m!(0.0),
    m!(0.0),
    m!(0.0),
    m!(0.0),
    m!(0.0),
];

macro_rules! o {
    ( $x:expr ) => {
        $x / 10536.3
    };
}

pub(crate) static ILLUMINANT_D60: [f64; SAMPLES] = [
    o!(38.683115),
    o!(41.014457),
    o!(42.717548),
    o!(42.264182),
    o!(41.454941),
    o!(41.763698),
    o!(46.605319),
    o!(59.226938),
    o!(72.278594),
    o!(78.231500),
    o!(80.440600),
    o!(82.739580),
    o!(82.915027),
    o!(79.009168),
    o!(77.676264),
    o!(85.163609),
    o!(95.681274),
    o!(103.267764),
    o!(107.954821),
    o!(109.777964),
    o!(109.559187),
    o!(108.418402),
    o!(107.758141),
    o!(109.071548),
    o!(109.671404),
    o!(106.734741),
    o!(103.707873),
    o!(103.981942),
    o!(105.232199),
    o!(105.235867),
    o!(104.427667),
    o!(103.052881),
    o!(102.522934),
    o!(104.371416),
    o!(106.052671),
    o!(104.948900),
    o!(103.315154),
    o!(103.416286),
    o!(103.538599),
    o!(102.099304),
    o!(100.000000),
    o!(97.992725),
    o!(96.751421),
    o!(97.102402),
    o!(96.712823),
    o!(93.174457),
    o!(89.921479),
    o!(90.351933),
    o!(91.999793),
    o!(92.384009),
    o!(92.098710),
    o!(91.722859),
    o!(90.646003),
    o!(88.327552),
    o!(86.526483),
    o!(87.034239),
    o!(87.579186),
    o!(85.884584),
    o!(83.976140),
    o!(83.743140),
    o!(84.724074),
    o!(86.450818),
    o!(87.493491),
    o!(86.546330),
    o!(83.483070),
    o!(78.268785),
    o!(74.172451),
    o!(74.275184),
    o!(76.620385),
    o!(79.423856),
    o!(79.051849),
    o!(71.763360),
    o!(65.471371),
    o!(67.984085),
    o!(74.106079),
    o!(78.556612),
    o!(79.527120),
    o!(75.584935),
    o!(67.307163),
    o!(55.275106),
    o!(49.273538),
    o!(59.008629),
    o!(70.892412),
    o!(70.950115),
    o!(67.163996),
    o!(67.445480),
    o!(68.171371),
    o!(66.466636),
    o!(62.989809),
    o!(58.067786),
    o!(54.990892),
    o!(56.915942),
    o!(60.825601),
    o!(62.987850),
    o!(0.0000000), // This value is wrong to match the original repo
];

pub(crate) fn cie_interp(data: [f64; SAMPLES], x: f64) -> f64 {
    let x = (x - LAMBDA_MIN) * ((SAMPLES - 1) as f64 / LAMBDA_RANGE);
    let offset = (x as usize).min(SAMPLES - 2);
    let weight = x - offset as f64;

    (1.0 - weight) * data[offset] + weight * data[offset + 1]
}