making sqare merging deterministic

Author: Sahil-Gupta584

node-graph/nodes/vector/src/generator_nodes.rs

@@ -187,113 +187,31 @@ fn star<T: AsU64>(
 }
 
 /// Generates a QR code from the input text.
-#[node_macro::node(category("Vector: Shape"))]
-fn qr_code(
-	_: impl Ctx,
-	_primary: (),
-	#[default("https://graphite.art")] text: String,
-	#[default(true)]
-	#[name("Merge Adjacent Tiles")]
-	merge: bool,
+#[node_macro::node(category("Vector: Shape"), name("QR Code"))]
+fn qr_code(_: impl Ctx, _primary: (), #[default("https://graphite.art")] text: String, #[default(false)] individual_squares: bool
 ) -> Table<Vector> {
 	let ecc = qrcodegen::QrCodeEcc::Medium;
 
 	let Ok(qr_code) = qrcodegen::QrCode::encode_text(&text, ecc) else {
 		return Table::default();
 	};
 
-	let size = qr_code.size();
+	let size = qr_code.size() as usize;
 	let mut vector = Vector::default();
-	let offset = DVec2::splat(0.0);
 
-	if merge {
-		use std::collections::{HashMap, HashSet, VecDeque};
-
-		let mut remaining: HashSet<(i32, i32)> = HashSet::new();
+	if individual_squares {
 		for y in 0..size {
 			for x in 0..size {
-				if qr_code.get_module(x, y) {
-					remaining.insert((x, y));
-				}
-			}
-		}
-
-		while let Some(&(start_x, start_y)) = remaining.iter().next() {
-			let mut island = HashSet::new();
-			let mut queue = VecDeque::new();
-			queue.push_back((start_x, start_y));
-			remaining.remove(&(start_x, start_y));
-
-			while let Some((x, y)) = queue.pop_front() {
-				island.insert((x, y));
-				for (dx, dy) in [(0, 1), (0, -1), (1, 0), (-1, 0)] {
-					let nx = x + dx;
-					let ny = y + dy;
-					if remaining.remove(&(nx, ny)) {
-						queue.push_back((nx, ny));
-					}
-				}
-			}
-
-			let mut island_edges = HashSet::new();
-			for &(x, y) in &island {
-				for (p1, p2) in [((x, y), (x + 1, y)), ((x + 1, y), (x + 1, y + 1)), ((x + 1, y + 1), (x, y + 1)), ((x, y + 1), (x, y))] {
-					if !island_edges.remove(&(p2, p1)) {
-						island_edges.insert((p1, p2));
-					}
-				}
-			}
-
-			let mut adjacency: HashMap<(i32, i32), Vec<(i32, i32)>> = HashMap::new();
-			for (p1, p2) in island_edges {
-				adjacency.entry(p1).or_default().push(p2);
-			}
-
-			while let Some(&start_point) = adjacency.keys().next() {
-				let mut loop_points = Vec::new();
-				let mut current = start_point;
-
-				loop {
-					loop_points.push(DVec2::new(current.0 as f64, current.1 as f64));
-					let next = adjacency.get_mut(&current).and_then(|n| n.pop()).unwrap();
-					if adjacency.get(&current).map_or(false, |n| n.is_empty()) {
-						adjacency.remove(&current);
-					}
-					current = next;
-					if current == start_point {
-						break;
-					}
-				}
-
-				if loop_points.len() > 2 {
-					let mut simplified = Vec::new();
-					for i in 0..loop_points.len() {
-						let prev = loop_points[(i + loop_points.len() - 1) % loop_points.len()];
-						let curr = loop_points[i];
-						let next = loop_points[(i + 1) % loop_points.len()];
-
-						if (curr - prev).perp_dot(next - curr).abs() > 1e-6 {
-							simplified.push(curr + offset);
-						}
-					}
-					if !simplified.is_empty() {
-						vector.append_subpath(subpath::Subpath::from_anchors(simplified, true), false);
-					}
-				}
-			}
-		}
-	} else {
-		for y in 0..size {
-			for x in 0..size {
-				if qr_code.get_module(x, y) {
-					let corner1 = offset + DVec2::new(x as f64, y as f64);
+				if qr_code.get_module(x as i32, y as i32) {
+					let corner1 = DVec2::new(x as f64, y as f64);
 					let corner2 = corner1 + DVec2::splat(1.);
 					vector.append_subpath(subpath::Subpath::new_rect(corner1, corner2), false);
 				}
 			}
 		}
+	} else {
+		crate::merge_qr_squares::merge_qr_squares(&qr_code, &mut vector);
 	}
-
 	Table::new_from_element(vector)
 }
 

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

@@ -1,5 +1,6 @@
 pub mod generator_nodes;
 pub mod instance;
+pub mod merge_qr_squares;
 pub mod vector_modification_nodes;
 mod vector_nodes;
 

node-graph/nodes/vector/src/merge_qr_squares.rs

@@ -0,0 +1,118 @@
+use glam::DVec2;
+use graphic_types::Vector;
+use std::collections::VecDeque;
+use vector_types::subpath;
+
+pub fn merge_qr_squares(qr_code: &qrcodegen::QrCode, vector: &mut Vector) {
+	let size = qr_code.size() as usize;
+
+	// 0 = empty
+	// 1 = black, unvisited
+	// 2 = black, current island
+	let mut remaining = vec![vec![0u8; size]; size];
+
+	for y in 0..size {
+		for x in 0..size {
+			if qr_code.get_module(x as i32, y as i32) {
+				remaining[y][x] = 1;
+			}
+		}
+	}
+
+	for y in 0..size {
+		for x in 0..size {
+			if remaining[y][x] != 1 {
+				continue;
+			}
+
+			// fill island
+			let mut island = Vec::new();
+			let mut queue = VecDeque::new();
+			queue.push_back((x, y));
+			remaining[y][x] = 2;
+
+			while let Some((ix, iy)) = queue.pop_front() {
+				island.push((ix, iy));
+
+				for (dx, dy) in [(0, 1), (0, -1), (1, 0), (-1, 0)] {
+					let nx = ix as i32 + dx;
+					let ny = iy as i32 + dy;
+
+					if nx >= 0 && nx < size as i32 && ny >= 0 && ny < size as i32 && remaining[ny as usize][nx as usize] == 1 {
+						remaining[ny as usize][nx as usize] = 2;
+						queue.push_back((nx as usize, ny as usize));
+					}
+				}
+			}
+
+			// boundary detection
+			let mut outbound = vec![vec![0u8; size + 1]; size + 1];
+
+			for &(ix, iy) in &island {
+				if iy == 0 || remaining[iy - 1][ix] != 2 {
+					outbound[iy][ix] |= 1 << 0;
+				}
+				if ix == size - 1 || remaining[iy][ix + 1] != 2 {
+					outbound[iy][ix + 1] |= 1 << 1;
+				}
+				if iy == size - 1 || remaining[iy + 1][ix] != 2 {
+					outbound[iy + 1][ix + 1] |= 1 << 2;
+				}
+				if ix == 0 || remaining[iy][ix - 1] != 2 {
+					outbound[iy + 1][ix] |= 1 << 3;
+				}
+			}
+
+			// tracing loops
+			for vy in 0..=size {
+				for vx in 0..=size {
+					while outbound[vy][vx] != 0 {
+						let mut dir = outbound[vy][vx].trailing_zeros() as usize;
+						let start = (vx, vy);
+						let mut current = start;
+						let mut points = Vec::new();
+
+						loop {
+							points.push(DVec2::new(current.0 as f64, current.1 as f64));
+							outbound[current.1][current.0] &= !(1 << dir);
+
+							current = match dir {
+								0 => (current.0 + 1, current.1),
+								1 => (current.0, current.1 + 1),
+								2 => (current.0 - 1, current.1),
+								3 => (current.0, current.1 - 1),
+								_ => unreachable!(),
+							};
+
+							if current == start {
+								break;
+							}
+							dir = outbound[current.1][current.0].trailing_zeros() as usize;
+						}
+
+						if points.len() > 2 {
+							let mut simplified = Vec::new();
+							for i in 0..points.len() {
+								let prev = points[(i + points.len() - 1) % points.len()];
+								let curr = points[i];
+								let next = points[(i + 1) % points.len()];
+								if (curr - prev).perp_dot(next - curr).abs() > 1e-6 {
+									simplified.push(curr);
+								}
+							}
+
+							if !simplified.is_empty() {
+								vector.append_subpath(subpath::Subpath::from_anchors(simplified, true), false);
+							}
+						}
+					}
+				}
+			}
+
+			// marking island as processed
+			for &(ix, iy) in &island {
+				remaining[iy][ix] = 0;
+			}
+		}
+	}
+}