Implementation of gaussian blur and box blur and raster category

Author: calvintvu

node-graph/gstd/src/filter.rs

@@ -0,0 +1,242 @@
+use graph_craft::proto::types::PixelLength;
+use graphene_core::raster::image::{Image, ImageFrameTable};
+use graphene_core::transform::{Transform, TransformMut};
+use graphene_core::{Color, Ctx};
+use image::{DynamicImage, GenericImageView, ImageBuffer, Rgba};
+
+#[node_macro::node(category("Raster"))]
+async fn blur(_: impl Ctx, image_frame: ImageFrameTable<Color>, #[range((0., 100.))] radius: PixelLength, gaussian_blur: bool) -> ImageFrameTable<Color> {
+	let image_frame_transform = image_frame.transform();
+	let image_frame_alpha_blending = image_frame.one_instance().alpha_blending;
+
+	let image = image_frame.one_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: image::DynamicImage = image_buffer.into();
+
+	// Run blur algorithm
+	let blurred_image = blur_helper(dynamic_image, radius, gaussian_blur);
+
+	// Prepare the image data for returning
+	let buffer = blurred_image.to_rgba32f().into_raw();
+	let color_vec = bytemuck::cast_vec(buffer);
+	let processed_image = Image {
+		width: image.width,
+		height: image.height,
+		data: color_vec,
+		base64_string: None,
+	};
+
+	let mut result = ImageFrameTable::new(processed_image);
+	*result.transform_mut() = image_frame_transform;
+	*result.one_instance_mut().alpha_blending = *image_frame_alpha_blending;
+
+	result
+}
+
+fn blur_helper(image: DynamicImage, radius: f64, gaussian: bool) -> DynamicImage {
+	// For small radius, image would not change much -> just return original image
+	if radius < 1 as f64 {
+		return image;
+	} else {
+		// Run the gaussian blur algorithm, if user wants
+		if gaussian {
+			return gaussian_blur(image, radius);
+		}
+		// Else, run box blur
+		else {
+			return box_blur(image, radius);
+		}
+	}
+}
+
+fn gaussian_blur(image: DynamicImage, radius: f64) -> DynamicImage {
+	let (width, height) = image.dimensions();
+	let original_buffer = image.to_rgba8();
+
+	// Create 1D gaussian kernel
+	let kernel = create_gaussian_kernel(radius);
+	let half_kernel = kernel.len() / 2;
+
+	// Intermediate buffer for horizontal pass
+	let mut x_axis = ImageBuffer::<Rgba<u8>, Vec<u8>>::new(width, height);
+	// Blur along x-axis
+	for y in 0..height {
+		for x in 0..width {
+			let mut r_sum = 0.0;
+			let mut g_sum = 0.0;
+			let mut b_sum = 0.0;
+			let mut a_sum = 0.0;
+			let mut weight_sum = 0.0;
+
+			for (i, &weight) in kernel.iter().enumerate() {
+				let kx = i as i32 - half_kernel as i32;
+				let px = x as i32 + kx;
+
+				if px >= 0 && px < width as i32 {
+					let pixel = original_buffer.get_pixel(px as u32, y);
+
+					r_sum += pixel[0] as f64 * weight;
+					g_sum += pixel[1] as f64 * weight;
+					b_sum += pixel[2] as f64 * weight;
+					a_sum += pixel[3] as f64 * weight;
+					weight_sum += weight;
+				}
+			}
+
+			// Normalize
+			if weight_sum > 0.0 {
+				let r = (r_sum / weight_sum).clamp(0.0, 255.0) as u8;
+				let g = (g_sum / weight_sum).clamp(0.0, 255.0) as u8;
+				let b = (b_sum / weight_sum).clamp(0.0, 255.0) as u8;
+				let a = (a_sum / weight_sum).clamp(0.0, 255.0) as u8;
+
+				x_axis.put_pixel(x, y, Rgba([r, g, b, a]));
+			} else {
+				x_axis.put_pixel(x, y, *original_buffer.get_pixel(x, y));
+			}
+		}
+	}
+
+	// Intermediate buffer for vertical pass
+	let mut y_axis = ImageBuffer::<Rgba<u8>, Vec<u8>>::new(width, height);
+	// Blur along y-axis
+	for y in 0..height {
+		for x in 0..width {
+			let mut r_sum = 0.0;
+			let mut g_sum = 0.0;
+			let mut b_sum = 0.0;
+			let mut a_sum: f64 = 0.0;
+			let mut weight_sum = 0.0;
+
+			for (i, &weight) in kernel.iter().enumerate() {
+				let ky = i as i32 - half_kernel as i32;
+				let py = y as i32 + ky;
+
+				if py >= 0 && py < height as i32 {
+					let pixel = x_axis.get_pixel(x, py as u32);
+
+					r_sum += pixel[0] as f64 * weight;
+					g_sum += pixel[1] as f64 * weight;
+					b_sum += pixel[2] as f64 * weight;
+					a_sum += pixel[3] as f64 * weight;
+					weight_sum += weight;
+				}
+			}
+
+			if weight_sum > 0.0 {
+				let r = (r_sum / weight_sum).clamp(0.0, 255.0) as u8;
+				let g = (g_sum / weight_sum).clamp(0.0, 255.0) as u8;
+				let b = (b_sum / weight_sum).clamp(0.0, 255.0) as u8;
+				let a = (a_sum / weight_sum).clamp(0.0, 255.0) as u8;
+
+				y_axis.put_pixel(x, y, Rgba([r, g, b, a]));
+			} else {
+				y_axis.put_pixel(x, y, *x_axis.get_pixel(x, y));
+			}
+		}
+	}
+
+	DynamicImage::ImageRgba8(y_axis)
+}
+
+// 1D gaussian kernel
+fn create_gaussian_kernel(radius: f64) -> Vec<f64> {
+	// Given radius, compute size of kernel -> 3*radius (approx.)
+	let kernel_radius = (3.0 * radius).ceil() as usize;
+	let kernel_size = 2 * kernel_radius + 1;
+	let mut gaussian_kernel: Vec<f64> = vec![0.0; kernel_size];
+
+	// Kernel values
+	let two_radius_squared = 2.0 * radius * radius;
+	let mut sum = 0.0;
+	for i in 0..kernel_size {
+		let x: f64 = i as f64 - kernel_radius as f64;
+		let exponent = -(x * x) / two_radius_squared;
+		gaussian_kernel[i] = exponent.exp();
+		sum += gaussian_kernel[i];
+	}
+
+	// Normalize
+	for i in 0..kernel_size {
+		gaussian_kernel[i] /= sum;
+	}
+
+	gaussian_kernel
+}
+
+fn box_blur(image: DynamicImage, radius: f64) -> DynamicImage {
+	let (width, height) = image.dimensions();
+	let original_buffer = image.to_rgba8();
+	let mut x_axis = ImageBuffer::new(width, height);
+	let mut blurred_image = ImageBuffer::new(width, height);
+
+	// Blur along x-axis
+	for y in 0..height {
+		for x in 0..width {
+			let mut r_sum = 0.0;
+			let mut g_sum = 0.0;
+			let mut b_sum = 0.0;
+			let mut a_sum = 0.0;
+			let mut weight_sum = 0.0;
+
+			for dx in (x as i32 - radius as i32).max(0)..=(x as i32 + radius as i32).min(width as i32 - 1) {
+				let pixel = original_buffer.get_pixel(dx as u32, y);
+				let weight = 1.0;
+
+				r_sum += pixel[0] as f64 * weight;
+				g_sum += pixel[1] as f64 * weight;
+				b_sum += pixel[2] as f64 * weight;
+				a_sum += pixel[3] as f64 * weight;
+				weight_sum += weight;
+			}
+
+			x_axis.put_pixel(
+				x,
+				y,
+				Rgba([
+					(r_sum / weight_sum).round() as u8,
+					(g_sum / weight_sum).round() as u8,
+					(b_sum / weight_sum).round() as u8,
+					(a_sum / weight_sum).round() as u8,
+				]),
+			);
+		}
+	}
+
+	// Blur along y-axis
+	for y in 0..height {
+		for x in 0..width {
+			let mut r_sum = 0.0;
+			let mut g_sum = 0.0;
+			let mut b_sum = 0.0;
+			let mut a_sum = 0.0;
+			let mut weight_sum = 0.0;
+
+			for dy in (y as i32 - radius as i32).max(0)..=(y as i32 + radius as i32).min(height as i32 - 1) {
+				let pixel = x_axis.get_pixel(x, dy as u32);
+				let weight = 1.0;
+
+				r_sum += pixel[0] as f64 * weight;
+				g_sum += pixel[1] as f64 * weight;
+				b_sum += pixel[2] as f64 * weight;
+				a_sum += pixel[3] as f64 * weight;
+				weight_sum += weight;
+			}
+
+			blurred_image.put_pixel(
+				x,
+				y,
+				Rgba([
+					(r_sum / weight_sum).round() as u8,
+					(g_sum / weight_sum).round() as u8,
+					(b_sum / weight_sum).round() as u8,
+					(a_sum / weight_sum).round() as u8,
+				]),
+			);
+		}
+	}
+	DynamicImage::ImageRgba8(blurred_image)
+}

node-graph/gstd/src/lib.rs

@@ -30,3 +30,5 @@ pub mod wasm_application_io;
 pub mod dehaze;
 
 pub mod imaginate;
+
+pub mod filter;