Extract graster-nodes

Author: Firestar99

Cargo.lock

@@ -11,6 +11,7 @@ members = [
 	"node-graph/gpath-bool",
 	"node-graph/graph-craft",
 	"node-graph/graphene-cli",
+	"node-graph/graster-nodes",
 	"node-graph/gsvg-renderer",
 	"node-graph/interpreted-executor",
 	"node-graph/node-macro",
@@ -30,6 +31,7 @@ default-members = [
 	"node-graph/gpath-bool",
 	"node-graph/graph-craft",
 	"node-graph/graphene-cli",
+	"node-graph/graster-nodes",
 	"node-graph/gsvg-renderer",
 	"node-graph/interpreted-executor",
 	"node-graph/node-macro",
@@ -48,6 +50,7 @@ graphene-core = { path = "node-graph/gcore" }
 graphene-math-nodes = { path = "node-graph/gmath-nodes" }
 graphene-path-bool = { path = "node-graph/gpath-bool" }
 graph-craft = { path = "node-graph/graph-craft" }
+graphene-raster-nodes = { path = "node-graph/graster-nodes" }
 graphene-std = { path = "node-graph/gstd" }
 graphene-svg-renderer = { path = "node-graph/gsvg-renderer" }
 interpreted-executor = { path = "node-graph/interpreted-executor" }
@@ -147,6 +150,7 @@ half = { version = "2.4.1", default-features = false, features = ["bytemuck", "s
 tinyvec = { version = "1" }
 criterion = { version = "0.5", features = ["html_reports"] }
 iai-callgrind = { version = "0.12.3" }
+ndarray = "0.16.1"
 
 [profile.dev]
 opt-level = 1

Cargo.toml

@@ -25,6 +25,7 @@ const REPLACEMENTS: &[(&str, &str)] = &[
 	("graphene_core::ConstructArtboardNode", "graphene_core::graphic_element::ToArtboardNode"),
 	("graphene_core::ToGraphicElementNode", "graphene_core::graphic_element::ToElementNode"),
 	("graphene_core::ToGraphicGroupNode", "graphene_core::graphic_element::ToGroupNode"),
+	// math_nodes
 	("graphene_core::ops::MathNode", "graphene_math_nodes::MathNode"),
 	("graphene_core::ops::AddNode", "graphene_math_nodes::AddNode"),
 	("graphene_core::ops::SubtractNode", "graphene_math_nodes::SubtractNode"),
@@ -65,43 +66,72 @@ const REPLACEMENTS: &[(&str, &str)] = &[
 	("graphene_core::ops::GradientValueNode", "graphene_math_nodes::GradientValueNode"),
 	("graphene_core::ops::StringValueNode", "graphene_math_nodes::StringValueNode"),
 	("graphene_core::ops::DotProductNode", "graphene_math_nodes::DotProductNode"),
+	// debug
 	("graphene_core::ops::SizeOfNode", "graphene_core::debug::SizeOfNode"),
 	("graphene_core::ops::SomeNode", "graphene_core::debug::SomeNode"),
 	("graphene_core::ops::UnwrapNode", "graphene_core::debug::UnwrapNode"),
 	("graphene_core::ops::CloneNode", "graphene_core::debug::CloneNode"),
+	// ???
 	("graphene_core::ops::ExtractXyNode", "graphene_core::extract_xy::ExtractXyNode"),
 	("graphene_core::logic::LogicAndNode", "graphene_core::ops::LogicAndNode"),
 	("graphene_core::logic::LogicNotNode", "graphene_core::ops::LogicNotNode"),
 	("graphene_core::logic::LogicOrNode", "graphene_core::ops::LogicOrNode"),
 	("graphene_core::ops::ConstructVector2", "graphene_core::ops::CoordinateValueNode"),
 	("graphene_core::ops::Vector2ValueNode", "graphene_core::ops::CoordinateValueNode"),
-	("graphene_core::raster::BlackAndWhiteNode", "graphene_core::raster::adjustments::BlackAndWhiteNode"),
-	("graphene_core::raster::BlendNode", "graphene_core::raster::adjustments::BlendNode"),
 	("graphene_core::raster::BlendModeNode", "graphene_core::blending_nodes::BlendModeNode"),
 	("graphene_core::raster::OpacityNode", "graphene_core::blending_nodes::OpacityNode"),
 	("graphene_core::raster::BlendingNode", "graphene_core::blending_nodes::BlendingNode"),
-	("graphene_core::raster::ChannelMixerNode", "graphene_core::raster::adjustments::ChannelMixerNode"),
-	("graphene_core::raster::adjustments::ColorOverlayNode", "graphene_core::raster::adjustments::ColorOverlayNode"),
-	("graphene_core::raster::ExposureNode", "graphene_core::raster::adjustments::ExposureNode"),
-	("graphene_core::raster::ExtractChannelNode", "graphene_core::raster::adjustments::ExtractChannelNode"),
-	("graphene_core::raster::GradientMapNode", "graphene_core::raster::adjustments::GradientMapNode"),
-	("graphene_core::raster::HueSaturationNode", "graphene_core::raster::adjustments::HueSaturationNode"),
 	("graphene_core::vector::GenerateHandlesNode", "graphene_core::vector::AutoTangentsNode"),
 	("graphene_core::vector::RemoveHandlesNode", "graphene_core::vector::AutoTangentsNode"),
-	("graphene_core::raster::InvertNode", "graphene_core::raster::adjustments::InvertNode"),
-	("graphene_core::raster::InvertRGBNode", "graphene_core::raster::adjustments::InvertNode"),
-	("graphene_core::raster::LevelsNode", "graphene_core::raster::adjustments::LevelsNode"),
-	("graphene_core::raster::LuminanceNode", "graphene_core::raster::adjustments::LuminanceNode"),
-	("graphene_core::raster::ExtractOpaqueNode", "graphene_core::raster::adjustments::MakeOpaqueNode"),
-	("graphene_core::raster::PosterizeNode", "graphene_core::raster::adjustments::PosterizeNode"),
-	("graphene_core::raster::ThresholdNode", "graphene_core::raster::adjustments::ThresholdNode"),
-	("graphene_core::raster::VibranceNode", "graphene_core::raster::adjustments::VibranceNode"),
+	// raster::adjustments
+	("graphene_core::raster::adjustments::LuminanceNode", "graphene_raster_nodes::adjustments::LuminanceNode"),
+	("graphene_core::raster::LuminanceNode", "graphene_raster_nodes::adjustments::LuminanceNode"),
+	("graphene_core::raster::adjustments::ExtractChannelNode", "graphene_raster_nodes::adjustments::ExtractChannelNode"),
+	("graphene_core::raster::ExtractChannelNode", "graphene_raster_nodes::adjustments::ExtractChannelNode"),
+	("graphene_core::raster::adjustments::MakeOpaqueNode", "graphene_raster_nodes::adjustments::MakeOpaqueNode"),
+	("graphene_core::raster::ExtractOpaqueNode", "graphene_raster_nodes::adjustments::MakeOpaqueNode"),
+	(
+		"graphene_core::raster::adjustments::BrightnessContrastNode",
+		"graphene_raster_nodes::adjustments::BrightnessContrastNode",
+	),
+	("graphene_core::raster::adjustments::LevelsNode", "graphene_raster_nodes::adjustments::LevelsNode"),
+	("graphene_core::raster::LevelsNode", "graphene_raster_nodes::adjustments::LevelsNode"),
+	("graphene_core::raster::adjustments::BlackAndWhiteNode", "graphene_raster_nodes::adjustments::BlackAndWhiteNode"),
+	("graphene_core::raster::BlackAndWhiteNode", "graphene_raster_nodes::adjustments::BlackAndWhiteNode"),
+	("graphene_core::raster::adjustments::HueSaturationNode", "graphene_raster_nodes::adjustments::HueSaturationNode"),
+	("graphene_core::raster::HueSaturationNode", "graphene_raster_nodes::adjustments::HueSaturationNode"),
+	("graphene_core::raster::adjustments::InvertNode", "graphene_raster_nodes::adjustments::InvertNode"),
+	("graphene_core::raster::InvertNode", "graphene_raster_nodes::adjustments::InvertNode"),
+	("graphene_core::raster::InvertRGBNode", "graphene_raster_nodes::adjustments::InvertNode"),
+	("graphene_core::raster::adjustments::ThresholdNode", "graphene_raster_nodes::adjustments::ThresholdNode"),
+	("graphene_core::raster::ThresholdNode", "graphene_raster_nodes::adjustments::ThresholdNode"),
+	("graphene_core::raster::adjustments::BlendNode", "graphene_raster_nodes::adjustments::BlendNode"),
+	("graphene_core::raster::BlendNode", "graphene_raster_nodes::adjustments::BlendNode"),
+	("graphene_core::raster::BlendColorPairNode", "graphene_raster_nodes::adjustments::BlendColorPairNode"),
+	("graphene_core::raster::adjustments::BlendColorsNode", "graphene_raster_nodes::adjustments::BlendColorsNode"),
+	("graphene_core::raster::BlendColorsNode", "graphene_raster_nodes::adjustments::BlendColorsNode"),
+	("graphene_core::raster::adjustments::GradientMapNode", "graphene_raster_nodes::adjustments::GradientMapNode"),
+	("graphene_core::raster::GradientMapNode", "graphene_raster_nodes::adjustments::GradientMapNode"),
+	("graphene_core::raster::adjustments::VibranceNode", "graphene_raster_nodes::adjustments::VibranceNode"),
+	("graphene_core::raster::VibranceNode", "graphene_raster_nodes::adjustments::VibranceNode"),
+	("graphene_core::raster::adjustments::ChannelMixerNode", "graphene_raster_nodes::adjustments::ChannelMixerNode"),
+	("graphene_core::raster::ChannelMixerNode", "graphene_raster_nodes::adjustments::ChannelMixerNode"),
+	("graphene_core::raster::adjustments::SelectiveColorNode", "graphene_raster_nodes::adjustments::SelectiveColorNode"),
+	("graphene_core::raster::adjustments::PosterizeNode", "graphene_raster_nodes::adjustments::PosterizeNode"),
+	("graphene_core::raster::PosterizeNode", "graphene_raster_nodes::adjustments::PosterizeNode"),
+	("graphene_core::raster::adjustments::ExposureNode", "graphene_raster_nodes::adjustments::ExposureNode"),
+	("graphene_core::raster::ExposureNode", "graphene_raster_nodes::adjustments::ExposureNode"),
+	("graphene_core::raster::adjustments::GenerateCurvesNode", "graphene_raster_nodes::generate_curves::GenerateCurvesNode"),
+	("graphene_core::raster::adjustments::ColorOverlayNode", "graphene_raster_nodes::generate_curves::ColorOverlayNode"),
+	// text
 	("graphene_core::text::TextGeneratorNode", "graphene_core::text::TextNode"),
+	// transform
 	("graphene_core::transform::SetTransformNode", "graphene_core::transform_nodes::ReplaceTransformNode"),
 	("graphene_core::transform::ReplaceTransformNode", "graphene_core::transform_nodes::ReplaceTransformNode"),
 	("graphene_core::transform::TransformNode", "graphene_core::transform_nodes::TransformNode"),
 	("graphene_core::transform::BoundlessFootprintNode", "graphene_core::transform_nodes::BoundlessFootprintNode"),
 	("graphene_core::transform::FreezeRealTimeNode", "graphene_core::transform_nodes::FreezeRealTimeNode"),
+	// ???
 	("graphene_core::vector::SplinesFromPointsNode", "graphene_core::vector::SplineNode"),
 	("graphene_core::vector::generator_nodes::EllipseGenerator", "graphene_core::vector::generator_nodes::EllipseNode"),
 	("graphene_core::vector::generator_nodes::LineGenerator", "graphene_core::vector::generator_nodes::LineNode"),

editor/src/messages/portfolio/document_migration.rs

@@ -12,13 +12,10 @@ pub mod color {
 	pub use super::*;
 }
 
-pub mod adjustments;
 pub mod brush_cache;
-pub mod curve;
 pub mod image;
 
 pub use self::image::Image;
-pub use adjustments::*;
 
 pub trait Bitmap {
 	type Pixel: Pixel;

node-graph/gcore/src/raster.rs

@@ -19,6 +19,7 @@ graphene-core = { workspace = true }
 graphene-path-bool = { workspace = true }
 graphene-application-io = { workspace = true }
 graphene-svg-renderer = { workspace = true }
+graphene-raster-nodes = { workspace = true }
 
 # Workspace dependencies
 log = { workspace = true }

node-graph/graph-craft/Cargo.toml

@@ -6,7 +6,6 @@ pub use dyn_any::StaticType;
 pub use glam::{DAffine2, DVec2, IVec2, UVec2};
 use graphene_application_io::SurfaceFrame;
 use graphene_core::raster::brush_cache::BrushCache;
-use graphene_core::raster::{BlendMode, LuminanceCalculation};
 use graphene_core::raster_types::CPU;
 use graphene_core::transform::ReferencePoint;
 use graphene_core::uuid::NodeId;
@@ -212,26 +211,26 @@ tagged_value! {
 	BrushStrokes(Vec<graphene_core::vector::brush_stroke::BrushStroke>),
 	BrushCache(BrushCache),
 	DocumentNode(DocumentNode),
-	Curve(graphene_core::raster::curve::Curve),
+	Curve(graphene_raster_nodes::curve::Curve),
 	Footprint(graphene_core::transform::Footprint),
 	VectorModification(Box<graphene_core::vector::VectorModification>),
 	FontCache(Arc<graphene_core::text::FontCache>),
 	// ==========
 	// ENUM TYPES
 	// ==========
-	BlendMode(BlendMode),
-	LuminanceCalculation(LuminanceCalculation),
+	BlendMode(graphene_core::blending::BlendMode),
+	LuminanceCalculation(graphene_raster_nodes::adjustments::LuminanceCalculation),
 	XY(graphene_core::extract_xy::XY),
-	RedGreenBlue(graphene_core::raster::RedGreenBlue),
-	RedGreenBlueAlpha(graphene_core::raster::RedGreenBlueAlpha),
+	RedGreenBlue(graphene_raster_nodes::adjustments::RedGreenBlue),
+	RedGreenBlueAlpha(graphene_raster_nodes::adjustments::RedGreenBlueAlpha),
 	RealTimeMode(graphene_core::animation::RealTimeMode),
-	NoiseType(graphene_core::raster::NoiseType),
-	FractalType(graphene_core::raster::FractalType),
-	CellularDistanceFunction(graphene_core::raster::CellularDistanceFunction),
-	CellularReturnType(graphene_core::raster::CellularReturnType),
-	DomainWarpType(graphene_core::raster::DomainWarpType),
-	RelativeAbsolute(graphene_core::raster::RelativeAbsolute),
-	SelectiveColorChoice(graphene_core::raster::SelectiveColorChoice),
+	NoiseType(graphene_raster_nodes::adjustments::NoiseType),
+	FractalType(graphene_raster_nodes::adjustments::FractalType),
+	CellularDistanceFunction(graphene_raster_nodes::adjustments::CellularDistanceFunction),
+	CellularReturnType(graphene_raster_nodes::adjustments::CellularReturnType),
+	DomainWarpType(graphene_raster_nodes::adjustments::DomainWarpType),
+	RelativeAbsolute(graphene_raster_nodes::adjustments::RelativeAbsolute),
+	SelectiveColorChoice(graphene_raster_nodes::adjustments::SelectiveColorChoice),
 	GridType(graphene_core::vector::misc::GridType),
 	ArcType(graphene_core::vector::misc::ArcType),
 	MergeByDistanceAlgorithm(graphene_core::vector::misc::MergeByDistanceAlgorithm),

node-graph/graph-craft/src/document/value.rs

@@ -0,0 +1,35 @@
+[package]
+name = "graphene-raster-nodes"
+version = "0.1.0"
+edition = "2024"
+description = "graphene raster data format"
+authors = ["Graphite Authors <contact@graphite.rs>"]
+license = "MIT OR Apache-2.0"
+
+[features]
+default = ["serde"]
+serde = ["dep:serde"]
+
+[dependencies]
+# Local dependencies
+dyn-any = { workspace = true }
+graphene-core = { workspace = true }
+node-macro = { workspace = true }
+
+# Workspace dependencies
+glam = { workspace = true }
+specta = { workspace = true }
+image = { workspace = true }
+bytemuck = { workspace = true }
+ndarray = { workspace = true }
+bezier-rs = { workspace = true }
+rand = { workspace = true }
+rand_chacha = { workspace = true }
+fastnoise-lite = { workspace = true }
+
+# Optional workspace dependencies
+serde = { workspace = true, optional = true, features = ["derive"] }
+
+[dev-dependencies]
+tokio = { workspace = true }
+futures = { workspace = true }

node-graph/graster-nodes/Cargo.toml

@@ -1,16 +1,16 @@
 #![allow(clippy::too_many_arguments)]
 
-use crate::GraphicElement;
-use crate::blending::BlendMode;
-use crate::raster::curve::{CubicSplines, CurveManipulatorGroup};
-use crate::raster::curve::{Curve, ValueMapperNode};
-use crate::raster::image::Image;
-use crate::raster::{Channel, Color, Pixel};
-use crate::raster_types::{CPU, Raster, RasterDataTable};
-use crate::registry::types::{Angle, Percentage, SignedPercentage};
-use crate::vector::style::GradientStops;
-use crate::{Ctx, Node};
+use crate::curve::CubicSplines;
 use dyn_any::DynAny;
+use graphene_core::Node;
+use graphene_core::blending::BlendMode;
+use graphene_core::color::Color;
+use graphene_core::color::Pixel;
+use graphene_core::context::Ctx;
+use graphene_core::gradient::GradientStops;
+use graphene_core::raster::image::Image;
+use graphene_core::raster_types::{CPU, Raster, RasterDataTable};
+use graphene_core::registry::types::{Angle, Percentage, SignedPercentage};
 use std::cmp::Ordering;
 use std::fmt::Debug;
 
@@ -576,10 +576,7 @@ impl Adjust<Color> for GradientStops {
 		}
 	}
 }
-impl Adjust<Color> for RasterDataTable<CPU>
-where
-	GraphicElement: From<Image<Color>>,
-{
+impl Adjust<Color> for RasterDataTable<CPU> {
 	fn adjust(&mut self, map_fn: impl Fn(&Color) -> Color) {
 		for instance in self.instance_mut_iter() {
 			for c in instance.instance.data_mut().data.iter_mut() {
@@ -1130,48 +1127,6 @@ async fn exposure<T: Adjust<Color>>(
 	input
 }
 
-const WINDOW_SIZE: usize = 1024;
-
-#[node_macro::node(category(""))]
-fn generate_curves<C: Channel + crate::raster::Linear>(_: impl Ctx, curve: Curve, #[implementations(f32, f64)] _target_format: C) -> ValueMapperNode<C> {
-	use bezier_rs::{Bezier, TValue};
-
-	let [mut pos, mut param]: [[f32; 2]; 2] = [[0.; 2], curve.first_handle];
-	let mut lut = vec![C::from_f64(0.); WINDOW_SIZE];
-	let end = CurveManipulatorGroup {
-		anchor: [1.; 2],
-		handles: [curve.last_handle, [0.; 2]],
-	};
-	for sample in curve.manipulator_groups.iter().chain(std::iter::once(&end)) {
-		let [x0, y0, x1, y1, x2, y2, x3, y3] = [pos[0], pos[1], param[0], param[1], sample.handles[0][0], sample.handles[0][1], sample.anchor[0], sample.anchor[1]].map(f64::from);
-
-		let bezier = Bezier::from_cubic_coordinates(x0, y0, x1, y1, x2, y2, x3, y3);
-
-		let [left, right] = [pos[0], sample.anchor[0]].map(|c| c.clamp(0., 1.));
-		let lut_index_left: usize = (left * (lut.len() - 1) as f32).floor() as _;
-		let lut_index_right: usize = (right * (lut.len() - 1) as f32).ceil() as _;
-		for index in lut_index_left..=lut_index_right {
-			let x = index as f64 / (lut.len() - 1) as f64;
-			let y = if x <= x0 {
-				y0
-			} else if x >= x3 {
-				y3
-			} else {
-				bezier.find_tvalues_for_x(x)
-					.next()
-					.map(|t| bezier.evaluate(TValue::Parametric(t.clamp(0., 1.))).y)
-					// Fall back to a very bad approximation if Bezier-rs fails
-					.unwrap_or_else(|| (x - x0) / (x3 - x0) * (y3 - y0) + y0)
-			};
-			lut[index] = C::from_f64(y);
-		}
-
-		pos = sample.anchor;
-		param = sample.handles[1];
-	}
-	ValueMapperNode::new(lut)
-}
-
 #[node_macro::node(category("Raster: Adjustment"))]
 fn color_overlay<T: Adjust<Color>>(
 	_: impl Ctx,
@@ -1224,10 +1179,10 @@ fn color_overlay<T: Adjust<Color>>(
 
 #[cfg(test)]
 mod test {
-	use crate::Color;
-	use crate::blending::BlendMode;
-	use crate::raster::image::Image;
-	use crate::raster_types::{Raster, RasterDataTable};
+	use graphene_core::blending::BlendMode;
+	use graphene_core::color::Color;
+	use graphene_core::raster::image::Image;
+	use graphene_core::raster_types::{Raster, RasterDataTable};
 
 	#[tokio::test]
 	async fn color_overlay_multiply() {