pointgrid-rs

High-performance Rust implementation of deterministic point-grid alignment and numerical primitives for semantic maps.

Overview

pointgrid-rs provides fast, deterministic algorithms for:

• Point-grid alignment: Maps 2D points to a checkerboard grid pattern
• 1D uniform filtering: Scipy-compatible filtering with reflect/wrap boundary modes
• Linear sum assignment: Optimal assignment solver for cost matrices

This package is a drop-in replacement for the Python pointgrid package, offering 700x faster performance on large datasets.

Installation

pip install pointgrid-rs

Usage

Point-Grid Alignment

import numpy as np
import pointgrid_rs

points = np.array([[0.0, 0.0], [0.1, 0.2], [0.9, 1.0], [0.4, 0.6]])
aligned = pointgrid_rs.align_points_to_grid(points)
# Returns: array([[0.12857143, 0.        ],
#                 [0.        , 0.14285714],
#                 [0.64285714, 0.85714286],
#                 [0.38571429, 0.57142857]])

Uniform Filter

values = np.array([1.0, 2.0, 3.0, 4.0])
filtered = pointgrid_rs.uniform_filter1d(values, [4], size=3, axis=0, mode='reflect')
# Returns: array([1.33333333, 2.        , 3.        , 3.66666667])

Linear Sum Assignment

costs = np.array([[4.0, 1.0, 3.0],
                  [2.0, 0.0, 5.0],
                  [3.0, 2.0, 2.0]])
assignment = pointgrid_rs.linear_sum_assignment(costs)
# Returns: array([1, 0, 2])

Performance

Benchmark on 10,000 points:

Speedup: 700x faster

API Reference

align_points_to_grid(points: np.ndarray) -> np.ndarray

Aligns 2D points to a deterministic checkerboard grid pattern.

Parameters:

• points: numpy array of shape (n, 2) containing 2D coordinates

Returns:

• numpy array of shape (n, 2) with aligned coordinates

uniform_filter1d(values: np.ndarray, shape: list, size: int, axis: int, mode: str) -> np.ndarray

Applies a uniform (box) filter along a specified axis with boundary handling.

Parameters:

• values: 1D numpy array of values
• shape: list specifying the shape of the multi-dimensional array
• size: size of the uniform filter kernel
• axis: axis along which to apply the filter
• mode: boundary mode, either 'reflect' or 'wrap'

Returns:

• 1D numpy array with filtered values

linear_sum_assignment(costs: np.ndarray) -> np.ndarray

Solves the linear sum assignment problem (Hungarian algorithm).

Parameters:

• costs: 2D numpy array of shape (n, n) containing the cost matrix

Returns:

• 1D numpy array where result[i] is the column assigned to row i

License

MIT

Source

https://github.com/neotree/digger-solo