chromashift 0.0.33

A library for converting between various color formats and color spaces.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use crate::{LinearRgb, ToAlpha};
use core::fmt;

/// An RGB colour space with defined chromacities.
/// The components are:
/// - Red - a number between 0 and 255
/// - Blue - a number between 0 and 255
/// - Green - a number between 0 and 255
/// - Alpha - a number between 0.0 and 100.0
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Srgb {
	pub red: u8,
	pub green: u8,
	pub blue: u8,
	pub alpha: f32,
}

impl Srgb {
	pub fn new(red: u8, green: u8, blue: u8, alpha: f32) -> Self {
		Self { red, green, blue, alpha: alpha.clamp(0.0, 100.0) }
	}
}

impl ToAlpha for Srgb {
	fn to_alpha(&self) -> f32 {
		self.alpha
	}
}

impl fmt::Display for Srgb {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		let Self { red, green, blue, alpha } = self;
		write!(f, "rgb({red} {green} {blue}")?;
		if *alpha < 100.0 {
			write!(f, " / {alpha}%")?;
		}
		write!(f, ")")
	}
}

fn linear(c: f64) -> f64 {
	if c > 0.04045 { ((c + 0.055) / 1.055).powf(2.4) } else { c / 12.92 }
}

fn gamma(u: f64) -> f64 {
	if u <= 0.0031308 { u * 12.92 } else { 1.055 * u.powf(1.0 / 2.4) - 0.055 }
}

fn clamp01(value: f64) -> f64 {
	value.clamp(0.0, 1.0)
}

impl From<Srgb> for LinearRgb {
	fn from(value: Srgb) -> Self {
		let Srgb { red, green, blue, alpha } = value;
		LinearRgb::new(linear(red as f64 / 255.0), linear(green as f64 / 255.0), linear(blue as f64 / 255.0), alpha)
	}
}

impl From<LinearRgb> for Srgb {
	fn from(value: LinearRgb) -> Self {
		let LinearRgb { red, green, blue, alpha } = value;
		Srgb::new(
			(gamma(clamp01(red)) * 255.0).round() as u8,
			(gamma(clamp01(green)) * 255.0).round() as u8,
			(gamma(clamp01(blue)) * 255.0).round() as u8,
			alpha,
		)
	}
}

#[cfg(feature = "anstyle")]
impl From<Srgb> for anstyle::RgbColor {
	fn from(value: Srgb) -> Self {
		anstyle::RgbColor(value.red, value.green, value.blue)
	}
}

#[cfg(feature = "anstyle")]
impl From<anstyle::RgbColor> for Srgb {
	fn from(value: anstyle::RgbColor) -> Self {
		Srgb::new(value.0, value.1, value.2, 100.0)
	}
}

#[cfg(feature = "owo-colors")]
impl From<Srgb> for owo_colors::Rgb {
	fn from(value: Srgb) -> Self {
		owo_colors::Rgb(value.red, value.green, value.blue)
	}
}

#[cfg(feature = "owo-colors")]
impl From<owo_colors::Rgb> for Srgb {
	fn from(value: owo_colors::Rgb) -> Self {
		Srgb::new(value.0, value.1, value.2, 100.0)
	}
}