Fast poisson sampling (#178)

Co-authored-by: ZeWaka <[email protected]>

Cargo.toml

@@ -52,7 +52,7 @@ serde = { version = "1.0", optional = true, features = ["derive"] }
 serde_json = { version = "1.0", optional = true }
 lazy_static = { version = "1.4", optional = true }
 once_cell = { version = "1.19", optional = true }
-mysql = { git = "https://github.com/ZeWaka/rust-mysql-simple.git", tag = "v25.0.1", default_features = false, optional = true }
+mysql = { git = "https://github.com/ZeWaka/rust-mysql-simple.git", tag = "v25.0.1", default-features = false, optional = true }
 dashmap = { version = "5.5", optional = true, features = ["rayon", "serde"] }
 zip = { version = "2.1.1", optional = true }
 rand = { version = "0.8", optional = true }
@@ -65,6 +65,7 @@ num-integer = { version = "0.1.46", optional = true }
 dmi = { version = "0.3.5", optional = true }
 tracy_full = { version = "1.8.0", optional = true }
 ammonia = { version = "4.0.0", optional = true }
+fast_poisson = { version = "0.5.2", optional = true, features = ["single_precision"]} # Higher versions have problems with x86 due to 'kiddo'.
 
 [features]
 default = [
@@ -106,6 +107,7 @@ all = [
     "hash",
     "iconforge",
     "pathfinder",
+    "poissonnoise",
     "redis_pubsub",
     "redis_reliablequeue",
     "unzip",
@@ -155,6 +157,7 @@ iconforge = [
     "twox-hash",
 ]
 pathfinder = ["num-integer", "pathfinding", "serde", "serde_json"]
+poissonnoise = ["fast_poisson"]
 redis_pubsub = ["flume", "redis", "serde", "serde_json"]
 redis_reliablequeue = ["flume", "redis", "serde", "serde_json"]
 unzip = ["zip", "jobs"]

README.md

@@ -111,6 +111,7 @@ Additional features are:
 * hash: Faster replacement for `md5`, support for SHA-1, SHA-256, and SHA-512. Requires OpenSSL on Linux.
 * iconforge: A much faster replacement for the spritesheet generation system used by [/tg/station].
 * pathfinder: An a* pathfinder used for finding the shortest path in a static node map. Not to be used for a non-static map.
+* poissonnoise: A way to generate a 2D poisson disk distribution ('blue noise'), which is relatively uniform.
 * redis_pubsub: Library for sending and receiving messages through Redis.
 * redis_reliablequeue: Library for using a reliable queue pattern through Redis.
 * unzip: Function to download a .zip from a URL and unzip it to a directory.

dmsrc/noise.dm

@@ -1 +1,15 @@
 #define rustg_noise_get_at_coordinates(seed, x, y) RUSTG_CALL(RUST_G, "noise_get_at_coordinates")(seed, x, y)
+
+/**
+ * Generates a 2D poisson disk distribution ('blue noise'), which is relatively uniform.
+ *
+ * params:
+ * 	`seed`: str
+ * 	`width`: int, width of the noisemap (see world.maxx)
+ * 	`length`: int, height of the noisemap (see world.maxy)
+ * 	`radius`: int, distance between points on the noisemap
+ *
+ * returns:
+ * 	a width*length length string of 1s and 0s representing a 2D poisson sample collapsed into a 1D string
+ */
+#define rustg_noise_poisson_map(seed, width, length, radius) RUSTG_CALL(RUST_G, "noise_poisson_map")(seed, width, length, radius)

src/lib.rs

@@ -34,6 +34,8 @@ pub mod log;
 pub mod noise_gen;
 #[cfg(feature = "pathfinder")]
 pub mod pathfinder;
+#[cfg(feature = "poissonnoise")]
+pub mod poissonnoise;
 #[cfg(feature = "redis_pubsub")]
 pub mod redis_pubsub;
 #[cfg(feature = "redis_reliablequeue")]

src/poissonnoise.rs

@@ -0,0 +1,41 @@
+use fast_poisson::Poisson2D;
+use std::fmt::Write;
+
+use crate::error::Result;
+
+byond_fn!(fn noise_poisson_map(seed, width, length, radius) {
+    get_poisson_map(seed, width, length, radius).ok()
+});
+
+fn get_poisson_map(
+    seed_as_str: &str,
+    width_as_str: &str,
+    length_as_str: &str,
+    radius_as_str: &str,
+) -> Result<String> {
+    let width = width_as_str.parse::<f32>()?;
+    let length = length_as_str.parse::<f32>()?;
+    let radius = radius_as_str.parse::<f32>()?;
+    let seed = seed_as_str.parse::<u64>()?;
+
+    let points: Vec<[f32; 2]> = Poisson2D::new()
+        .with_dimensions([width, length], radius)
+        .with_seed(seed)
+        .to_vec();
+
+    let mut output = String::new();
+    for y in 0..length as usize {
+        for x in 0..width as usize {
+            if points
+                .iter()
+                .any(|&point| point[0] as usize == x && point[1] as usize == y)
+            {
+                let _ = write!(output, "1");
+            } else {
+                let _ = write!(output, "0");
+            }
+        }
+    }
+
+    Ok(output)
+}