Extract graster-nodes (#2783)

node-graph/graster-nodes/src/curve.rs

@@ -0,0 +1,200 @@
+use dyn_any::{DynAny, StaticType, StaticTypeSized};
+use graphene_core::Node;
+use graphene_core::color::{Channel, Linear, LuminanceMut};
+use std::hash::{Hash, Hasher};
+use std::ops::{Add, Mul, Sub};
+
+#[derive(Debug, Clone, PartialEq, DynAny, specta::Type, serde::Serialize, serde::Deserialize)]
+pub struct Curve {
+	#[serde(rename = "manipulatorGroups")]
+	pub manipulator_groups: Vec<CurveManipulatorGroup>,
+	#[serde(rename = "firstHandle")]
+	pub first_handle: [f32; 2],
+	#[serde(rename = "lastHandle")]
+	pub last_handle: [f32; 2],
+}
+
+impl Default for Curve {
+	fn default() -> Self {
+		Self {
+			manipulator_groups: vec![],
+			first_handle: [0.2; 2],
+			last_handle: [0.8; 2],
+		}
+	}
+}
+
+impl Hash for Curve {
+	fn hash<H: Hasher>(&self, state: &mut H) {
+		self.manipulator_groups.hash(state);
+		[self.first_handle, self.last_handle].iter().flatten().for_each(|f| f.to_bits().hash(state));
+	}
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, DynAny, specta::Type, serde::Serialize, serde::Deserialize)]
+pub struct CurveManipulatorGroup {
+	pub anchor: [f32; 2],
+	pub handles: [[f32; 2]; 2],
+}
+
+impl Hash for CurveManipulatorGroup {
+	fn hash<H: Hasher>(&self, state: &mut H) {
+		for c in self.handles.iter().chain([&self.anchor]).flatten() {
+			c.to_bits().hash(state);
+		}
+	}
+}
+
+#[derive(Debug)]
+pub struct CubicSplines {
+	pub x: [f32; 4],
+	pub y: [f32; 4],
+}
+
+impl CubicSplines {
+	pub fn solve(&self) -> [f32; 4] {
+		let (x, y) = (&self.x, &self.y);
+
+		// Build an augmented matrix to solve the system of equations using Gaussian elimination
+		let mut augmented_matrix = [
+			[
+				2. / (x[1] - x[0]),
+				1. / (x[1] - x[0]),
+				0.,
+				0.,
+				// |
+				3. * (y[1] - y[0]) / ((x[1] - x[0]) * (x[1] - x[0])),
+			],
+			[
+				1. / (x[1] - x[0]),
+				2. * (1. / (x[1] - x[0]) + 1. / (x[2] - x[1])),
+				1. / (x[2] - x[1]),
+				0.,
+				// |
+				3. * ((y[1] - y[0]) / ((x[1] - x[0]) * (x[1] - x[0])) + (y[2] - y[1]) / ((x[2] - x[1]) * (x[2] - x[1]))),
+			],
+			[
+				0.,
+				1. / (x[2] - x[1]),
+				2. * (1. / (x[2] - x[1]) + 1. / (x[3] - x[2])),
+				1. / (x[3] - x[2]),
+				// |
+				3. * ((y[2] - y[1]) / ((x[2] - x[1]) * (x[2] - x[1])) + (y[3] - y[2]) / ((x[3] - x[2]) * (x[3] - x[2]))),
+			],
+			[
+				0.,
+				0.,
+				1. / (x[3] - x[2]),
+				2. / (x[3] - x[2]),
+				// |
+				3. * (y[3] - y[2]) / ((x[3] - x[2]) * (x[3] - x[2])),
+			],
+		];
+
+		// Gaussian elimination: forward elimination
+		for row in 0..4 {
+			let pivot_row_index = (row..4)
+				.max_by(|&a_row, &b_row| augmented_matrix[a_row][row].abs().partial_cmp(&augmented_matrix[b_row][row].abs()).unwrap_or(std::cmp::Ordering::Equal))
+				.unwrap();
+
+			// Swap the current row with the row that has the largest pivot element
+			augmented_matrix.swap(row, pivot_row_index);
+
+			// Eliminate the current column in all rows below the current one
+			for row_below_current in row + 1..4 {
+				assert!(augmented_matrix[row][row].abs() > f32::EPSILON);
+
+				let scale_factor = augmented_matrix[row_below_current][row] / augmented_matrix[row][row];
+				for col in row..5 {
+					augmented_matrix[row_below_current][col] -= augmented_matrix[row][col] * scale_factor
+				}
+			}
+		}
+
+		// Gaussian elimination: back substitution
+		let mut solutions = [0.; 4];
+		for col in (0..4).rev() {
+			assert!(augmented_matrix[col][col].abs() > f32::EPSILON);
+
+			solutions[col] = augmented_matrix[col][4] / augmented_matrix[col][col];
+
+			for row in (0..col).rev() {
+				augmented_matrix[row][4] -= augmented_matrix[row][col] * solutions[col];
+				augmented_matrix[row][col] = 0.;
+			}
+		}
+
+		solutions
+	}
+
+	pub fn interpolate(&self, input: f32, solutions: &[f32]) -> f32 {
+		if input <= self.x[0] {
+			return self.y[0];
+		}
+		if input >= self.x[self.x.len() - 1] {
+			return self.y[self.x.len() - 1];
+		}
+
+		// Find the segment that the input falls between
+		let mut segment = 1;
+		while self.x[segment] < input {
+			segment += 1;
+		}
+		let segment_start = segment - 1;
+		let segment_end = segment;
+
+		// Calculate the output value using quadratic interpolation
+		let input_value = self.x[segment_start];
+		let input_value_prev = self.x[segment_end];
+		let output_value = self.y[segment_start];
+		let output_value_prev = self.y[segment_end];
+		let solutions_value = solutions[segment_start];
+		let solutions_value_prev = solutions[segment_end];
+
+		let output_delta = solutions_value_prev * (input_value - input_value_prev) - (output_value - output_value_prev);
+		let solution_delta = (output_value - output_value_prev) - solutions_value * (input_value - input_value_prev);
+
+		let input_ratio = (input - input_value_prev) / (input_value - input_value_prev);
+		let prev_output_ratio = (1. - input_ratio) * output_value_prev;
+		let output_ratio = input_ratio * output_value;
+		let quadratic_ratio = input_ratio * (1. - input_ratio) * (output_delta * (1. - input_ratio) + solution_delta * input_ratio);
+
+		let result = prev_output_ratio + output_ratio + quadratic_ratio;
+		result.clamp(0., 1.)
+	}
+}
+
+pub struct ValueMapperNode<C> {
+	lut: Vec<C>,
+}
+
+unsafe impl<C: StaticTypeSized> StaticType for ValueMapperNode<C> {
+	type Static = ValueMapperNode<C::Static>;
+}
+
+impl<C> ValueMapperNode<C> {
+	pub const fn new(lut: Vec<C>) -> Self {
+		Self { lut }
+	}
+}
+
+impl<'i, L: LuminanceMut + 'i> Node<'i, L> for ValueMapperNode<L::LuminanceChannel>
+where
+	L::LuminanceChannel: Linear + Copy,
+	L::LuminanceChannel: Add<Output = L::LuminanceChannel>,
+	L::LuminanceChannel: Sub<Output = L::LuminanceChannel>,
+	L::LuminanceChannel: Mul<Output = L::LuminanceChannel>,
+{
+	type Output = L;
+
+	fn eval(&'i self, mut val: L) -> L {
+		let luminance: f32 = val.luminance().to_linear();
+		let floating_sample_index = luminance * (self.lut.len() - 1) as f32;
+		let index_in_lut = floating_sample_index.floor() as usize;
+		let a = self.lut[index_in_lut];
+		let b = self.lut[(index_in_lut + 1).clamp(0, self.lut.len() - 1)];
+		let result = a.lerp(b, L::LuminanceChannel::from_linear(floating_sample_index.fract()));
+		val.set_luminance(result);
+		val
+	}
+}

node-graph/graster-nodes/src/dehaze.rs

@@ -0,0 +1,266 @@
+use graphene_core::context::Ctx;
+use graphene_core::raster::image::Image;
+use graphene_core::raster_types::{CPU, Raster, RasterDataTable};
+use graphene_core::registry::types::Percentage;
+use image::{DynamicImage, GenericImage, GenericImageView, GrayImage, ImageBuffer, Luma, Rgba, RgbaImage};
+use ndarray::{Array2, ArrayBase, Dim, OwnedRepr};
+use std::cmp::{max, min};
+
+#[node_macro::node(category("Raster: Filter"))]
+async fn dehaze(_: impl Ctx, image_frame: RasterDataTable<CPU>, strength: Percentage) -> RasterDataTable<CPU> {
+	let mut result_table = RasterDataTable::default();
+
+	for mut image_frame_instance in image_frame.instance_iter() {
+		let image = image_frame_instance.instance;
+		// Prepare the image data for processing
+		let image_data = bytemuck::cast_vec(image.data.clone());
+		let image_buffer = image::Rgba32FImage::from_raw(image.width, image.height, image_data).expect("Failed to convert internal image format into image-rs data type.");
+		let dynamic_image: DynamicImage = image_buffer.into();
+
+		// Run the dehaze algorithm
+		let dehazed_dynamic_image = dehaze_image(dynamic_image, strength / 100.);
+
+		// Prepare the image data for returning
+		let buffer = dehazed_dynamic_image.to_rgba32f().into_raw();
+		let color_vec = bytemuck::cast_vec(buffer);
+		let dehazed_image = Image {
+			width: image.width,
+			height: image.height,
+			data: color_vec,
+			base64_string: None,
+		};
+
+		image_frame_instance.instance = Raster::new_cpu(dehazed_image);
+		image_frame_instance.source_node_id = None;
+		result_table.push(image_frame_instance);
+	}
+
+	result_table
+}
+
+// There is no real point in modifying these values because they do not change the final result all that much.
+// The authors of the paper recommended using these values to get a reasonable balance of performance and quality.
+const PATCH_SIZE: u32 = 15;
+const TOP_PERCENT: f64 = 0.001;
+const RADIUS: u32 = 60;
+const EPSILON: f64 = 0.0001;
+const TX: f32 = 0.1;
+
+// Dehazing algorithm based on "Single Image Haze Removal Using Dark Channel Prior"
+// Paper: <https://www.researchgate.net/publication/220182411_Single_Image_Haze_Removal_Using_Dark_Channel_Prior>
+// TODO: Make this algorithm work with negative strength values
+fn dehaze_image(image: DynamicImage, strength: f64) -> DynamicImage {
+	// TODO: Break out this pair of steps into its own node, with a memoize node which caches the pair of outputs, so the strength can be adjusted without recomputing these two steps.
+	let dark_channel = compute_dark_channel(&image);
+	let atmospheric_light = estimate_atmospheric_light(&image, &dark_channel);
+
+	let transmission_map = estimate_transmission_map(&image, &dark_channel, strength);
+	let refined_transmission_map = refine_transmission_map(&image, &transmission_map);
+
+	recover(&image, &refined_transmission_map, atmospheric_light)
+}
+
+fn compute_dark_channel(image: &DynamicImage) -> DynamicImage {
+	let (width, height) = image.dimensions();
+	let mut dark_channel = GrayImage::new(width, height);
+	let half_patch = PATCH_SIZE / 2;
+
+	for y in 0..height {
+		for x in 0..width {
+			let pixel = image.get_pixel(x, y);
+			let min_intensity = min(min(pixel[0], pixel[1]), pixel[2]);
+			dark_channel.put_pixel(x, y, Luma([min_intensity]));
+		}
+	}
+
+	let mut eroded_channel = RgbaImage::new(width, height);
+
+	for y in 0..height {
+		for x in 0..width {
+			let mut local_min = u8::MAX;
+
+			for dy in 0..PATCH_SIZE {
+				for dx in 0..PATCH_SIZE {
+					let nx = x as i32 + dx as i32 - half_patch as i32;
+					let ny = y as i32 + dy as i32 - half_patch as i32;
+
+					if nx >= 0 && nx < width as i32 && ny >= 0 && ny < height as i32 {
+						let intensity = dark_channel.get_pixel(nx as u32, ny as u32)[0];
+						if intensity < local_min {
+							local_min = intensity;
+						}
+					}
+				}
+			}
+			let alpha = image.get_pixel(x, y)[3];
+			eroded_channel.put_pixel(x, y, Rgba([local_min, local_min, local_min, alpha]));
+		}
+	}
+
+	DynamicImage::ImageRgba8(eroded_channel)
+}
+
+fn estimate_atmospheric_light(hazy: &DynamicImage, dark_channel: &DynamicImage) -> Rgba<u8> {
+	let (width, height) = hazy.dimensions();
+	let dark = dark_channel.to_luma_alpha8();
+	let total_pixels = (width * height) as usize;
+	let num_pixels = ((TOP_PERCENT / 100.) * total_pixels as f64).ceil() as usize;
+
+	let mut intensities: Vec<(u32, u32, f64)> = Vec::with_capacity(total_pixels);
+
+	for y in 0..height {
+		for x in 0..width {
+			let pixel = dark.get_pixel(x, y);
+			let intensity = pixel.0[0] as f64;
+			intensities.push((x, y, intensity))
+		}
+	}
+
+	intensities.sort_by(|a, b| b.2.partial_cmp(&a.2).unwrap());
+
+	let top_intensities = &intensities[..num_pixels];
+
+	let mut atm_sum = [0., 0., 0.];
+	for (x, y, _) in top_intensities {
+		let pixel = hazy.get_pixel(*x, *y);
+		atm_sum[0] += pixel[0] as f64;
+		atm_sum[1] += pixel[1] as f64;
+		atm_sum[2] += pixel[2] as f64;
+	}
+
+	let num_pixels = num_pixels as f64;
+
+	Rgba([(atm_sum[0] / num_pixels) as u8, (atm_sum[1] / num_pixels) as u8, (atm_sum[2] / num_pixels) as u8, 255])
+}
+
+fn estimate_transmission_map(image: &DynamicImage, dark_channel: &DynamicImage, omega: f64) -> DynamicImage {
+	let (width, height) = image.dimensions();
+	let mut transmission_map = RgbaImage::new(width, height);
+
+	for y in 0..height {
+		for x in 0..width {
+			let min_intensity = dark_channel.get_pixel(x, y).0[0] as f32 / 255.;
+			let transmission_value = 1. - omega * min_intensity as f64;
+			let alpha = image.get_pixel(x, y)[3];
+			transmission_map.put_pixel(
+				x,
+				y,
+				Rgba([(transmission_value * 255.) as u8, (transmission_value * 255.) as u8, (transmission_value * 255.) as u8, alpha]),
+			);
+		}
+	}
+
+	DynamicImage::ImageRgba8(transmission_map)
+}
+
+fn refine_transmission_map(img: &DynamicImage, transmission_map: &DynamicImage) -> DynamicImage {
+	let gray_image = img.to_luma8();
+
+	let normalized_gray_image: GrayImage = ImageBuffer::from_fn(gray_image.width(), gray_image.height(), |x, y| {
+		let pixel = gray_image.get_pixel(x, y);
+		let normalized_value = (pixel[0] as f64 / 255.) * 255.;
+		Luma([normalized_value as u8])
+	});
+
+	let normalized_gray_image = DynamicImage::ImageLuma8(normalized_gray_image);
+
+	guided_filter(&normalized_gray_image, transmission_map, RADIUS, EPSILON)
+}
+
+fn recover(im: &DynamicImage, t: &DynamicImage, a: Rgba<u8>) -> DynamicImage {
+	let (width, height) = im.dimensions();
+	let mut res = DynamicImage::new_rgba8(width, height);
+
+	let a = [a[0] as f32 / 255., a[1] as f32 / 255., a[2] as f32 / 255.];
+
+	for y in 0..height {
+		for x in 0..width {
+			let im_pixel = im.get_pixel(x, y).0;
+			let t_pixel = t.get_pixel(x, y).0;
+			let t_val = f32::max(t_pixel[0] as f32 / 255., TX);
+
+			let mut res_pixel = [0; 4];
+			for ind in 0..3 {
+				res_pixel[ind] = ((((im_pixel[ind] as f32 / 255. - a[ind]) / t_val) + a[ind]).clamp(0., 1.) * 255.) as u8;
+			}
+			res_pixel[3] = im_pixel[3];
+
+			res.put_pixel(x, y, Rgba(res_pixel));
+		}
+	}
+
+	res
+}
+
+fn guided_filter(guidance_img: &DynamicImage, input_img: &DynamicImage, r: u32, epsilon: f64) -> DynamicImage {
+	let (width, height) = guidance_img.dimensions();
+	let radius = r as i32;
+
+	let guidance_nd = image_to_ndarray(guidance_img);
+	let input_nd = image_to_ndarray(input_img);
+
+	let mean_guidance = box_filter(&guidance_nd, radius);
+	let mean_input = box_filter(&input_nd, radius);
+	let corr_guidance = box_filter(&(guidance_nd.clone() * guidance_nd.clone()), radius);
+	let corr_guidance_input = box_filter(&(guidance_nd.clone() * input_nd.clone()), radius);
+
+	let var_guidance = &corr_guidance - &(mean_guidance.clone() * mean_guidance.clone());
+	let cov_guidance_input = &corr_guidance_input - &(mean_guidance.clone() * mean_input.clone());
+
+	let a = &cov_guidance_input / &(var_guidance.clone() + epsilon);
+	let b = mean_input - &(a.clone() * mean_guidance);
+
+	let mean_a = box_filter(&a, radius);
+	let mean_b = box_filter(&b, radius);
+
+	let q = &mean_a * &guidance_nd + mean_b;
+
+	ndarray_to_image(&q, width, height)
+}
+
+fn box_filter(img: &Array2<f64>, radius: i32) -> Array2<f64> {
+	let (height, width) = img.dim();
+	let mut result = Array2::zeros((height, width));
+	let mut integral_image: ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>> = Array2::zeros((height + 1, width + 1));
+
+	// Compute integral image
+	for y in 0..height {
+		for x in 0..width {
+			integral_image[(y + 1, x + 1)] = img[(y, x)] + integral_image[(y, x + 1)] + integral_image[(y + 1, x)] - integral_image[(y, x)];
+		}
+	}
+
+	for y in 0..height {
+		for x in 0..width {
+			let y1 = max(0, y as i32 - radius) as usize;
+			let y2 = min(height as i32 - 1, y as i32 + radius) as usize;
+			let x1 = max(0, x as i32 - radius) as usize;
+			let x2 = min(width as i32 - 1, x as i32 + radius) as usize;
+
+			let area = (y2 - y1 + 1) as f64 * (x2 - x1 + 1) as f64;
+
+			result[(y, x)] = (integral_image[(y2 + 1, x2 + 1)] - integral_image[(y1, x2 + 1)] - integral_image[(y2 + 1, x1)] + integral_image[(y1, x1)]) / area;
+		}
+	}
+
+	result
+}
+
+fn image_to_ndarray(img: &DynamicImage) -> Array2<f64> {
+	let (width, height) = img.dimensions();
+	let mut array = Array2::zeros((height as usize, width as usize));
+	for (x, y, pixel) in img.pixels() {
+		let luminance = pixel.0[0] as f64 / 255.;
+		array[(y as usize, x as usize)] = luminance;
+	}
+	array
+}
+
+fn ndarray_to_image(array: &Array2<f64>, width: u32, height: u32) -> DynamicImage {
+	let mut img = DynamicImage::new_rgba8(width, height);
+	for ((y, x), &value) in array.indexed_iter() {
+		let clamped_value = (value * 255.).clamp(0., 255.) as u8;
+		img.put_pixel(x as u32, y as u32, Rgba([clamped_value, clamped_value, clamped_value, 255]));
+	}
+	img
+}

node-graph/graster-nodes/src/filter.rs

@@ -0,0 +1,182 @@
+use graphene_core::color::Color;
+use graphene_core::context::Ctx;
+use graphene_core::raster::image::Image;
+use graphene_core::raster::{Bitmap, BitmapMut};
+use graphene_core::raster_types::{CPU, Raster, RasterDataTable};
+use graphene_core::registry::types::PixelLength;
+
+/// Blurs the image with a Gaussian or blur kernel filter.
+#[node_macro::node(category("Raster: Filter"))]
+async fn blur(
+	_: impl Ctx,
+	/// The image to be blurred.
+	image_frame: RasterDataTable<CPU>,
+	/// The radius of the blur kernel.
+	#[range((0., 100.))]
+	#[hard_min(0.)]
+	radius: PixelLength,
+	/// Use a lower-quality box kernel instead of a circular Gaussian kernel. This is faster but produces boxy artifacts.
+	box_blur: bool,
+	/// Opt to incorrectly apply the filter with color calculations in gamma space for compatibility with the results from other software.
+	gamma: bool,
+) -> RasterDataTable<CPU> {
+	let mut result_table = RasterDataTable::default();
+
+	for mut image_instance in image_frame.instance_iter() {
+		let image = image_instance.instance.clone();
+
+		// Run blur algorithm
+		let blurred_image = if radius < 0.1 {
+			// Minimum blur radius
+			image.clone()
+		} else if box_blur {
+			Raster::new_cpu(box_blur_algorithm(image.into_data(), radius, gamma))
+		} else {
+			Raster::new_cpu(gaussian_blur_algorithm(image.into_data(), radius, gamma))
+		};
+
+		image_instance.instance = blurred_image;
+		image_instance.source_node_id = None;
+		result_table.push(image_instance);
+	}
+
+	result_table
+}
+
+// 1D gaussian kernel
+fn gaussian_kernel(radius: f64) -> Vec<f64> {
+	// Given radius, compute the size of the kernel that's approximately three times the radius
+	let kernel_radius = (3. * radius).ceil() as usize;
+	let kernel_size = 2 * kernel_radius + 1;
+	let mut gaussian_kernel: Vec<f64> = vec![0.; kernel_size];
+
+	// Kernel values
+	let two_radius_squared = 2. * radius * radius;
+	let sum = gaussian_kernel
+		.iter_mut()
+		.enumerate()
+		.map(|(i, value_at_index)| {
+			let x = i as f64 - kernel_radius as f64;
+			let exponent = -(x * x) / two_radius_squared;
+			*value_at_index = exponent.exp();
+			*value_at_index
+		})
+		.sum::<f64>();
+
+	// Normalize
+	gaussian_kernel.iter_mut().for_each(|value_at_index| *value_at_index /= sum);
+
+	gaussian_kernel
+}
+
+fn gaussian_blur_algorithm(mut original_buffer: Image<Color>, radius: f64, gamma: bool) -> Image<Color> {
+	if gamma {
+		original_buffer.map_pixels(|px| px.to_gamma_srgb().to_associated_alpha(px.a()));
+	} else {
+		original_buffer.map_pixels(|px| px.to_associated_alpha(px.a()));
+	}
+
+	let (width, height) = original_buffer.dimensions();
+
+	// Create 1D gaussian kernel
+	let kernel = gaussian_kernel(radius);
+	let half_kernel = kernel.len() / 2;
+
+	// Intermediate buffer for horizontal and vertical passes
+	let mut x_axis = Image::new(width, height, Color::TRANSPARENT);
+	let mut y_axis = Image::new(width, height, Color::TRANSPARENT);
+
+	for pass in [false, true] {
+		let (max, old_buffer, current_buffer) = match pass {
+			false => (width, &original_buffer, &mut x_axis),
+			true => (height, &x_axis, &mut y_axis),
+		};
+		let pass = pass as usize;
+
+		for y in 0..height {
+			for x in 0..width {
+				let (mut r_sum, mut g_sum, mut b_sum, mut a_sum, mut weight_sum) = (0., 0., 0., 0., 0.);
+
+				for (i, &weight) in kernel.iter().enumerate() {
+					let p = [x, y][pass] as i32 + (i as i32 - half_kernel as i32);
+
+					if p >= 0 && p < max as i32 {
+						if let Some(px) = old_buffer.get_pixel([p as u32, x][pass], [y, p as u32][pass]) {
+							r_sum += px.r() as f64 * weight;
+							g_sum += px.g() as f64 * weight;
+							b_sum += px.b() as f64 * weight;
+							a_sum += px.a() as f64 * weight;
+							weight_sum += weight;
+						}
+					}
+				}
+
+				// Normalize
+				let (r, g, b, a) = if weight_sum > 0. {
+					((r_sum / weight_sum) as f32, (g_sum / weight_sum) as f32, (b_sum / weight_sum) as f32, (a_sum / weight_sum) as f32)
+				} else {
+					let px = old_buffer.get_pixel(x, y).unwrap();
+					(px.r(), px.g(), px.b(), px.a())
+				};
+				current_buffer.set_pixel(x, y, Color::from_rgbaf32_unchecked(r, g, b, a));
+			}
+		}
+	}
+
+	if gamma {
+		y_axis.map_pixels(|px| px.to_linear_srgb().to_unassociated_alpha());
+	} else {
+		y_axis.map_pixels(|px| px.to_unassociated_alpha());
+	}
+
+	y_axis
+}
+
+fn box_blur_algorithm(mut original_buffer: Image<Color>, radius: f64, gamma: bool) -> Image<Color> {
+	if gamma {
+		original_buffer.map_pixels(|px| px.to_gamma_srgb().to_associated_alpha(px.a()));
+	} else {
+		original_buffer.map_pixels(|px| px.to_associated_alpha(px.a()));
+	}
+
+	let (width, height) = original_buffer.dimensions();
+	let mut x_axis = Image::new(width, height, Color::TRANSPARENT);
+	let mut y_axis = Image::new(width, height, Color::TRANSPARENT);
+
+	for pass in [false, true] {
+		let (max, old_buffer, current_buffer) = match pass {
+			false => (width, &original_buffer, &mut x_axis),
+			true => (height, &x_axis, &mut y_axis),
+		};
+		let pass = pass as usize;
+
+		for y in 0..height {
+			for x in 0..width {
+				let (mut r_sum, mut g_sum, mut b_sum, mut a_sum, mut weight_sum) = (0., 0., 0., 0., 0.);
+
+				let i = [x, y][pass];
+				for d in (i as i32 - radius as i32).max(0)..=(i as i32 + radius as i32).min(max as i32 - 1) {
+					if let Some(px) = old_buffer.get_pixel([d as u32, x][pass], [y, d as u32][pass]) {
+						let weight = 1.;
+						r_sum += px.r() as f64 * weight;
+						g_sum += px.g() as f64 * weight;
+						b_sum += px.b() as f64 * weight;
+						a_sum += px.a() as f64 * weight;
+						weight_sum += weight;
+					}
+				}
+
+				let (r, g, b, a) = ((r_sum / weight_sum) as f32, (g_sum / weight_sum) as f32, (b_sum / weight_sum) as f32, (a_sum / weight_sum) as f32);
+				current_buffer.set_pixel(x, y, Color::from_rgbaf32_unchecked(r, g, b, a));
+			}
+		}
+	}
+
+	if gamma {
+		y_axis.map_pixels(|px| px.to_linear_srgb().to_unassociated_alpha());
+	} else {
+		y_axis.map_pixels(|px| px.to_unassociated_alpha());
+	}
+
+	y_axis
+}

node-graph/graster-nodes/src/generate_curves.rs

@@ -0,0 +1,46 @@
+//! requires bezier-rs
+
+use crate::curve::{Curve, CurveManipulatorGroup, ValueMapperNode};
+use bezier_rs::{Bezier, TValue};
+use graphene_core::color::{Channel, Linear};
+use graphene_core::context::Ctx;
+
+const WINDOW_SIZE: usize = 1024;
+
+#[node_macro::node(category(""))]
+fn generate_curves<C: Channel + Linear>(_: impl Ctx, curve: Curve, #[implementations(f32, f64)] _target_format: C) -> ValueMapperNode<C> {
+	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-graph/graster-nodes/src/image_color_palette.rs

@@ -0,0 +1,85 @@
+use graphene_core::color::Color;
+use graphene_core::context::Ctx;
+use graphene_core::raster_types::{CPU, RasterDataTable};
+
+#[node_macro::node(category("Color"))]
+async fn image_color_palette(
+	_: impl Ctx,
+	image: RasterDataTable<CPU>,
+	#[hard_min(1.)]
+	#[soft_max(28.)]
+	max_size: u32,
+) -> Vec<Color> {
+	const GRID: f32 = 3.;
+
+	let bins = GRID * GRID * GRID;
+
+	let mut histogram: Vec<usize> = vec![0; (bins + 1.) as usize];
+	let mut colors: Vec<Vec<Color>> = vec![vec![]; (bins + 1.) as usize];
+
+	for image_instance in image.instance_ref_iter() {
+		for pixel in image_instance.instance.data.iter() {
+			let r = pixel.r() * GRID;
+			let g = pixel.g() * GRID;
+			let b = pixel.b() * GRID;
+
+			let bin = (r * GRID + g * GRID + b * GRID) as usize;
+
+			histogram[bin] += 1;
+			colors[bin].push(pixel.to_gamma_srgb());
+		}
+	}
+
+	let shorted = histogram.iter().enumerate().filter(|&(_, &count)| count > 0).map(|(i, _)| i).collect::<Vec<usize>>();
+
+	let mut palette = vec![];
+
+	for i in shorted.iter().take(max_size as usize) {
+		let list = colors[*i].clone();
+
+		let mut r = 0.;
+		let mut g = 0.;
+		let mut b = 0.;
+		let mut a = 0.;
+
+		for color in list.iter() {
+			r += color.r();
+			g += color.g();
+			b += color.b();
+			a += color.a();
+		}
+
+		r /= list.len() as f32;
+		g /= list.len() as f32;
+		b /= list.len() as f32;
+		a /= list.len() as f32;
+
+		let color = Color::from_rgbaf32(r, g, b, a).unwrap();
+
+		palette.push(color);
+	}
+
+	palette
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use graphene_core::raster::image::Image;
+	use graphene_core::raster_types::{Raster, RasterDataTable};
+
+	#[test]
+	fn test_image_color_palette() {
+		let result = image_color_palette(
+			(),
+			RasterDataTable::new(Raster::new_cpu(Image {
+				width: 100,
+				height: 100,
+				data: vec![Color::from_rgbaf32(0., 0., 0., 1.).unwrap(); 10000],
+				base64_string: None,
+			})),
+			1,
+		);
+		assert_eq!(futures::executor::block_on(result), [Color::from_rgbaf32(0., 0., 0., 1.).unwrap()]);
+	}
+}

node-graph/graster-nodes/src/lib.rs

@@ -0,0 +1,7 @@
+pub mod adjustments;
+pub mod curve;
+pub mod dehaze;
+pub mod filter;
+pub mod generate_curves;
+pub mod image_color_palette;
+pub mod std_nodes;

node-graph/graster-nodes/src/std_nodes.rs

@@ -0,0 +1,536 @@
+use crate::adjustments::{CellularDistanceFunction, CellularReturnType, DomainWarpType, FractalType, NoiseType};
+use dyn_any::DynAny;
+use fastnoise_lite;
+use glam::{DAffine2, DVec2, Vec2};
+use graphene_core::blending::AlphaBlending;
+use graphene_core::color::Color;
+use graphene_core::color::{Alpha, AlphaMut, Channel, LinearChannel, Luminance, RGBMut};
+use graphene_core::context::{Ctx, ExtractFootprint};
+use graphene_core::instances::Instance;
+use graphene_core::math::bbox::Bbox;
+use graphene_core::raster::image::Image;
+use graphene_core::raster::{Bitmap, BitmapMut};
+use graphene_core::raster_types::{CPU, Raster, RasterDataTable};
+use graphene_core::transform::Transform;
+use rand::prelude::*;
+use rand_chacha::ChaCha8Rng;
+use std::fmt::Debug;
+use std::hash::Hash;
+
+#[derive(Debug, DynAny)]
+pub enum Error {
+	IO(std::io::Error),
+	Image(::image::ImageError),
+}
+
+impl From<std::io::Error> for Error {
+	fn from(e: std::io::Error) -> Self {
+		Error::IO(e)
+	}
+}
+
+#[node_macro::node(category("Debug: Raster"))]
+pub fn sample_image(ctx: impl ExtractFootprint + Clone + Send, image_frame: RasterDataTable<CPU>) -> RasterDataTable<CPU> {
+	let mut result_table = RasterDataTable::default();
+
+	for mut image_frame_instance in image_frame.instance_iter() {
+		let image_frame_transform = image_frame_instance.transform;
+		let image = image_frame_instance.instance;
+
+		// Resize the image using the image crate
+		let data = bytemuck::cast_vec(image.data.clone());
+
+		let footprint = ctx.footprint();
+		let viewport_bounds = footprint.viewport_bounds_in_local_space();
+		let image_bounds = Bbox::from_transform(image_frame_transform).to_axis_aligned_bbox();
+		let intersection = viewport_bounds.intersect(&image_bounds);
+		let image_size = DAffine2::from_scale(DVec2::new(image.width as f64, image.height as f64));
+		let size = intersection.size();
+		let size_px = image_size.transform_vector2(size).as_uvec2();
+
+		// If the image would not be visible, add nothing.
+		if size.x <= 0. || size.y <= 0. {
+			continue;
+		}
+
+		let image_buffer = ::image::Rgba32FImage::from_raw(image.width, image.height, data).expect("Failed to convert internal image format into image-rs data type.");
+
+		let dynamic_image: ::image::DynamicImage = image_buffer.into();
+		let offset = (intersection.start - image_bounds.start).max(DVec2::ZERO);
+		let offset_px = image_size.transform_vector2(offset).as_uvec2();
+		let cropped = dynamic_image.crop_imm(offset_px.x, offset_px.y, size_px.x, size_px.y);
+
+		let viewport_resolution_x = footprint.transform.transform_vector2(DVec2::X * size.x).length();
+		let viewport_resolution_y = footprint.transform.transform_vector2(DVec2::Y * size.y).length();
+		let mut new_width = size_px.x;
+		let mut new_height = size_px.y;
+
+		// Only downscale the image for now
+		let resized = if new_width < image.width || new_height < image.height {
+			new_width = viewport_resolution_x as u32;
+			new_height = viewport_resolution_y as u32;
+			// TODO: choose filter based on quality requirements
+			cropped.resize_exact(new_width, new_height, ::image::imageops::Triangle)
+		} else {
+			cropped
+		};
+		let buffer = resized.to_rgba32f();
+		let buffer = buffer.into_raw();
+		let vec = bytemuck::cast_vec(buffer);
+		let image = Image {
+			width: new_width,
+			height: new_height,
+			data: vec,
+			base64_string: None,
+		};
+		// we need to adjust the offset if we truncate the offset calculation
+
+		let new_transform = image_frame_transform * DAffine2::from_translation(offset) * DAffine2::from_scale(size);
+
+		image_frame_instance.transform = new_transform;
+		image_frame_instance.source_node_id = None;
+		image_frame_instance.instance = Raster::new_cpu(image);
+		result_table.push(image_frame_instance)
+	}
+
+	result_table
+}
+
+#[node_macro::node(category("Raster: Channels"))]
+pub fn combine_channels(
+	_: impl Ctx,
+	_primary: (),
+	#[expose] red: RasterDataTable<CPU>,
+	#[expose] green: RasterDataTable<CPU>,
+	#[expose] blue: RasterDataTable<CPU>,
+	#[expose] alpha: RasterDataTable<CPU>,
+) -> RasterDataTable<CPU> {
+	let mut result_table = RasterDataTable::default();
+
+	let max_len = red.len().max(green.len()).max(blue.len()).max(alpha.len());
+	let red = red.instance_iter().map(Some).chain(std::iter::repeat(None)).take(max_len);
+	let green = green.instance_iter().map(Some).chain(std::iter::repeat(None)).take(max_len);
+	let blue = blue.instance_iter().map(Some).chain(std::iter::repeat(None)).take(max_len);
+	let alpha = alpha.instance_iter().map(Some).chain(std::iter::repeat(None)).take(max_len);
+
+	for (((red, green), blue), alpha) in red.zip(green).zip(blue).zip(alpha) {
+		// Turn any default zero-sized image instances into None
+		let red = red.filter(|i| i.instance.width > 0 && i.instance.height > 0);
+		let green = green.filter(|i| i.instance.width > 0 && i.instance.height > 0);
+		let blue = blue.filter(|i| i.instance.width > 0 && i.instance.height > 0);
+		let alpha = alpha.filter(|i| i.instance.width > 0 && i.instance.height > 0);
+
+		// Get this instance's transform and alpha blending mode from the first non-empty channel
+		let Some((transform, alpha_blending)) = [&red, &green, &blue, &alpha].iter().find_map(|i| i.as_ref()).map(|i| (i.transform, i.alpha_blending)) else {
+			continue;
+		};
+
+		// Get the common width and height of the channels, which must have equal dimensions
+		let channel_dimensions = [
+			red.as_ref().map(|r| (r.instance.width, r.instance.height)),
+			green.as_ref().map(|g| (g.instance.width, g.instance.height)),
+			blue.as_ref().map(|b| (b.instance.width, b.instance.height)),
+			alpha.as_ref().map(|a| (a.instance.width, a.instance.height)),
+		];
+		if channel_dimensions.iter().all(Option::is_none)
+			|| channel_dimensions
+				.iter()
+				.flatten()
+				.any(|&(x, y)| channel_dimensions.iter().flatten().any(|&(other_x, other_y)| x != other_x || y != other_y))
+		{
+			continue;
+		}
+		let Some(&(width, height)) = channel_dimensions.iter().flatten().next() else { continue };
+
+		// Create a new image for this instance output
+		let mut image = Image::new(width, height, Color::TRANSPARENT);
+
+		// Iterate over all pixels in the image and set the color channels
+		for y in 0..image.height() {
+			for x in 0..image.width() {
+				let image_pixel = image.get_pixel_mut(x, y).unwrap();
+
+				if let Some(r) = red.as_ref().and_then(|r| r.instance.get_pixel(x, y)) {
+					image_pixel.set_red(r.l().cast_linear_channel());
+				} else {
+					image_pixel.set_red(Channel::from_linear(0.));
+				}
+				if let Some(g) = green.as_ref().and_then(|g| g.instance.get_pixel(x, y)) {
+					image_pixel.set_green(g.l().cast_linear_channel());
+				} else {
+					image_pixel.set_green(Channel::from_linear(0.));
+				}
+				if let Some(b) = blue.as_ref().and_then(|b| b.instance.get_pixel(x, y)) {
+					image_pixel.set_blue(b.l().cast_linear_channel());
+				} else {
+					image_pixel.set_blue(Channel::from_linear(0.));
+				}
+				if let Some(a) = alpha.as_ref().and_then(|a| a.instance.get_pixel(x, y)) {
+					image_pixel.set_alpha(a.l().cast_linear_channel());
+				} else {
+					image_pixel.set_alpha(Channel::from_linear(1.));
+				}
+			}
+		}
+
+		// Add this instance to the result table
+		result_table.push(Instance {
+			instance: Raster::new_cpu(image),
+			transform,
+			alpha_blending,
+			source_node_id: None,
+		});
+	}
+
+	result_table
+}
+
+#[node_macro::node(category("Raster"))]
+pub fn mask(
+	_: impl Ctx,
+	/// The image to be masked.
+	image: RasterDataTable<CPU>,
+	/// The stencil to be used for masking.
+	#[expose]
+	stencil: RasterDataTable<CPU>,
+) -> RasterDataTable<CPU> {
+	// TODO: Support multiple stencil instances
+	let Some(stencil_instance) = stencil.instance_iter().next() else {
+		// No stencil provided so we return the original image
+		return image;
+	};
+	let stencil_size = DVec2::new(stencil_instance.instance.width as f64, stencil_instance.instance.height as f64);
+
+	let mut result_table = RasterDataTable::default();
+
+	for mut image_instance in image.instance_iter() {
+		let image_size = DVec2::new(image_instance.instance.width as f64, image_instance.instance.height as f64);
+		let mask_size = stencil_instance.transform.decompose_scale();
+
+		if mask_size == DVec2::ZERO {
+			continue;
+		}
+
+		// Transforms a point from the background image to the foreground image
+		let bg_to_fg = image_instance.transform * DAffine2::from_scale(1. / image_size);
+		let stencil_transform_inverse = stencil_instance.transform.inverse();
+
+		for y in 0..image_instance.instance.height {
+			for x in 0..image_instance.instance.width {
+				let image_point = DVec2::new(x as f64, y as f64);
+				let mask_point = bg_to_fg.transform_point2(image_point);
+				let local_mask_point = stencil_transform_inverse.transform_point2(mask_point);
+				let mask_point = stencil_instance.transform.transform_point2(local_mask_point.clamp(DVec2::ZERO, DVec2::ONE));
+				let mask_point = (DAffine2::from_scale(stencil_size) * stencil_instance.transform.inverse()).transform_point2(mask_point);
+
+				let image_pixel = image_instance.instance.data_mut().get_pixel_mut(x, y).unwrap();
+				let mask_pixel = stencil_instance.instance.sample(mask_point);
+				*image_pixel = image_pixel.multiplied_alpha(mask_pixel.l().cast_linear_channel());
+			}
+		}
+
+		result_table.push(image_instance);
+	}
+
+	result_table
+}
+
+#[node_macro::node(category(""))]
+pub fn extend_image_to_bounds(_: impl Ctx, image: RasterDataTable<CPU>, bounds: DAffine2) -> RasterDataTable<CPU> {
+	let mut result_table = RasterDataTable::default();
+
+	for mut image_instance in image.instance_iter() {
+		let image_aabb = Bbox::unit().affine_transform(image_instance.transform).to_axis_aligned_bbox();
+		let bounds_aabb = Bbox::unit().affine_transform(bounds.transform()).to_axis_aligned_bbox();
+		if image_aabb.contains(bounds_aabb.start) && image_aabb.contains(bounds_aabb.end) {
+			result_table.push(image_instance);
+			continue;
+		}
+
+		let image_data = &image_instance.instance.data;
+		let (image_width, image_height) = (image_instance.instance.width, image_instance.instance.height);
+		if image_width == 0 || image_height == 0 {
+			for image_instance in empty_image((), bounds, Color::TRANSPARENT).instance_iter() {
+				result_table.push(image_instance);
+			}
+			continue;
+		}
+
+		let orig_image_scale = DVec2::new(image_width as f64, image_height as f64);
+		let layer_to_image_space = DAffine2::from_scale(orig_image_scale) * image_instance.transform.inverse();
+		let bounds_in_image_space = Bbox::unit().affine_transform(layer_to_image_space * bounds).to_axis_aligned_bbox();
+
+		let new_start = bounds_in_image_space.start.floor().min(DVec2::ZERO);
+		let new_end = bounds_in_image_space.end.ceil().max(orig_image_scale);
+		let new_scale = new_end - new_start;
+
+		// Copy over original image into enlarged image.
+		let mut new_image = Image::new(new_scale.x as u32, new_scale.y as u32, Color::TRANSPARENT);
+		let offset_in_new_image = (-new_start).as_uvec2();
+		for y in 0..image_height {
+			let old_start = y * image_width;
+			let new_start = (y + offset_in_new_image.y) * new_image.width + offset_in_new_image.x;
+			let old_row = &image_data[old_start as usize..(old_start + image_width) as usize];
+			let new_row = &mut new_image.data[new_start as usize..(new_start + image_width) as usize];
+			new_row.copy_from_slice(old_row);
+		}
+
+		// Compute new transform.
+		// let layer_to_new_texture_space = (DAffine2::from_scale(1. / new_scale) * DAffine2::from_translation(new_start) * layer_to_image_space).inverse();
+		let new_texture_to_layer_space = image_instance.transform * DAffine2::from_scale(1. / orig_image_scale) * DAffine2::from_translation(new_start) * DAffine2::from_scale(new_scale);
+
+		image_instance.instance = Raster::new_cpu(new_image);
+		image_instance.transform = new_texture_to_layer_space;
+		image_instance.source_node_id = None;
+		result_table.push(image_instance);
+	}
+
+	result_table
+}
+
+#[node_macro::node(category("Debug: Raster"))]
+pub fn empty_image(_: impl Ctx, transform: DAffine2, color: Color) -> RasterDataTable<CPU> {
+	let width = transform.transform_vector2(DVec2::new(1., 0.)).length() as u32;
+	let height = transform.transform_vector2(DVec2::new(0., 1.)).length() as u32;
+
+	let image = Image::new(width, height, color);
+
+	let mut result_table = RasterDataTable::new(Raster::new_cpu(image));
+	let image_instance = result_table.get_mut(0).unwrap();
+	*image_instance.transform = transform;
+	*image_instance.alpha_blending = AlphaBlending::default();
+
+	// Callers of empty_image can safely unwrap on returned table
+	result_table
+}
+
+/// Constructs a raster image.
+#[node_macro::node(category(""))]
+pub fn image_value(_: impl Ctx, _primary: (), image: RasterDataTable<CPU>) -> RasterDataTable<CPU> {
+	image
+}
+
+#[node_macro::node(category("Raster: Pattern"))]
+#[allow(clippy::too_many_arguments)]
+pub fn noise_pattern(
+	ctx: impl ExtractFootprint + Ctx,
+	_primary: (),
+	clip: bool,
+	seed: u32,
+	scale: f64,
+	noise_type: NoiseType,
+	domain_warp_type: DomainWarpType,
+	domain_warp_amplitude: f64,
+	fractal_type: FractalType,
+	fractal_octaves: u32,
+	fractal_lacunarity: f64,
+	fractal_gain: f64,
+	fractal_weighted_strength: f64,
+	fractal_ping_pong_strength: f64,
+	cellular_distance_function: CellularDistanceFunction,
+	cellular_return_type: CellularReturnType,
+	cellular_jitter: f64,
+) -> RasterDataTable<CPU> {
+	let footprint = ctx.footprint();
+	let viewport_bounds = footprint.viewport_bounds_in_local_space();
+
+	let mut size = viewport_bounds.size();
+	let mut offset = viewport_bounds.start;
+	if clip {
+		// TODO: Remove "clip" entirely (and its arbitrary 100x100 clipping square) once we have proper resolution-aware layer clipping
+		const CLIPPING_SQUARE_SIZE: f64 = 100.;
+		let image_bounds = Bbox::from_transform(DAffine2::from_scale(DVec2::splat(CLIPPING_SQUARE_SIZE))).to_axis_aligned_bbox();
+		let intersection = viewport_bounds.intersect(&image_bounds);
+
+		offset = (intersection.start - image_bounds.start).max(DVec2::ZERO);
+		size = intersection.size();
+	}
+
+	// If the image would not be visible, return an empty image
+	if size.x <= 0. || size.y <= 0. {
+		return RasterDataTable::default();
+	}
+
+	let footprint_scale = footprint.scale();
+	let width = (size.x * footprint_scale.x) as u32;
+	let height = (size.y * footprint_scale.y) as u32;
+
+	// All
+	let mut image = Image::new(width, height, Color::from_luminance(0.5));
+	let mut noise = fastnoise_lite::FastNoiseLite::with_seed(seed as i32);
+	noise.set_frequency(Some(1. / (scale as f32).max(f32::EPSILON)));
+
+	// Domain Warp
+	let domain_warp_type = match domain_warp_type {
+		DomainWarpType::None => None,
+		DomainWarpType::OpenSimplex2 => Some(fastnoise_lite::DomainWarpType::OpenSimplex2),
+		DomainWarpType::OpenSimplex2Reduced => Some(fastnoise_lite::DomainWarpType::OpenSimplex2Reduced),
+		DomainWarpType::BasicGrid => Some(fastnoise_lite::DomainWarpType::BasicGrid),
+	};
+	let domain_warp_active = domain_warp_type.is_some();
+	noise.set_domain_warp_type(domain_warp_type);
+	noise.set_domain_warp_amp(Some(domain_warp_amplitude as f32));
+
+	// Fractal
+	let noise_type = match noise_type {
+		NoiseType::Perlin => fastnoise_lite::NoiseType::Perlin,
+		NoiseType::OpenSimplex2 => fastnoise_lite::NoiseType::OpenSimplex2,
+		NoiseType::OpenSimplex2S => fastnoise_lite::NoiseType::OpenSimplex2S,
+		NoiseType::Cellular => fastnoise_lite::NoiseType::Cellular,
+		NoiseType::ValueCubic => fastnoise_lite::NoiseType::ValueCubic,
+		NoiseType::Value => fastnoise_lite::NoiseType::Value,
+		NoiseType::WhiteNoise => {
+			// TODO: Generate in layer space, not viewport space
+
+			let mut rng = ChaCha8Rng::seed_from_u64(seed as u64);
+
+			for y in 0..height {
+				for x in 0..width {
+					let pixel = image.get_pixel_mut(x, y).unwrap();
+					let luminance = rng.random_range(0.0..1.) as f32;
+					*pixel = Color::from_luminance(luminance);
+				}
+			}
+
+			let mut result = RasterDataTable::default();
+			result.push(Instance {
+				instance: Raster::new_cpu(image),
+				transform: DAffine2::from_translation(offset) * DAffine2::from_scale(size),
+				..Default::default()
+			});
+
+			return result;
+		}
+	};
+	noise.set_noise_type(Some(noise_type));
+	let fractal_type = match fractal_type {
+		FractalType::None => fastnoise_lite::FractalType::None,
+		FractalType::FBm => fastnoise_lite::FractalType::FBm,
+		FractalType::Ridged => fastnoise_lite::FractalType::Ridged,
+		FractalType::PingPong => fastnoise_lite::FractalType::PingPong,
+		FractalType::DomainWarpProgressive => fastnoise_lite::FractalType::DomainWarpProgressive,
+		FractalType::DomainWarpIndependent => fastnoise_lite::FractalType::DomainWarpIndependent,
+	};
+	noise.set_fractal_type(Some(fractal_type));
+	noise.set_fractal_octaves(Some(fractal_octaves as i32));
+	noise.set_fractal_lacunarity(Some(fractal_lacunarity as f32));
+	noise.set_fractal_gain(Some(fractal_gain as f32));
+	noise.set_fractal_weighted_strength(Some(fractal_weighted_strength as f32));
+	noise.set_fractal_ping_pong_strength(Some(fractal_ping_pong_strength as f32));
+
+	// Cellular
+	let cellular_distance_function = match cellular_distance_function {
+		CellularDistanceFunction::Euclidean => fastnoise_lite::CellularDistanceFunction::Euclidean,
+		CellularDistanceFunction::EuclideanSq => fastnoise_lite::CellularDistanceFunction::EuclideanSq,
+		CellularDistanceFunction::Manhattan => fastnoise_lite::CellularDistanceFunction::Manhattan,
+		CellularDistanceFunction::Hybrid => fastnoise_lite::CellularDistanceFunction::Hybrid,
+	};
+	let cellular_return_type = match cellular_return_type {
+		CellularReturnType::CellValue => fastnoise_lite::CellularReturnType::CellValue,
+		CellularReturnType::Nearest => fastnoise_lite::CellularReturnType::Distance,
+		CellularReturnType::NextNearest => fastnoise_lite::CellularReturnType::Distance2,
+		CellularReturnType::Average => fastnoise_lite::CellularReturnType::Distance2Add,
+		CellularReturnType::Difference => fastnoise_lite::CellularReturnType::Distance2Sub,
+		CellularReturnType::Product => fastnoise_lite::CellularReturnType::Distance2Mul,
+		CellularReturnType::Division => fastnoise_lite::CellularReturnType::Distance2Div,
+	};
+	noise.set_cellular_distance_function(Some(cellular_distance_function));
+	noise.set_cellular_return_type(Some(cellular_return_type));
+	noise.set_cellular_jitter(Some(cellular_jitter as f32));
+
+	let coordinate_offset = offset.as_vec2();
+	let scale = size.as_vec2() / Vec2::new(width as f32, height as f32);
+	// Calculate the noise for every pixel
+	for y in 0..height {
+		for x in 0..width {
+			let pixel = image.get_pixel_mut(x, y).unwrap();
+			let pos = Vec2::new(x as f32, y as f32);
+			let vec = pos * scale + coordinate_offset;
+
+			let (mut x, mut y) = (vec.x, vec.y);
+			if domain_warp_active && domain_warp_amplitude > 0. {
+				(x, y) = noise.domain_warp_2d(x, y);
+			}
+
+			let luminance = (noise.get_noise_2d(x, y) + 1.) * 0.5;
+			*pixel = Color::from_luminance(luminance);
+		}
+	}
+
+	let mut result = RasterDataTable::default();
+	result.push(Instance {
+		instance: Raster::new_cpu(image),
+		transform: DAffine2::from_translation(offset) * DAffine2::from_scale(size),
+		..Default::default()
+	});
+
+	result
+}
+
+#[node_macro::node(category("Raster: Pattern"))]
+pub fn mandelbrot(ctx: impl ExtractFootprint + Send) -> RasterDataTable<CPU> {
+	let footprint = ctx.footprint();
+	let viewport_bounds = footprint.viewport_bounds_in_local_space();
+
+	let image_bounds = Bbox::from_transform(DAffine2::IDENTITY).to_axis_aligned_bbox();
+	let intersection = viewport_bounds.intersect(&image_bounds);
+	let size = intersection.size();
+
+	let offset = (intersection.start - image_bounds.start).max(DVec2::ZERO);
+
+	// If the image would not be visible, return an empty image
+	if size.x <= 0. || size.y <= 0. {
+		return RasterDataTable::default();
+	}
+
+	let scale = footprint.scale();
+	let width = (size.x * scale.x) as u32;
+	let height = (size.y * scale.y) as u32;
+
+	let mut data = Vec::with_capacity(width as usize * height as usize);
+	let max_iter = 255;
+
+	let scale = 3. * size.as_vec2() / Vec2::new(width as f32, height as f32);
+	let coordinate_offset = offset.as_vec2() * 3. - Vec2::new(2., 1.5);
+	for y in 0..height {
+		for x in 0..width {
+			let pos = Vec2::new(x as f32, y as f32);
+			let c = pos * scale + coordinate_offset;
+
+			let iter = mandelbrot_impl(c, max_iter);
+			data.push(map_color(iter, max_iter));
+		}
+	}
+
+	let image = Image {
+		width,
+		height,
+		data,
+		..Default::default()
+	};
+	let mut result = RasterDataTable::default();
+	result.push(Instance {
+		instance: Raster::new_cpu(image),
+		transform: DAffine2::from_translation(offset) * DAffine2::from_scale(size),
+		..Default::default()
+	});
+
+	result
+}
+
+#[inline(always)]
+fn mandelbrot_impl(c: Vec2, max_iter: usize) -> usize {
+	let mut z = Vec2::new(0., 0.);
+	for i in 0..max_iter {
+		z = Vec2::new(z.x * z.x - z.y * z.y, 2. * z.x * z.y) + c;
+		if z.length_squared() > 4. {
+			return i;
+		}
+	}
+	max_iter
+}
+
+fn map_color(iter: usize, max_iter: usize) -> Color {
+	let v = iter as f32 / max_iter as f32;
+	Color::from_rgbaf32_unchecked(v, v, v, 1.)
+}