Convert dehaze, empty_image, extend_image_to_bounds, and image to record kernels

node-graph/nodes/brush/src/brush.rs

@@ -11,7 +11,7 @@ use core_types::uuid::NodeId;
 use core_types::{ATTR_BLEND_MODE, ATTR_CLIPPING_MASK, ATTR_EDITOR_LAYER_PATH, ATTR_OPACITY, ATTR_OPACITY_FILL, ATTR_TRANSFORM};
 use glam::{DAffine2, DVec2};
 use raster_nodes::blending_nodes::blend_colors;
-use raster_nodes::std_nodes::{empty_image, extend_image_to_bounds};
+use raster_nodes::std_nodes::{empty_image_core, extend_image_to_bounds_core};
 use raster_types::BitmapMut;
 use raster_types::Image;
 use raster_types::{CPU, Raster};
@@ -134,7 +134,11 @@ where
 pub fn create_brush_texture(brush_style: &BrushStyle) -> Raster<CPU> {
 	let stamp = brush_stamp_generator(&(), brush_style.diameter, brush_style.color, brush_style.hardness, brush_style.flow);
 	let transform = DAffine2::from_scale_angle_translation(DVec2::splat(brush_style.diameter), 0., -DVec2::splat(brush_style.diameter / 2.));
-	let blank_texture = empty_image(&(), transform, List::new_from_element(Color::TRANSPARENT)).into_iter().next().unwrap_or_default();
+	let blank_texture = {
+		let mut item = Item::new_from_element(empty_image_core(transform, Color::TRANSPARENT));
+		item.set_attribute(ATTR_TRANSFORM, transform);
+		item
+	};
 	let image = blend_stamp_closure(stamp, blank_texture, |a, b| blend_colors(a, b, BlendMode::Normal, 1.));
 
 	image.into_element()
@@ -221,8 +225,14 @@ fn brush(
 	let mut brush_plan = cache.compute_brush_plan(list_item, &draw_strokes);
 
 	// TODO: Find a way to handle more than one item
-	let Some(mut actual_image) = extend_image_to_bounds(&(), List::new_from_item(brush_plan.background), background_bounds).into_iter().next() else {
+	let mut actual_image = {
-		return List::new();
+		let background = brush_plan.background;
+		let transform: DAffine2 = background.attribute_cloned_or_default(ATTR_TRANSFORM);
+		let (element, attributes) = background.into_parts();
+		let (element, transform) = extend_image_to_bounds_core(element, transform, background_bounds);
+		let mut item = Item::from_parts(element, attributes);
+		item.set_attribute(ATTR_TRANSFORM, transform);
+		item
 	};
 
 	let final_stroke_idx = brush_plan.strokes.len().saturating_sub(1);
@@ -254,9 +264,16 @@ fn brush(
 
 			let blit_target = if idx == 0 {
 				let target = core::mem::take(&mut brush_plan.first_stroke_texture);
-				extend_image_to_bounds(&(), List::new_from_item(target), stroke_to_layer)
+				let transform: DAffine2 = target.attribute_cloned_or_default(ATTR_TRANSFORM);
+				let (element, attributes) = target.into_parts();
+				let (element, transform) = extend_image_to_bounds_core(element, transform, stroke_to_layer);
+				let mut item = Item::from_parts(element, attributes);
+				item.set_attribute(ATTR_TRANSFORM, transform);
+				List::new_from_item(item)
 			} else {
-				empty_image(&(), stroke_to_layer, List::new_from_element(Color::TRANSPARENT))
+				let mut item = Item::new_from_element(empty_image_core(stroke_to_layer, Color::TRANSPARENT));
+				item.set_attribute(ATTR_TRANSFORM, stroke_to_layer);
+				List::new_from_item(item)
 			};
 
 			let list = blit(&(), blit_target, brush_texture, positions, |a, b| blend_colors(a, b, BlendMode::Normal, 1.));

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

@@ -1,5 +1,4 @@
 use core_types::context::Ctx;
-use core_types::list::List;
 use core_types::registry::types::Percentage;
 use image::{DynamicImage, GenericImage, GenericImageView, GrayImage, ImageBuffer, Luma, Rgba, RgbaImage};
 use ndarray::{Array2, ArrayBase, Dim, OwnedRepr};
@@ -8,11 +7,8 @@ use raster_types::{CPU, Raster};
 use std::cmp::{max, min};
 
 #[node_macro::node(category("Raster: Filter"))]
-fn dehaze(_: impl Ctx, image_frame: List<Raster<CPU>>, strength: Percentage) -> List<Raster<CPU>> {
+fn dehaze(_: impl Ctx, image_frame: Raster<CPU>, strength: Percentage) -> Raster<CPU> {
-	image_frame
+	let image = image_frame;
-		.into_iter()
-		.map(|mut row| {
-			let image = std::mem::replace(row.element_mut(), Raster::new_cpu(Image::default()));
 	// 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.");
@@ -31,10 +27,7 @@ fn dehaze(_: impl Ctx, image_frame: List<Raster<CPU>>, strength: Percentage) ->
 		base64_string: None,
 	};
 
-			*row.element_mut() = Raster::new_cpu(dehazed_image);
+	Raster::new_cpu(dehazed_image)
-			row
-		})
-		.collect()
 }
 
 // There is no real point in modifying these values because they do not change the final result all that much.

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

@@ -1,8 +1,9 @@
 use crate::adjustments::{CellularDistanceFunction, CellularReturnType, DomainWarpType, FractalType, NoiseType};
 use core_types::ATTR_TRANSFORM;
+use core_types::attribute::{Attr, Transform as TransformAttr};
 use core_types::color::Color;
 use core_types::color::{Alpha, AlphaMut, Channel, LinearChannel, Luminance, RGBMut};
-use core_types::context::{Ctx, ExtractFootprint};
+use core_types::context::{Ctx, ExtractFootprint, ExtractIndex, InjectIndex};
 use core_types::list::{Item, List};
 use core_types::math::bbox::Bbox;
 use core_types::transform::Transform;
@@ -225,23 +226,19 @@ pub fn mask(
 		.collect()
 }
 
-#[node_macro::node(category(""))]
+/// The per-lane extend, shared with the brush's plain callers.
-pub fn extend_image_to_bounds(_: impl Ctx, image: List<Raster<CPU>>, bounds: DAffine2) -> List<Raster<CPU>> {
+pub fn extend_image_to_bounds_core(image: Raster<CPU>, row_transform: DAffine2, bounds: DAffine2) -> (Raster<CPU>, DAffine2) {
-	image
-		.into_iter()
-		.map(|mut row| {
-			let row_transform: DAffine2 = row.attribute_cloned_or_default(ATTR_TRANSFORM);
 	let image_aabb = Bbox::unit().affine_transform(row_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) {
-				return row;
+		return (image, row_transform);
 	}
 
-			let image_data = &row.element().data;
+	let (image_width, image_height) = (image.width, image.height);
-			let (image_width, image_height) = (row.element().width, row.element().height);
 	if image_width == 0 || image_height == 0 {
-				return empty_image(&(), bounds, List::new_from_element(Color::TRANSPARENT)).into_iter().next().unwrap();
+		return (empty_image_core(bounds, Color::TRANSPARENT), bounds);
 	}
+	let image_data = &image.data;
 
 	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) * row_transform.inverse();
@@ -266,34 +263,39 @@ pub fn extend_image_to_bounds(_: impl Ctx, image: List<Raster<CPU>>, bounds: DAf
 	// 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 = row_transform * DAffine2::from_scale(1. / orig_image_scale) * DAffine2::from_translation(new_start) * DAffine2::from_scale(new_scale);
 
-			*row.element_mut() = Raster::new_cpu(new_image);
+	(Raster::new_cpu(new_image), new_texture_to_layer_space)
-			row.set_attribute(ATTR_TRANSFORM, new_texture_to_layer_space);
-			row
-		})
-		.collect()
-}
-
-#[node_macro::node(category("Debug"))]
-pub fn empty_image(_: impl Ctx, transform: DAffine2, color: List<Color>) -> List<Raster<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 color = color.element(0).copied().unwrap_or(Color::WHITE);
-	let image = Image::new(width, height, color);
-
-	let mut result_list = List::new_from_element(Raster::new_cpu(image));
-	result_list.set_attribute(ATTR_TRANSFORM, 0, transform);
-
-	// Callers of empty_image can safely unwrap on returned `List`
-	result_list
 }
 
 #[node_macro::node(category(""))]
-pub fn image(_: impl Ctx, resource: Resource) -> List<Raster<CPU>> {
+pub fn extend_image_to_bounds(_: impl Ctx, (image, transform): (Raster<CPU>, Attr<TransformAttr>), bounds: DAffine2) -> (Raster<CPU>, Attr<TransformAttr>) {
+	let (image, transform) = extend_image_to_bounds_core(image, *transform, bounds);
+	(image, Attr(transform))
+}
+
+/// The blank texture a transform spans, shared with the brush's plain callers.
+pub fn empty_image_core(transform: DAffine2, color: Color) -> Raster<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;
+
+	Raster::new_cpu(Image::new(width, height, color))
+}
+
+#[node_macro::node(category("Debug"))]
+pub fn empty_image(_: impl Ctx + ExtractIndex + InjectIndex + Copy, transform: DAffine2, color: IList<Color>) -> (Raster<CPU>, Attr<TransformAttr>) {
+	let color = match color.len() {
+		0 => Color::WHITE,
+		_ => color.get(0),
+	};
+	(empty_image_core(transform, color), Attr(transform))
+}
+
+#[node_macro::node(category(""))]
+pub fn image(_: impl Ctx, resource: Resource) -> Raster<CPU> {
 	let image_data = resource.as_ref();
 
+	// A zero-size raster renders as nothing, matching the legacy empty list.
 	let Some(image) = ::image::load_from_memory(image_data).ok() else {
-		return List::new();
+		return Raster::new_cpu(Image::default());
 	};
 	let image = image.to_rgba32f();
 	let image = Image {
@@ -308,7 +310,7 @@ pub fn image(_: impl Ctx, resource: Resource) -> List<Raster<CPU>> {
 		height: image.height(),
 		..Default::default()
 	};
-	List::new_from_element(Raster::new_cpu(image))
+	Raster::new_cpu(image)
 }
 
 /// Generates customizable procedural noise patterns.