pointgrid-rs 0.1.0__tar.gz

pointgrid_rs-0.1.0/Cargo.lock

@@ -0,0 +1,309 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "lapjv"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f66c977eaa63543f7d7bae335c66c46657ca973091340aff72ff141a50c0bfb3"
+dependencies = [
+ "log",
+ "ndarray",
+ "num-traits",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.189"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+
+[[package]]
+name = "log"
+version = "0.4.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
+
+[[package]]
+name = "matrixmultiply"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f607c237553f086e7043417a51df26b2eb899d3caff94e6a67592ff992fedc7"
+dependencies = [
+ "autocfg",
+ "rawpointer",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "ndarray"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "882ed72dce9365842bf196bdeedf5055305f11fc8c03dee7bb0194a6cad34841"
+dependencies = [
+ "matrixmultiply",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "portable-atomic",
+ "portable-atomic-util",
+ "rawpointer",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "numpy"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edb929bc0da91a4d85ed6c0a84deaa53d411abfb387fc271124f91bf6b89f14e"
+dependencies = [
+ "libc",
+ "ndarray",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "pyo3",
+ "rustc-hash",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "pointgrid-rs"
+version = "0.1.0"
+dependencies = [
+ "lapjv",
+ "ndarray",
+ "numpy",
+ "pyo3",
+ "thiserror",
+]
+
+[[package]]
+name = "portable-atomic"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d20d5497ef88037a52ff98267d066e7f11fcc5e99bbfbd58a42336193aacec3"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618"
+dependencies = [
+ "portable-atomic",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f402062616ab18202ae8319da13fa4279883a2b8a9d9f83f20dbade813ce1884"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b14b5775b5ff446dd1056212d778012cbe8a0fbffd368029fd9e25b514479c38"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ab5bcf04a2cdcbb50c7d6105de943f543f9ed92af55818fd17b660390fc8636"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fd24d897903a9e6d80b968368a34e1525aeb719d568dba8b3d4bfa5dc67d453"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36c011a03ba1e50152b4b394b479826cad97e7a21eb52df179cd91ac411cbfbe"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rawpointer"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"

pointgrid_rs-0.1.0/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "pointgrid-rs"
+version = "0.1.0"
+edition = "2021"
+description = "Native point-grid and numerical primitives for Digger Solo"
+
+[lib]
+name = "pointgrid_rs"
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+lapjv = "0.3"
+ndarray = "0.16"
+thiserror = "1"
+pyo3 = { version = "0.22", features = ["extension-module"] }
+numpy = "0.22"

pointgrid_rs-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: pointgrid-rs
+Version: 0.1.0
+Requires-Dist: numpy
+Summary: Native point-grid and numerical primitives for Digger Solo
+License: MIT
+Requires-Python: >=3.8

pointgrid_rs-0.1.0/pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "pointgrid-rs"
+version = "0.1.0"
+description = "Native point-grid and numerical primitives for Digger Solo"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+dependencies = ["numpy"]
+
+[tool.maturin]
+features = ["pyo3/extension-module"]

pointgrid_rs-0.1.0/src/lib.rs

@@ -0,0 +1,442 @@
+//! Deterministic checkerboard point-grid alignment used by semantic maps.
+
+use ndarray::Array2;
+use numpy::{PyArray1, PyArray2, PyReadonlyArray1, PyReadonlyArray2, IntoPyArray};
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+use thiserror::Error;
+
+const DEFAULT_GRID_FILL: f64 = 0.1;
+
+#[derive(Debug, Error, PartialEq)]
+pub enum PointGridError {
+    #[error("{0}")]
+    InvalidInput(String),
+    #[error("linear assignment failed: {0}")]
+    Assignment(String),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum BoundaryMode {
+    Reflect,
+    Wrap,
+}
+
+pub fn align_points_to_grid(points: &[[f64; 2]]) -> Result<Vec<[f64; 2]>, PointGridError> {
+    if points.iter().flatten().any(|value| !value.is_finite()) {
+        return Err(PointGridError::InvalidInput(
+            "points must contain only finite values".to_string(),
+        ));
+    }
+    if points.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let side = ((points.len() as f64 / DEFAULT_GRID_FILL).sqrt().ceil() as usize).max(2);
+    let x_bounds = non_degenerate_bounds(points.iter().map(|point| point[0]));
+    let y_bounds = non_degenerate_bounds(points.iter().map(|point| point[1]));
+    let x_step = (x_bounds.1 - x_bounds.0) / side as f64;
+    let y_step = (y_bounds.1 - y_bounds.0) / side as f64;
+    let mut open = vec![false; side * side];
+
+    for row in 0..side {
+        for column in 0..side {
+            open[row * side + column] = (row + column) % 2 == 1;
+        }
+    }
+
+    let mut aligned = vec![[0.0; 2]; points.len()];
+    for (point_index, point) in points.iter().enumerate() {
+        let mut radius_x = x_step;
+        let mut radius_y = y_step;
+        loop {
+            if let Some(slot) = first_open_slot(
+                &open, side, x_bounds.0, y_bounds.0, x_step, y_step, *point, radius_x, radius_y,
+            ) {
+                open[slot] = false;
+                let row = slot / side;
+                let column = slot % side;
+                aligned[point_index] = [
+                    x_bounds.0 + column as f64 * x_step,
+                    y_bounds.0 + row as f64 * y_step,
+                ];
+                break;
+            }
+            radius_x *= 2.0;
+            radius_y *= 2.0;
+        }
+    }
+    Ok(aligned)
+}
+
+fn non_degenerate_bounds(values: impl Iterator<Item = f64>) -> (f64, f64) {
+    let (minimum, maximum) = values.fold(
+        (f64::INFINITY, f64::NEG_INFINITY),
+        |(minimum, maximum), value| (minimum.min(value), maximum.max(value)),
+    );
+    if minimum == maximum {
+        return (minimum - 0.5, maximum + 0.5);
+    }
+    (minimum, maximum)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn first_open_slot(
+    open: &[bool],
+    side: usize,
+    x_minimum: f64,
+    y_minimum: f64,
+    x_step: f64,
+    y_step: f64,
+    point: [f64; 2],
+    radius_x: f64,
+    radius_y: f64,
+) -> Option<usize> {
+    for row in 0..side {
+        let y = y_minimum + row as f64 * y_step;
+        if y < point[1] - radius_y || y > point[1] + radius_y {
+            continue;
+        }
+        for column in 0..side {
+            let slot = row * side + column;
+            let x = x_minimum + column as f64 * x_step;
+            if open[slot] && x >= point[0] - radius_x && x <= point[0] + radius_x {
+                return Some(slot);
+            }
+        }
+    }
+    None
+}
+
+pub fn uniform_filter1d(
+    values: &[f64],
+    shape: &[usize],
+    size: usize,
+    axis: usize,
+    mode: BoundaryMode,
+) -> Result<Vec<f64>, PointGridError> {
+    if shape.is_empty() || axis >= shape.len() {
+        return Err(PointGridError::InvalidInput(
+            "axis must identify an existing array dimension".to_string(),
+        ));
+    }
+    if size == 0 {
+        return Err(PointGridError::InvalidInput(
+            "filter size must be greater than zero".to_string(),
+        ));
+    }
+    let expected_len = shape
+        .iter()
+        .try_fold(1usize, |product, dimension| product.checked_mul(*dimension));
+    if expected_len != Some(values.len()) || shape[axis] == 0 {
+        return Err(PointGridError::InvalidInput(
+            "shape does not match a non-empty input array".to_string(),
+        ));
+    }
+    if values.iter().any(|value| !value.is_finite()) {
+        return Err(PointGridError::InvalidInput(
+            "values must contain only finite numbers".to_string(),
+        ));
+    }
+
+    let axis_len = shape[axis];
+    let inner_stride = shape[axis + 1..].iter().product::<usize>();
+    let outer_count = values.len() / (axis_len * inner_stride);
+    let mut filtered = vec![0.0; values.len()];
+
+    for outer in 0..outer_count {
+        for inner in 0..inner_stride {
+            let base = outer * axis_len * inner_stride + inner;
+            for position in 0..axis_len {
+                let start = position as isize - (size / 2) as isize;
+                let sum = (0..size)
+                    .map(|offset| boundary_index(start + offset as isize, axis_len, mode))
+                    .map(|source| values[base + source * inner_stride])
+                    .sum::<f64>();
+                filtered[base + position * inner_stride] = sum / size as f64;
+            }
+        }
+    }
+    Ok(filtered)
+}
+
+fn boundary_index(index: isize, len: usize, mode: BoundaryMode) -> usize {
+    if len == 1 {
+        return 0;
+    }
+    match mode {
+        BoundaryMode::Wrap => index.rem_euclid(len as isize) as usize,
+        BoundaryMode::Reflect => {
+            let period = (2 * len) as isize;
+            let reflected = index.rem_euclid(period);
+            if reflected < len as isize {
+                reflected as usize
+            } else {
+                (period - reflected - 1) as usize
+            }
+        }
+    }
+}
+
+pub fn linear_sum_assignment(
+    costs: &[f64],
+    rows: usize,
+    columns: usize,
+) -> Result<Vec<usize>, PointGridError> {
+    if rows == 0 || rows != columns || costs.len() != rows * columns {
+        return Err(PointGridError::InvalidInput(
+            "cost matrix must be a non-empty square matrix".to_string(),
+        ));
+    }
+    if costs.iter().any(|cost| !cost.is_finite()) {
+        return Err(PointGridError::InvalidInput(
+            "cost matrix must contain only finite values".to_string(),
+        ));
+    }
+    let matrix = Array2::from_shape_vec((rows, columns), costs.to_vec())
+        .map_err(|error| PointGridError::InvalidInput(error.to_string()))?;
+    let (columns_by_row, _) =
+        lapjv::lapjv(&matrix).map_err(|error| PointGridError::Assignment(error.to_string()))?;
+    Ok(columns_by_row)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashSet;
+
+    #[test]
+    fn grid_alignment_is_deterministic_unique_and_ordered() {
+        let points = [[0.0, 0.0], [0.1, 0.2], [0.9, 1.0], [0.4, 0.6]];
+        let first = align_points_to_grid(&points).unwrap();
+        let second = align_points_to_grid(&points).unwrap();
+        assert_eq!(first, second);
+        assert_eq!(first.len(), points.len());
+        let unique: HashSet<_> = first
+            .iter()
+            .map(|point| (point[0].to_bits(), point[1].to_bits()))
+            .collect();
+        assert_eq!(unique.len(), points.len());
+        assert!(first.iter().all(|point| point[0] >= 0.0 && point[0] <= 0.9));
+        assert!(first.iter().all(|point| point[1] >= 0.0 && point[1] <= 1.0));
+    }
+
+    #[test]
+    fn grid_alignment_handles_degenerate_axes() {
+        let result = align_points_to_grid(&[[2.0, 4.0], [2.0, 5.0], [2.0, 6.0]]).unwrap();
+        assert!(result.iter().flatten().all(|value| value.is_finite()));
+        assert_eq!(result.len(), 3);
+    }
+
+    #[test]
+    fn grid_alignment_matches_seeded_python_golden_output() {
+        let points = [[0.0, 0.0], [0.1, 0.2], [0.9, 1.0], [0.4, 0.6]];
+        let expected = [
+            [0.1285714285714286, 0.0],
+            [0.0, 0.14285714285714285],
+            [0.6428571428571429, 0.8571428571428571],
+            [0.3857142857142858, 0.5714285714285714],
+        ];
+        let actual = align_points_to_grid(&points).unwrap();
+        assert!(actual.iter().zip(expected).all(|(actual, expected)| {
+            (actual[0] - expected[0]).abs() < 1e-12 && (actual[1] - expected[1]).abs() < 1e-12
+        }));
+    }
+
+    #[test]
+    fn grid_alignment_rejects_non_finite_values() {
+        assert!(align_points_to_grid(&[[f64::NAN, 0.0]]).is_err());
+    }
+
+    #[test]
+    fn uniform_filter_matches_scipy_golden_values() {
+        let values = [1.0, 2.0, 3.0, 4.0];
+        assert_eq!(
+            uniform_filter1d(&values, &[4], 3, 0, BoundaryMode::Reflect).unwrap(),
+            vec![4.0 / 3.0, 2.0, 3.0, 11.0 / 3.0]
+        );
+        assert_eq!(
+            uniform_filter1d(&values, &[4], 3, 0, BoundaryMode::Wrap).unwrap(),
+            vec![7.0 / 3.0, 2.0, 3.0, 8.0 / 3.0]
+        );
+    }
+
+    #[test]
+    fn uniform_filter_supports_multiple_axes_and_even_kernels() {
+        let values = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
+        assert_eq!(
+            uniform_filter1d(&values, &[2, 3], 2, 1, BoundaryMode::Reflect).unwrap(),
+            vec![1.0, 1.5, 2.5, 4.0, 4.5, 5.5]
+        );
+        assert_eq!(
+            uniform_filter1d(&values, &[2, 3], 2, 0, BoundaryMode::Wrap).unwrap(),
+            vec![2.5, 3.5, 4.5, 2.5, 3.5, 4.5]
+        );
+    }
+
+    #[test]
+    fn uniform_filter_matches_multidimensional_scipy_fixtures() {
+        let values = (1..=12).map(f64::from).collect::<Vec<_>>();
+        let cases = [
+            (
+                0,
+                2,
+                BoundaryMode::Reflect,
+                vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0],
+            ),
+            (
+                1,
+                3,
+                BoundaryMode::Reflect,
+                vec![
+                    1.6666666666666667,
+                    2.6666666666666665,
+                    3.0,
+                    4.0,
+                    4.333333333333333,
+                    5.333333333333333,
+                    7.666666666666667,
+                    8.666666666666666,
+                    9.0,
+                    10.0,
+                    10.333333333333334,
+                    11.333333333333334,
+                ],
+            ),
+            (
+                2,
+                5,
+                BoundaryMode::Reflect,
+                vec![1.6, 1.4, 3.6, 3.4, 5.6, 5.4, 7.6, 7.4, 9.6, 9.4, 11.6, 11.4],
+            ),
+            (
+                0,
+                3,
+                BoundaryMode::Wrap,
+                vec![5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
+            ),
+            (
+                1,
+                2,
+                BoundaryMode::Wrap,
+                vec![
+                    3.0, 4.0, 2.0, 3.0, 4.0, 5.0, 9.0, 10.0, 8.0, 9.0, 10.0, 11.0,
+                ],
+            ),
+            (
+                2,
+                4,
+                BoundaryMode::Wrap,
+                vec![1.5, 1.5, 3.5, 3.5, 5.5, 5.5, 7.5, 7.5, 9.5, 9.5, 11.5, 11.5],
+            ),
+        ];
+        for (axis, size, mode, expected) in cases {
+            let actual = uniform_filter1d(&values, &[2, 3, 2], size, axis, mode).unwrap();
+            assert!(actual
+                .iter()
+                .zip(expected)
+                .all(|(actual, expected)| (actual - expected).abs() < 1e-12));
+        }
+    }
+
+    #[test]
+    fn assignment_finds_the_optimal_permutation() {
+        let costs = [4.0, 1.0, 3.0, 2.0, 0.0, 5.0, 3.0, 2.0, 2.0];
+        assert_eq!(linear_sum_assignment(&costs, 3, 3).unwrap(), vec![1, 0, 2]);
+    }
+
+    #[test]
+    fn malformed_assignment_matrices_are_rejected() {
+        assert!(linear_sum_assignment(&[1.0, 2.0], 1, 2).is_err());
+        assert!(linear_sum_assignment(&[], 0, 0).is_err());
+    }
+
+    #[test]
+    fn assignment_handles_ties_and_flas_sized_matrices() {
+        let tied = linear_sum_assignment(&[0.0; 16], 4, 4).unwrap();
+        let mut sorted = tied.clone();
+        sorted.sort_unstable();
+        assert_eq!(sorted, vec![0, 1, 2, 3]);
+
+        let side = 49usize;
+        let costs = (0..side)
+            .flat_map(|row| (0..side).map(move |column| row.abs_diff(column) as f64))
+            .collect::<Vec<_>>();
+        assert_eq!(
+            linear_sum_assignment(&costs, side, side).unwrap(),
+            (0..side).collect::<Vec<_>>()
+        );
+    }
+}
+
+#[pymodule]
+fn pointgrid_rs(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(py_align_points_to_grid, m)?)?;
+    m.add_function(wrap_pyfunction!(py_uniform_filter1d, m)?)?;
+    m.add_function(wrap_pyfunction!(py_linear_sum_assignment, m)?)?;
+    Ok(())
+}
+
+#[pyfunction(name = "align_points_to_grid")]
+fn py_align_points_to_grid<'py>(
+    py: Python<'py>,
+    points: PyReadonlyArray2<'py, f64>,
+) -> PyResult<Bound<'py, PyArray2<f64>>> {
+    let points_array = points.as_array();
+    let (n, cols) = (points_array.shape()[0], points_array.shape()[1]);
+
+    if cols != 2 {
+        return Err(PyValueError::new_err(
+            "points must have shape (n, 2)",
+        ));
+    }
+
+    let points_vec: Vec<[f64; 2]> = (0..n)
+        .map(|i| [points_array[[i, 0]], points_array[[i, 1]]])
+        .collect();
+
+    let result = align_points_to_grid(&points_vec).map_err(|e| PyValueError::new_err(e.to_string()))?;
+
+    let result_flat: Vec<f64> = result.iter().flat_map(|p| [p[0], p[1]]).collect();
+    let result_2d = ndarray::Array2::from_shape_vec((n, 2), result_flat)
+        .map_err(|e| PyValueError::new_err(format!("array creation failed: {}", e)))?;
+
+    Ok(result_2d.into_pyarray_bound(py))
+}
+
+#[pyfunction(name = "uniform_filter1d")]
+fn py_uniform_filter1d<'py>(
+    py: Python<'py>,
+    values: PyReadonlyArray1<'py, f64>,
+    shape: Vec<usize>,
+    size: usize,
+    axis: usize,
+    mode: &str,
+) -> PyResult<Bound<'py, PyArray1<f64>>> {
+    let boundary_mode = match mode {
+        "reflect" => BoundaryMode::Reflect,
+        "wrap" => BoundaryMode::Wrap,
+        _ => return Err(PyValueError::new_err("mode must be 'reflect' or 'wrap'")),
+    };
+
+    let result = uniform_filter1d(values.as_slice()?, &shape, size, axis, boundary_mode)
+        .map_err(|e| PyValueError::new_err(e.to_string()))?;
+
+    Ok(result.into_pyarray_bound(py))
+}
+
+#[pyfunction(name = "linear_sum_assignment")]
+fn py_linear_sum_assignment<'py>(
+    py: Python<'py>,
+    costs: PyReadonlyArray2<'py, f64>,
+) -> PyResult<Bound<'py, PyArray1<usize>>> {
+    let costs_array = costs.as_array();
+    let (rows, columns) = (costs_array.shape()[0], costs_array.shape()[1]);
+
+    let costs_vec: Vec<f64> = costs_array.iter().copied().collect();
+
+    let result = linear_sum_assignment(&costs_vec, rows, columns)
+        .map_err(|e| PyValueError::new_err(e.to_string()))?;
+
+    Ok(result.into_pyarray_bound(py))
+}