squarenet 0.1.0__tar.gz

squarenet-0.1.0/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

squarenet-0.1.0/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: squarenet
+Version: 0.1.0
+Summary: Sparse local operations for point clouds in any dimension.
+Author-email: ArmanddeCacqueray <armanddecacqueray@sfr.fr>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Provides-Extra: demo
+Requires-Dist: geopandas; extra == "demo"
+Requires-Dist: shapely; extra == "demo"
+Dynamic: license-file
+
+# SquareNet
+
+**SquareNet** is a lightweight framework for mapping unstructured point clouds into structured N-dimensional grids, enabling fast and efficient local operations.
+
+## ✨ Key Idea
+
+SquareNet builds a bijective mapping between point indices and a structured grid:
+
+* **Bijection**: each point maps to exactly one grid cell
+* **Neighborhood preservation**: nearby points remain close in the grid
+
+This allows replacing expensive spatial queries (k-NN, radius search) with simple **array slicing**.
+
+---
+
+## 🚀 Features
+
+* Fast point cloud → grid mapping
+* Invertible transformation
+* Efficient local neighborhood operations
+* Sparse Gram matrix computation via sliding windows
+* NumPy-friendly (no heavy dependencies required)
+
+---
+
+## 📦 Installation
+
+```bash
+pip install squarenet
+```
+
+---
+
+## 🧠 Basic Usage
+
+```python
+from squarenet import SquareNet
+
+sqnet = SquareNet(IJ=(L, W, H, ...), max_iter = 100)
+
+# Original data: (N, D)
+points = np.random.rand(N, D)
+Sqnet.fit(points)
+
+# Map (N, *) to the grid: (L, W, H, ..., *)
+sqX = sqnet.map(X)
+
+# Back to original ordering
+X_rec = sqnet.invert_map(sqX)
+```
+
+---
+
+## 🔬 Local Processing Example
+
+Compute a **local (sparse) Gram matrix** using a sliding window:
+
+```python
+G = sqnet.gram(X, ws=(5, 5))
+```
+
+Instead of computing a full `(N × N)` matrix, SquareNet only computes interactions within local neighborhoods.
+
+---
+
+## 🗺️ Demo Dataset
+
+A small demo dataset (France map) is included:
+
+```python
+Sqnet.fit("france")
+```
+
+---
+
+## 🧱 Project Structure
+
+```
+src/
+  squarenet/
+    __init__.py
+    core.py
+    utils.py
+    data/france.geojson
+```
+
+---
+
+## 🎯 Why SquareNet?
+
+Traditional point cloud pipelines rely on:
+
+* k-NN search (O(N log N))
+* irregular memory access
+* poor GPU utilization
+
+SquareNet enables:
+
+* **O(N)** local operations
+* contiguous memory access
+* vectorized operations on a sliding window
+
+---
+
+## 📈 Use Cases
+
+* Point cloud processing
+* Graph-to-grid transformations
+* Fast kernel methods
+* Local feature aggregation
+* Deep learning preprocessing
+
+---
+
+## 🛠️ Development
+
+```bash
+git clone https://github.com/ArmanddeCacqueray/SquareNet
+cd squarenet
+pip install -e .
+```
+
+---
+
+## 📄 License
+
+MIT License
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome. Please open an issue or submit a pull request.
+

squarenet-0.1.0/README.md

@@ -0,0 +1,134 @@
+# SquareNet
+
+**SquareNet** is a lightweight framework for mapping unstructured point clouds into structured N-dimensional grids, enabling fast and efficient local operations.
+
+## ✨ Key Idea
+
+SquareNet builds a bijective mapping between point indices and a structured grid:
+
+* **Bijection**: each point maps to exactly one grid cell
+* **Neighborhood preservation**: nearby points remain close in the grid
+
+This allows replacing expensive spatial queries (k-NN, radius search) with simple **array slicing**.
+
+---
+
+## 🚀 Features
+
+* Fast point cloud → grid mapping
+* Invertible transformation
+* Efficient local neighborhood operations
+* Sparse Gram matrix computation via sliding windows
+* NumPy-friendly (no heavy dependencies required)
+
+---
+
+## 📦 Installation
+
+```bash
+pip install squarenet
+```
+
+---
+
+## 🧠 Basic Usage
+
+```python
+from squarenet import SquareNet
+
+sqnet = SquareNet(IJ=(L, W, H, ...), max_iter = 100)
+
+# Original data: (N, D)
+points = np.random.rand(N, D)
+Sqnet.fit(points)
+
+# Map (N, *) to the grid: (L, W, H, ..., *)
+sqX = sqnet.map(X)
+
+# Back to original ordering
+X_rec = sqnet.invert_map(sqX)
+```
+
+---
+
+## 🔬 Local Processing Example
+
+Compute a **local (sparse) Gram matrix** using a sliding window:
+
+```python
+G = sqnet.gram(X, ws=(5, 5))
+```
+
+Instead of computing a full `(N × N)` matrix, SquareNet only computes interactions within local neighborhoods.
+
+---
+
+## 🗺️ Demo Dataset
+
+A small demo dataset (France map) is included:
+
+```python
+Sqnet.fit("france")
+```
+
+---
+
+## 🧱 Project Structure
+
+```
+src/
+  squarenet/
+    __init__.py
+    core.py
+    utils.py
+    data/france.geojson
+```
+
+---
+
+## 🎯 Why SquareNet?
+
+Traditional point cloud pipelines rely on:
+
+* k-NN search (O(N log N))
+* irregular memory access
+* poor GPU utilization
+
+SquareNet enables:
+
+* **O(N)** local operations
+* contiguous memory access
+* vectorized operations on a sliding window
+
+---
+
+## 📈 Use Cases
+
+* Point cloud processing
+* Graph-to-grid transformations
+* Fast kernel methods
+* Local feature aggregation
+* Deep learning preprocessing
+
+---
+
+## 🛠️ Development
+
+```bash
+git clone https://github.com/ArmanddeCacqueray/SquareNet
+cd squarenet
+pip install -e .
+```
+
+---
+
+## 📄 License
+
+MIT License
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome. Please open an issue or submit a pull request.
+

squarenet-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "squarenet"
+version = "0.1.0"
+description = "Sparse local operations for point clouds in any dimension."
+authors = [{ name = "ArmanddeCacqueray", email = "armanddecacqueray@sfr.fr" }]
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "numpy",
+    "matplotlib"
+]
+
+[project.optional-dependencies]
+demo = [
+    "geopandas",
+    "shapely"
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"squarenet" = ["data/*.json"]

squarenet-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

squarenet-0.1.0/src/squarenet/__init__.py

@@ -0,0 +1,5 @@
+from .core import SquareNet
+from .utils import checkerboard, initpoint, grid_disorder, gram
+
+__all__ = ["squarenet"]
+__version__ = "0.1.0"

squarenet-0.1.0/src/squarenet/core.py

@@ -0,0 +1,133 @@
+import numpy as np
+from .utils import initpoint, grid_disorder, checkerboard, gram
+
+class SquareNet:
+    """
+    An iterative grid-straightening algorithm that untangles a D-dimensional mesh 
+    by sorting nodes along each spatial axis to enforce a structured ordering.
+    
+    The grid is represented as an (I, J, ..., D) array, where D is the number of spatial dimensions.
+    Each iteration attempts to minimize disorder along each dimension independently.
+    """
+    
+    def __init__(self, IJ=(100, 100), max_iter=100):
+        """
+        Initialize the SquareNet.
+
+        Args:
+            IJ (tuple): Grid dimensions (Rows, Cols, ...). Supports any number of dimensions.
+            max_iter (int): Maximum number of straightening iterations.
+        """
+        self.IJ = tuple(IJ)
+        self.D = len(self.IJ)  # Spatial dimensions (x, y, z,...)
+        self.N = np.prod(IJ)
+        self.max_iter = max_iter
+        self.learning_curve = []
+        
+        # Internal state
+        self.points = None     # Points as given by the user
+        self.net = None        # Grid with attached original indices
+        self.mapID = None      # Permutation map after sorting
+
+    def map(self, X):
+        """
+        Reorders any input array according to the optimized grid structure.
+
+        Args:
+            X (np.ndarray): Array of shape (N, ...) to be remapped.
+            
+        Returns:
+            np.ndarray: Reshaped and reordered array of shape (*IJ, ...).
+        """
+        return X[self.mapID].reshape(*self.IJ, *X.shape[1:])
+
+    def invert_map(self, X):
+        """
+        Restores the original ordering from the grid representation.
+
+        Args:
+            sqX (np.ndarray): Array of shape (*IJ, ...)
+
+        Returns:
+            np.ndarray: Array of shape (N, ...)
+        """
+        return (X.reshape(-1, *X.shape[len(self.IJ):]))[self.inv_mapID]
+
+    def fit(self, points):
+        """
+        Fit the grid to a set of points in D dimensions.
+
+        Args:
+            points (np.ndarray or str): Array of shape (N, D) or a method name supported
+                                        by .utils.initpoint.
+        """
+        if isinstance(points, str):
+            points = initpoint(method=points, size=(self.N, self.D))
+        
+        self.points = points
+        self.learning_curve = []
+        
+        N, D = points.shape
+        assert N == self.N, f"Input points ({N}) must match grid size {self.N}"
+        assert D == self.D, f"Input points dimension ({D}) must match D={self.D}"
+
+        # Attach an ID to each point for tracking during swaps
+        indexed_points = np.concatenate([points, np.arange(N)[:, None]], axis=-1)
+        
+        # Reshape into structured grid: (*IJ, D+1)
+        self.net = indexed_points.reshape(*self.IJ, self.D + 1)
+
+        # Iteratively sort along each spatial axis
+        for k in range(self.max_iter):
+            error = self.sort_increasing()
+            if error ==0:
+                print(f"succesfully sorted at step {k}")
+                break
+
+        # Extract permutation map and clean the coordinate grid
+        self.mapID = self.net[..., -1].astype(int).ravel()
+        self.inv_mapID = np.empty_like(self.mapID)
+        self.inv_mapID[self.mapID] = np.arange(len(self.mapID))
+        self.net = self.net[..., :-1]
+
+    def sort_increasing(self):
+        """
+        Aligns the grid by sorting nodes along each spatial axis.
+        Ensures that the points are generally ordered along all dimensions.
+        """
+        for axis in range(self.D):
+            # np.argsort along the current spatial axis
+            # Keep the last dimension (original index) attached
+            flat_axis = axis
+            idx = np.argsort(self.net[..., flat_axis], axis=axis)
+            # Expand idx to match last dimension for np.take_along_axis
+            idx_expanded = np.expand_dims(idx, axis=-1)
+            self.net = np.take_along_axis(self.net, idx_expanded.repeat(self.D + 1, axis=-1), axis=axis)
+
+        error = grid_disorder(self.net[..., :-1])
+        self.learning_curve.append(error)
+        return(error)
+    
+    def checkerboard(self, scales= [2, 4, 8, 16]):
+        """
+        plot the net as a chekerboard at different scales
+        """
+        assert self.D == 2, "only valid in 2D"
+        checkerboard(self.net, scales)
+
+    def gram(self, X, ws=5):
+        """
+        Compute a sparse Gram matrix using local neighborhoods within a window.
+
+        Args:
+            X (np.ndarray): Input features of shape (N, C)
+            ws (int or sequence): Half window size per dimension.
+                                If int → same for all dims
+                                If sequence → one per grid dim
+
+        Returns:
+            np.ndarray: Sparse Gram matrix of shape (N, K)
+        """
+
+        return gram(self, X, ws)
+

squarenet-0.1.0/src/squarenet/utils.py

@@ -0,0 +1,148 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from numpy.lib.stride_tricks import sliding_window_view
+from importlib import resources
+
+def checkerboard(grid, scales):
+    n = grid.shape[0]
+    I, J = np.arange(n)[:, None], np.arange(n)[None, :]
+
+    fig, axes = plt.subplots(2, 2, figsize=(8, 8))  # grille 2x2
+
+    for ax, i in zip(axes.flat, scales):
+        H = n // i
+        mask = (I // H) % 2 == (J // H) % 2
+        
+        ax.scatter(grid[mask, 0], grid[mask, 1],
+                color="blue", s=3)
+        ax.set_aspect("equal")
+        ax.set_xticks([])
+        ax.set_yticks([])
+        for spine in ax.spines.values():
+            spine.set_visible(False)
+
+    plt.tight_layout()
+    plt.show()
+
+def grid_disorder(net):
+    """
+    Measures the "disorder" of a D-dimensional grid.
+
+    Args:
+        net (np.ndarray): Grid of shape (*IJ, D), points already sorted with attached coordinates.
+    
+    Returns:
+        int: Total number of consecutive inversions along all axes (lower is better).
+    """
+    total_disorder = 0
+    D = net.shape[-1]
+    for axis in range(D):
+        # Move the sorting axis to the front
+        axes_order = (axis,) + tuple(i for i in range(net.ndim - 1) if i != axis) + (net.ndim - 1,)
+        net_perm = np.transpose(net, axes_order)
+        
+        # Flatten all remaining axes except the sorting axis
+        shape = net_perm.shape
+        flat_net = net_perm.reshape(shape[0], -1, D)
+        
+        # Count consecutive inversions along the axis
+        coords = flat_net[..., axis]  # shape (axis_size, n_cols)
+        inv = np.sum(coords[:-1, :] > coords[1:, :])  # i > i+1
+        total_disorder += inv
+    return total_disorder
+
+def initpoint(method, size):
+    N, D = size
+    if method == "test":
+        points = np.random.rand(N, D)
+    if method == "france":
+        import geopandas as gpd
+        from shapely.geometry import Point
+
+        # Charger le GeoJSON
+        with resources.files("squarenet.data").joinpath("france.geojson").open("r") as f:
+            gdf = gpd.read_file(f)
+        metropole = gdf[~gdf['nom'].isin([
+            'Guadeloupe', 'Martinique', 'Guyane', 'La Réunion', 'Mayotte', 'Corse'
+        ])]
+
+
+        # Merge regions
+        france = metropole.union_all()
+
+        # Bounding box
+        minx, miny, maxx, maxy = france.bounds
+
+        def sample_points(polygon, n_points):
+            points = []
+            
+            while len(points) < n_points:
+                x = np.random.uniform(minx, maxx)
+                y = np.random.uniform(miny, maxy)
+                p = Point(x, y)
+                
+                if polygon.contains(p):
+                    points.append(p)
+            
+            return np.array([[p.x, p.y] for p in points])
+
+        # Generate sample
+        points = sample_points(france, N)
+    return points
+
+def gram(self, X, ws):
+    """
+    Compute a sparse Gram matrix using local neighborhoods within a window.
+
+    Args:
+        X (np.ndarray): Input features of shape (N, C)
+        ws (int or sequence): Half window size per dimension.
+                             If int → same for all dims
+                             If sequence → one per grid dim
+
+    Returns:
+        np.ndarray: Sparse Gram matrix of shape (N, K)
+    """
+
+    # Map to grid → (*IJ, C)
+    Xg = self.map(X)
+    *grid_shape, C = Xg.shape
+    ndim = len(grid_shape)
+    d = ws
+
+    # Handle window size
+    if isinstance(d, int):
+        d = [d] * ndim
+    else:
+        assert len(d) == ndim, "d must match number of grid dimensions"
+
+    # Padding
+    pad_width = [(di, di) for di in d] + [(0, 0)]
+    X_padded = np.pad(Xg, pad_width, mode='constant')
+
+    # Window shape
+    window_shape = tuple(2 * di + 1 for di in d)
+
+    # Extract patches
+    patches = sliding_window_view(
+        X_padded,
+        window_shape=window_shape,
+        axis=tuple(range(ndim))
+    )
+
+    # Compute K = number of neighbors
+    K = np.prod(window_shape)
+
+    # reshape → (*IJ, K, C)
+    patches = patches.reshape(*grid_shape, K, C)
+
+    # center → (*IJ, 1, C)
+    center = Xg[(...,) + (None, slice(None))]
+
+    # dot product → (*IJ, K)
+    G = np.sum(center * patches, axis=-1)
+
+    # back to (N, K)
+    G = self.invert_map(G)
+
+    return G

squarenet-0.1.0/src/squarenet.egg-info/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: squarenet
+Version: 0.1.0
+Summary: Sparse local operations for point clouds in any dimension.
+Author-email: ArmanddeCacqueray <armanddecacqueray@sfr.fr>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Provides-Extra: demo
+Requires-Dist: geopandas; extra == "demo"
+Requires-Dist: shapely; extra == "demo"
+Dynamic: license-file
+
+# SquareNet
+
+**SquareNet** is a lightweight framework for mapping unstructured point clouds into structured N-dimensional grids, enabling fast and efficient local operations.
+
+## ✨ Key Idea
+
+SquareNet builds a bijective mapping between point indices and a structured grid:
+
+* **Bijection**: each point maps to exactly one grid cell
+* **Neighborhood preservation**: nearby points remain close in the grid
+
+This allows replacing expensive spatial queries (k-NN, radius search) with simple **array slicing**.
+
+---
+
+## 🚀 Features
+
+* Fast point cloud → grid mapping
+* Invertible transformation
+* Efficient local neighborhood operations
+* Sparse Gram matrix computation via sliding windows
+* NumPy-friendly (no heavy dependencies required)
+
+---
+
+## 📦 Installation
+
+```bash
+pip install squarenet
+```
+
+---
+
+## 🧠 Basic Usage
+
+```python
+from squarenet import SquareNet
+
+sqnet = SquareNet(IJ=(L, W, H, ...), max_iter = 100)
+
+# Original data: (N, D)
+points = np.random.rand(N, D)
+Sqnet.fit(points)
+
+# Map (N, *) to the grid: (L, W, H, ..., *)
+sqX = sqnet.map(X)
+
+# Back to original ordering
+X_rec = sqnet.invert_map(sqX)
+```
+
+---
+
+## 🔬 Local Processing Example
+
+Compute a **local (sparse) Gram matrix** using a sliding window:
+
+```python
+G = sqnet.gram(X, ws=(5, 5))
+```
+
+Instead of computing a full `(N × N)` matrix, SquareNet only computes interactions within local neighborhoods.
+
+---
+
+## 🗺️ Demo Dataset
+
+A small demo dataset (France map) is included:
+
+```python
+Sqnet.fit("france")
+```
+
+---
+
+## 🧱 Project Structure
+
+```
+src/
+  squarenet/
+    __init__.py
+    core.py
+    utils.py
+    data/france.geojson
+```
+
+---
+
+## 🎯 Why SquareNet?
+
+Traditional point cloud pipelines rely on:
+
+* k-NN search (O(N log N))
+* irregular memory access
+* poor GPU utilization
+
+SquareNet enables:
+
+* **O(N)** local operations
+* contiguous memory access
+* vectorized operations on a sliding window
+
+---
+
+## 📈 Use Cases
+
+* Point cloud processing
+* Graph-to-grid transformations
+* Fast kernel methods
+* Local feature aggregation
+* Deep learning preprocessing
+
+---
+
+## 🛠️ Development
+
+```bash
+git clone https://github.com/ArmanddeCacqueray/SquareNet
+cd squarenet
+pip install -e .
+```
+
+---
+
+## 📄 License
+
+MIT License
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome. Please open an issue or submit a pull request.
+

squarenet-0.1.0/src/squarenet.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE.txt
+README.md
+pyproject.toml
+src/squarenet/__init__.py
+src/squarenet/core.py
+src/squarenet/utils.py
+src/squarenet.egg-info/PKG-INFO
+src/squarenet.egg-info/SOURCES.txt
+src/squarenet.egg-info/dependency_links.txt
+src/squarenet.egg-info/requires.txt
+src/squarenet.egg-info/top_level.txt

squarenet-0.1.0/src/squarenet.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

squarenet-0.1.0/src/squarenet.egg-info/requires.txt

@@ -0,0 +1,6 @@
+numpy
+matplotlib
+
+[demo]
+geopandas
+shapely

squarenet-0.1.0/src/squarenet.egg-info/top_level.txt

@@ -0,0 +1 @@
+squarenet