ratio_color/

gradient.rs

//! # Color gradient module
//!
//! Treats interpolating between bounds and colors as well as the creation of numerical palettes.
//!
//! ## License
//!
//! This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
//! If a copy of the MPL was not distributed with this file,
//! You can obtain one at <https://mozilla.org/MPL/2.0/>.
//!
//! **Code examples both in the docstrings and rendered documentation are free to use.**

use std::collections::BTreeMap;

use enterpolation::linear::{Linear, LinearError};
use enterpolation::{Identity, Signal, Sorted};
use palette::{LinSrgba, Srgba};
use snafu::prelude::*;

use crate::{HexRgba, Numerical, Palette, Selector};

/// Ratio Color error.
#[derive(Clone, Debug, Snafu)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
pub enum Error {
    /// Linear interpolation error.
    Linear { source: LinearError },
}

/// Capability of interpolating a color at a given fraction between 0.0 and 1.0.
pub trait ColorAtFraction<Color> {
    /// Interpolated color at a given fraction between 0.0 and 1.0.
    fn color_at(&self, fraction: f64) -> Color;
}

/// Enable a CSS gradient generation function.
pub trait CssGradient {
    /// Create a CSS gradient string with the given fractions between 0.0 and 1.0 as knots.
    fn css_gradient(&self, fractions: &[f64]) -> String;
}

/// A linearly interpolated gradient.
#[derive(Clone, Debug, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "reactive", derive(reactive_stores::Store))]
pub struct LinearGradient {
    pub gradient: Linear<Sorted<Vec<f64>>, Vec<LinSrgba<f64>>, Identity>,
}
impl Default for LinearGradient {
    fn default() -> Self {
        Numerical::Ratio.into()
    }
}
impl LinearGradient {
    /// Create a new linear gradient.
    pub fn try_new<Color, Colors>(colors: Colors, knots: Option<&[f64]>) -> Result<Self, Error>
    where
        Color: Into<LinSrgba<f64>>,
        Colors: IntoIterator<Item = Color>,
    {
        let elements: Vec<LinSrgba<f64>> = colors.into_iter().map(|color| color.into()).collect();
        let knots = match knots {
            Some(knots) => knots.to_vec(),
            None => {
                let len = elements.len();
                let step = if len <= 1 {
                    1.0
                } else {
                    1.0 / ((len - 1) as f64)
                };
                (0..len).map(|x| x as f64 * step).collect()
            }
        };
        let linear = Linear::builder()
            .elements(elements)
            .knots(knots)
            .build()
            .with_context(|_| LinearSnafu)?;
        Ok(Self { gradient: linear })
    }
}

impl<C: Into<LinSrgba<f64>>> From<Vec<C>> for LinearGradient {
    fn from(value: Vec<C>) -> Self {
        Self::try_new(value, None).unwrap()
    }
}

impl ColorAtFraction<LinSrgba<f64>> for LinearGradient {
    fn color_at(&self, fraction: f64) -> LinSrgba<f64> {
        self.gradient.eval(fraction)
    }
}

impl ColorAtFraction<Srgba<f64>> for LinearGradient {
    fn color_at(&self, fraction: f64) -> Srgba<f64> {
        Srgba::from_linear(self.gradient.eval(fraction))
    }
}

impl ColorAtFraction<Srgba<u8>> for LinearGradient {
    fn color_at(&self, fraction: f64) -> Srgba<u8> {
        Srgba::from_linear(self.gradient.eval(fraction))
    }
}

impl ColorAtFraction<HexRgba> for LinearGradient {
    fn color_at(&self, fraction: f64) -> HexRgba {
        Srgba::<u8>::from_linear(self.gradient.eval(fraction)).into()
    }
}

impl CssGradient for LinearGradient {
    fn css_gradient(&self, fractions: &[f64]) -> String {
        let colors: String = fractions
            .iter()
            .map(|&f| {
                let color = self.color_at(f);
                format!(
                    "{} {:.0}%",
                    to_rgba_string(Srgba::<u8>::from_linear(color)),
                    100.0 * f
                )
            })
            .collect::<Vec<_>>()
            .join(",");
        format!("linear-gradient({colors})")
    }
}

/// Convert a Srgba (u8) color to a CSS string.
pub fn to_rgba_string<C: Into<Srgba<u8>>>(color: C) -> String {
    let color = color.into();
    format!(
        "rgba({},{},{},{})",
        color.red, color.green, color.blue, color.alpha
    )
}

/// Numerical color scale information. Either knot values paired with colors, or just an array of
/// colors to be mapped across entire domains.
#[derive(Clone, Debug, PartialEq)]
#[cfg_attr(
    feature = "serde",
    derive(serde::Serialize, serde::Deserialize),
    serde(rename_all = "camelCase", untagged)
)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[cfg_attr(feature = "reactive", derive(reactive_stores::Store))]
pub enum NumericalColorScale<Color> {
    Knots(Vec<(f64, Color)>),
    Colors(Vec<Color>),
}

impl<Color: From<Srgba<u8>>> Default for NumericalColorScale<Color> {
    fn default() -> Self {
        Self::Colors(
            crate::Numerical::Ratio
                .colors()
                .into_iter()
                .map(Into::into)
                .collect(),
        )
    }
}

impl<C, Color: From<C>> From<Vec<C>> for NumericalColorScale<Color> {
    fn from(value: Vec<C>) -> Self {
        Self::Colors(value.into_iter().map(Into::into).collect())
    }
}

impl From<NumericalColorScale<Srgba<u8>>> for NumericalColorScale<HexRgba> {
    fn from(value: NumericalColorScale<Srgba<u8>>) -> Self {
        match value {
            NumericalColorScale::Colors(colors) => {
                NumericalColorScale::Colors(colors.into_iter().map(Into::into).collect())
            }
            NumericalColorScale::Knots(knots) => NumericalColorScale::Knots(
                knots
                    .into_iter()
                    .map(|(knot, color)| (knot, color.into()))
                    .collect(),
            ),
        }
    }
}

impl<Color: Into<LinSrgba<f64>>> TryInto<LinearGradient> for NumericalColorScale<Color> {
    type Error = crate::Error;
    fn try_into(self) -> Result<LinearGradient, Self::Error> {
        match self {
            NumericalColorScale::Colors(colors) => LinearGradient::try_new(colors, None),
            NumericalColorScale::Knots(knots) => {
                let (knots, colors): (Vec<f64>, Vec<Color>) = knots.into_iter().unzip();
                LinearGradient::try_new(colors, Some(&knots))
            }
        }
    }
}

impl<Key: Ord, Color: Into<LinSrgba<f64>>> TryFrom<Palette<Key, NumericalColorScale<Color>>>
    for Palette<Key, LinearGradient>
{
    type Error = crate::Error;
    fn try_from(value: Palette<Key, NumericalColorScale<Color>>) -> Result<Self, Self::Error> {
        Ok(Self {
            values: value
                .values
                .into_iter()
                .map(TryInto::<LinearGradient>::try_into)
                .collect::<Result<Vec<LinearGradient>, Self::Error>>()?,
            selectors: value
                .selectors
                .into_iter()
                .map(|(k, sel)| {
                    // convert selector
                    match sel {
                        Selector::Index(index) => Ok(Selector::<LinearGradient>::Index(index)),
                        Selector::KeyOrder => Ok(Selector::<LinearGradient>::KeyOrder),
                        Selector::Value(scale) => {
                            scale.try_into().map(Selector::<LinearGradient>::Value)
                        }
                    }
                    // re-pack with key
                    .map(|sel| (k, sel))
                })
                .collect::<Result<BTreeMap<Key, Selector<LinearGradient>>, Self::Error>>()?,
        })
    }
}