Add color weights to Grayscale node and improve luminance handling (#1015)

* Add weighted grayscale node

* Rename nodes, fix grayscale weighting, add luma calc options

* Fix tests

* Add Tint Option

* Improve (but not full fix) tint

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>

node-graph/gcore/src/raster/adjustments.rs

@@ -2,16 +2,48 @@ use super::Color;
 use crate::Node;
 
 use core::fmt::Debug;
+use dyn_any::{DynAny, StaticType};
+
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, DynAny, specta::Type, Hash)]
+pub enum LuminanceCalculation {
+	#[default]
+	SRGB,
+	Perceptual,
+	AverageChannels,
+}
+
+impl LuminanceCalculation {
+	pub fn list() -> [LuminanceCalculation; 3] {
+		[LuminanceCalculation::SRGB, LuminanceCalculation::Perceptual, LuminanceCalculation::AverageChannels]
+	}
+}
+
+impl std::fmt::Display for LuminanceCalculation {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			LuminanceCalculation::SRGB => write!(f, "sRGB"),
+			LuminanceCalculation::Perceptual => write!(f, "Perceptual"),
+			LuminanceCalculation::AverageChannels => write!(f, "Average Channels"),
+		}
+	}
+}
 
 #[derive(Debug, Clone, Copy, Default)]
-pub struct GrayscaleNode;
+pub struct LuminanceNode<LuminanceCalculation> {
+	luma_calculation: LuminanceCalculation,
+}
 
-#[node_macro::node_fn(GrayscaleNode)]
-fn grayscale_color_node(color: Color) -> Color {
+#[node_macro::node_fn(LuminanceNode)]
+fn luminance_color_node(color: Color, luma_calculation: LuminanceCalculation) -> Color {
 	// TODO: Remove conversion to linear when the whole node graph uses linear color
 	let color = color.to_linear_srgb();
 
-	let luminance = color.luminance();
+	let luminance = match luma_calculation {
+		LuminanceCalculation::SRGB => color.luminance_srgb(),
+		LuminanceCalculation::Perceptual => color.luminance_perceptual(),
+		LuminanceCalculation::AverageChannels => color.average_rgb_channels(),
+	};
 
 	// TODO: Remove conversion to linear when the whole node graph uses linear color
 	let luminance = Color::linear_to_srgb(luminance);
@@ -19,6 +51,51 @@ fn grayscale_color_node(color: Color) -> Color {
 	color.map_rgb(|_| luminance)
 }
 
+#[derive(Debug, Clone, Copy, Default)]
+pub struct GrayscaleNode<Tint, Reds, Yellows, Greens, Cyans, Blues, Magentas> {
+	tint: Tint,
+	reds: Reds,
+	yellows: Yellows,
+	greens: Greens,
+	cyans: Cyans,
+	blues: Blues,
+	magentas: Magentas,
+}
+
+// From <https://stackoverflow.com/a/55233732/775283>
+// Works the same for gamma and linear color
+#[node_macro::node_fn(GrayscaleNode)]
+fn grayscale_color_node(color: Color, tint: Color, reds: f64, yellows: f64, greens: f64, cyans: f64, blues: f64, magentas: f64) -> Color {
+	let reds = reds as f32 / 100.;
+	let yellows = yellows as f32 / 100.;
+	let greens = greens as f32 / 100.;
+	let cyans = cyans as f32 / 100.;
+	let blues = blues as f32 / 100.;
+	let magentas = magentas as f32 / 100.;
+
+	let gray_base = color.r().min(color.g()).min(color.b());
+
+	let red_part = color.r() - gray_base;
+	let green_part = color.g() - gray_base;
+	let blue_part = color.b() - gray_base;
+
+	let additional = if red_part == 0. {
+		let cyan_part = green_part.min(blue_part);
+		cyan_part * cyans + (green_part - cyan_part) * greens + (blue_part - cyan_part) * blues
+	} else if green_part == 0. {
+		let magenta_part = red_part.min(blue_part);
+		magenta_part * magentas + (red_part - magenta_part) * reds + (blue_part - magenta_part) * blues
+	} else {
+		let yellow_part = red_part.min(green_part);
+		yellow_part * yellows + (red_part - yellow_part) * reds + (green_part - yellow_part) * greens
+	};
+
+	let luminance = gray_base + additional;
+
+	// TODO: Fix "Color" blend mode implementation so it matches the expected behavior perfectly (it's currently close)
+	tint.with_luminance(luminance)
+}
+
 #[cfg(not(target_arch = "spirv"))]
 pub use hue_shift::HueSaturationNode;
 
@@ -54,18 +131,25 @@ fn invert_image(color: Color) -> Color {
 }
 
 #[derive(Debug, Clone, Copy)]
-pub struct ThresholdNode<Threshold> {
+pub struct ThresholdNode<LuminanceCalculation, Threshold> {
+	luma_calculation: LuminanceCalculation,
 	threshold: Threshold,
 }
 
 #[node_macro::node_fn(ThresholdNode)]
-fn threshold_node(color: Color, threshold: f64) -> Color {
-	let threshold = Color::srgb_to_linear(threshold as f32);
+fn threshold_node(color: Color, luma_calculation: LuminanceCalculation, threshold: f64) -> Color {
+	let threshold = Color::srgb_to_linear(threshold as f32 / 100.);
 
 	// TODO: Remove conversion to linear when the whole node graph uses linear color
 	let color = color.to_linear_srgb();
 
-	if color.luminance() >= threshold {
+	let luminance = match luma_calculation {
+		LuminanceCalculation::SRGB => color.luminance_srgb(),
+		LuminanceCalculation::Perceptual => color.luminance_perceptual(),
+		LuminanceCalculation::AverageChannels => color.average_rgb_channels(),
+	};
+
+	if luminance >= threshold {
 		Color::WHITE
 	} else {
 		Color::BLACK
@@ -108,7 +192,7 @@ pub struct OpacityNode<O> {
 
 #[node_macro::node_fn(OpacityNode)]
 fn image_opacity(color: Color, opacity_multiplier: f64) -> Color {
-	let opacity_multiplier = opacity_multiplier as f32;
+	let opacity_multiplier = opacity_multiplier as f32 / 100.;
 	Color::from_rgbaf32_unchecked(color.r(), color.g(), color.b(), color.a() * opacity_multiplier)
 }