binary-thinning-3d-cuda 1.1.8__tar.gz

binary_thinning_3d_cuda-1.1.8/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shiyang Chen
+
+Permission is hereby granted, free of Package, 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.

binary_thinning_3d_cuda-1.1.8/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: binary_thinning_3d_cuda
+Version: 1.1.8
+Summary: A fast 3D binary thinning implementation using CUDA and PyTorch.
+Home-page: https://github.com/sychen52/binary_thinning_3d_cuda
+Author: Shiyang Chen
+Author-email: sychen52@gmail.com
+Project-URL: Bug Tracker, https://github.com/sychen52/binary_thinning_3d_cuda/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: SimpleITK; extra == "dev"
+Requires-Dist: itk-thickness3d; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Binary Thinning 3D CUDA
+
+This package provides a blazing fast, memory-efficient GPU implementation of 3D Binary Thinning (skeletonization) using CUDA and PyTorch. 
+
+It is based on the [3D thinning algorithm by Lee and Kashyap (1994)](https://doi.org/10.1006/cvgi.1994.1039), which uses Euler characteristic invariance and 26-connectivity checks to safely erode a 3D binary volume down to a 1-pixel wide skeleton without altering its fundamental topology.
+
+## Features
+
+This implementation provides two topologically safe operating modes to suit your needs:
+
+1. **Mode 0: GPU Subgrid 8-Color Parallel (`mode=0`, Default)**
+   * **Speed:** Extremely Fast (~200x speedup over CPU)
+   * **Behavior:** Operates entirely on the GPU. It avoids race conditions by partitioning the image into an 8-color 3D checkerboard. It re-checks and deletes pixels of the same color in parallel because they are mathematically guaranteed not to touch each other.
+   * **Topology:** **Topologically Safe**. Produces a mathematically valid skeleton. *Note: Because the deletion order differs slightly from a strict CPU raster-scan, the exact pixel placement may differ very slightly from ITK (e.g. 0.003% difference), but the overall global topology is preserved perfectly.*
+2. **Mode 1: Hybrid CPU-GPU Sequential (`mode=1`)**
+   * **Speed:** Fast (~80x speedup over CPU)
+   * **Behavior:** Calculates Euler invariance on the GPU in parallel, but performs the final 26-connectivity re-checks strictly sequentially on the CPU (using zero-overhead memory compaction). 
+   * **Topology:** **100% Identical to ITK**. Guaranteed to produce the exact same pixel output as standard sequential CPU implementations like `itk.BinaryThinningImageFilter3D`.
+
+## Installation
+
+### Dependencies
+* Python 3.8+
+* PyTorch (with CUDA support)
+
+```bash
+git clone https://github.com/sychen52/binary_thinning_3d_cuda.git
+cd binary_thinning_3d_cuda
+
+# Standard install
+pip install -e --no-build-isolation .
+
+# Install with development dependencies (for running benchmarks)
+pip install -e --no-build-isolation ".[dev]"
+```
+*(Note: `itk-thickness3d` and `SimpleITK` are **not** hard dependencies. They are only included in the `[dev]` extras for the purpose of benchmarking and validating against the CPU implementation).*
+
+## Usage
+
+The input must be a 3D contiguous PyTorch `uint8` (Byte) tensor located on a CUDA device. All non-zero values are treated as foreground (`0` for background, `>0` for foreground).
+
+```python
+import torch
+from binary_thinning_3d import binary_thinning
+
+# Create or load a 3D binary mask on the GPU
+tensor = torch.zeros((100, 100, 100), dtype=torch.uint8, device='cuda')
+tensor[25:75, 25:75, 25:75] = 1 # Solid block
+
+# 1. GPU Subgrid (Default, Max Speed, Topologically Safe)
+# Modifies the tensor in-place
+binary_thinning(tensor, mode=0)
+
+# 2. Hybrid CPU-GPU (Exact ITK Match)
+binary_thinning(tensor, mode=1)
+```
+
+## Benchmark
+
+The following benchmark was run on a `(767, 512, 512)` NIfTI volume (CT Airways Label) containing `451,530` foreground voxels. 
+
+The benchmark compares this CUDA implementation against `itk.BinaryThinningImageFilter3D` (which is run sequentially on the CPU).
+
+| Method | Output Voxel Count | Time (Seconds) | Speedup vs ITK | Matches ITK CPU? |
+| :--- | :--- | :--- | :--- | :--- |
+| **Mode 0 (GPU Subgrid)** | 4,286 | **0.72 s** | **194x** | Topologically equivalent |
+| **Mode 1 (Hybrid CPU)** | 4,281 | 1.82 s | 77x | **Yes (100% Identical)** |
+| **ITK (CPU Baseline)** | 4,281 | 140.27 s | 1x | Baseline |
+
+To reproduce these benchmarks yourself:
+```bash
+# Ensure you installed with dev dependencies: pip install -e ".[dev]"
+python examples/process_nifti.py
+```
+*(The script will cache the slow ITK result to disk on the first run, so subsequent runs finish instantly).*

binary_thinning_3d_cuda-1.1.8/README.md

@@ -0,0 +1,75 @@
+# Binary Thinning 3D CUDA
+
+This package provides a blazing fast, memory-efficient GPU implementation of 3D Binary Thinning (skeletonization) using CUDA and PyTorch. 
+
+It is based on the [3D thinning algorithm by Lee and Kashyap (1994)](https://doi.org/10.1006/cvgi.1994.1039), which uses Euler characteristic invariance and 26-connectivity checks to safely erode a 3D binary volume down to a 1-pixel wide skeleton without altering its fundamental topology.
+
+## Features
+
+This implementation provides two topologically safe operating modes to suit your needs:
+
+1. **Mode 0: GPU Subgrid 8-Color Parallel (`mode=0`, Default)**
+   * **Speed:** Extremely Fast (~200x speedup over CPU)
+   * **Behavior:** Operates entirely on the GPU. It avoids race conditions by partitioning the image into an 8-color 3D checkerboard. It re-checks and deletes pixels of the same color in parallel because they are mathematically guaranteed not to touch each other.
+   * **Topology:** **Topologically Safe**. Produces a mathematically valid skeleton. *Note: Because the deletion order differs slightly from a strict CPU raster-scan, the exact pixel placement may differ very slightly from ITK (e.g. 0.003% difference), but the overall global topology is preserved perfectly.*
+2. **Mode 1: Hybrid CPU-GPU Sequential (`mode=1`)**
+   * **Speed:** Fast (~80x speedup over CPU)
+   * **Behavior:** Calculates Euler invariance on the GPU in parallel, but performs the final 26-connectivity re-checks strictly sequentially on the CPU (using zero-overhead memory compaction). 
+   * **Topology:** **100% Identical to ITK**. Guaranteed to produce the exact same pixel output as standard sequential CPU implementations like `itk.BinaryThinningImageFilter3D`.
+
+## Installation
+
+### Dependencies
+* Python 3.8+
+* PyTorch (with CUDA support)
+
+```bash
+git clone https://github.com/sychen52/binary_thinning_3d_cuda.git
+cd binary_thinning_3d_cuda
+
+# Standard install
+pip install -e --no-build-isolation .
+
+# Install with development dependencies (for running benchmarks)
+pip install -e --no-build-isolation ".[dev]"
+```
+*(Note: `itk-thickness3d` and `SimpleITK` are **not** hard dependencies. They are only included in the `[dev]` extras for the purpose of benchmarking and validating against the CPU implementation).*
+
+## Usage
+
+The input must be a 3D contiguous PyTorch `uint8` (Byte) tensor located on a CUDA device. All non-zero values are treated as foreground (`0` for background, `>0` for foreground).
+
+```python
+import torch
+from binary_thinning_3d import binary_thinning
+
+# Create or load a 3D binary mask on the GPU
+tensor = torch.zeros((100, 100, 100), dtype=torch.uint8, device='cuda')
+tensor[25:75, 25:75, 25:75] = 1 # Solid block
+
+# 1. GPU Subgrid (Default, Max Speed, Topologically Safe)
+# Modifies the tensor in-place
+binary_thinning(tensor, mode=0)
+
+# 2. Hybrid CPU-GPU (Exact ITK Match)
+binary_thinning(tensor, mode=1)
+```
+
+## Benchmark
+
+The following benchmark was run on a `(767, 512, 512)` NIfTI volume (CT Airways Label) containing `451,530` foreground voxels. 
+
+The benchmark compares this CUDA implementation against `itk.BinaryThinningImageFilter3D` (which is run sequentially on the CPU).
+
+| Method | Output Voxel Count | Time (Seconds) | Speedup vs ITK | Matches ITK CPU? |
+| :--- | :--- | :--- | :--- | :--- |
+| **Mode 0 (GPU Subgrid)** | 4,286 | **0.72 s** | **194x** | Topologically equivalent |
+| **Mode 1 (Hybrid CPU)** | 4,281 | 1.82 s | 77x | **Yes (100% Identical)** |
+| **ITK (CPU Baseline)** | 4,281 | 140.27 s | 1x | Baseline |
+
+To reproduce these benchmarks yourself:
+```bash
+# Ensure you installed with dev dependencies: pip install -e ".[dev]"
+python examples/process_nifti.py
+```
+*(The script will cache the slow ITK result to disk on the first run, so subsequent runs finish instantly).*

binary_thinning_3d_cuda-1.1.8/binary_thinning_3d/__init__.py

@@ -0,0 +1,41 @@
+import torch
+from . import cuda_thinning_ext
+
+
+def binary_thinning(tensor: torch.Tensor, mode: int = 0) -> torch.Tensor:
+    """
+    3D binary thinning using CUDA. If the tensor is on CUDA, the operation is performed in-place.
+    If it's on CPU, it will be moved to CUDA for processing and then copied back.
+
+    Args:
+        tensor (torch.Tensor): A 3D tensor. All non-zero values are treated as foreground.
+        mode (int):
+            0 = GPU Subgrid (Fastest, preserves topology, fully GPU)
+            1 = CPU Sequential Re-check (Matches ITK exactly, slower)
+
+    Returns:
+        torch.Tensor: The thinned binary tensor.
+    """
+    if tensor.dim() != 3:
+        raise ValueError("Tensor must be 3D.")
+    if mode not in [0, 1]:
+        raise ValueError("Mode must be 0 (GPU Subgrid) or 1 (CPU Sequential).")
+
+    # We must operate on a contiguous ByteTensor (uint8)
+    if not tensor.is_cuda:
+        work_tensor = tensor.to(device="cuda", dtype=torch.uint8)
+    elif tensor.dtype != torch.uint8 or not tensor.is_contiguous():
+        work_tensor = (tensor != 0).to(torch.uint8).contiguous()
+    else:
+        work_tensor = tensor
+        tensor[tensor != 0] = 1  # Ensure binary
+
+    cuda_thinning_ext.binary_thinning(work_tensor, mode)
+
+    if not tensor.is_cuda:
+        return work_tensor.cpu()
+
+    if work_tensor is not tensor:
+        tensor.copy_(work_tensor)
+
+    return tensor

binary_thinning_3d_cuda-1.1.8/binary_thinning_3d_cuda.egg-info/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: binary_thinning_3d_cuda
+Version: 1.1.8
+Summary: A fast 3D binary thinning implementation using CUDA and PyTorch.
+Home-page: https://github.com/sychen52/binary_thinning_3d_cuda
+Author: Shiyang Chen
+Author-email: sychen52@gmail.com
+Project-URL: Bug Tracker, https://github.com/sychen52/binary_thinning_3d_cuda/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: SimpleITK; extra == "dev"
+Requires-Dist: itk-thickness3d; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Binary Thinning 3D CUDA
+
+This package provides a blazing fast, memory-efficient GPU implementation of 3D Binary Thinning (skeletonization) using CUDA and PyTorch. 
+
+It is based on the [3D thinning algorithm by Lee and Kashyap (1994)](https://doi.org/10.1006/cvgi.1994.1039), which uses Euler characteristic invariance and 26-connectivity checks to safely erode a 3D binary volume down to a 1-pixel wide skeleton without altering its fundamental topology.
+
+## Features
+
+This implementation provides two topologically safe operating modes to suit your needs:
+
+1. **Mode 0: GPU Subgrid 8-Color Parallel (`mode=0`, Default)**
+   * **Speed:** Extremely Fast (~200x speedup over CPU)
+   * **Behavior:** Operates entirely on the GPU. It avoids race conditions by partitioning the image into an 8-color 3D checkerboard. It re-checks and deletes pixels of the same color in parallel because they are mathematically guaranteed not to touch each other.
+   * **Topology:** **Topologically Safe**. Produces a mathematically valid skeleton. *Note: Because the deletion order differs slightly from a strict CPU raster-scan, the exact pixel placement may differ very slightly from ITK (e.g. 0.003% difference), but the overall global topology is preserved perfectly.*
+2. **Mode 1: Hybrid CPU-GPU Sequential (`mode=1`)**
+   * **Speed:** Fast (~80x speedup over CPU)
+   * **Behavior:** Calculates Euler invariance on the GPU in parallel, but performs the final 26-connectivity re-checks strictly sequentially on the CPU (using zero-overhead memory compaction). 
+   * **Topology:** **100% Identical to ITK**. Guaranteed to produce the exact same pixel output as standard sequential CPU implementations like `itk.BinaryThinningImageFilter3D`.
+
+## Installation
+
+### Dependencies
+* Python 3.8+
+* PyTorch (with CUDA support)
+
+```bash
+git clone https://github.com/sychen52/binary_thinning_3d_cuda.git
+cd binary_thinning_3d_cuda
+
+# Standard install
+pip install -e --no-build-isolation .
+
+# Install with development dependencies (for running benchmarks)
+pip install -e --no-build-isolation ".[dev]"
+```
+*(Note: `itk-thickness3d` and `SimpleITK` are **not** hard dependencies. They are only included in the `[dev]` extras for the purpose of benchmarking and validating against the CPU implementation).*
+
+## Usage
+
+The input must be a 3D contiguous PyTorch `uint8` (Byte) tensor located on a CUDA device. All non-zero values are treated as foreground (`0` for background, `>0` for foreground).
+
+```python
+import torch
+from binary_thinning_3d import binary_thinning
+
+# Create or load a 3D binary mask on the GPU
+tensor = torch.zeros((100, 100, 100), dtype=torch.uint8, device='cuda')
+tensor[25:75, 25:75, 25:75] = 1 # Solid block
+
+# 1. GPU Subgrid (Default, Max Speed, Topologically Safe)
+# Modifies the tensor in-place
+binary_thinning(tensor, mode=0)
+
+# 2. Hybrid CPU-GPU (Exact ITK Match)
+binary_thinning(tensor, mode=1)
+```
+
+## Benchmark
+
+The following benchmark was run on a `(767, 512, 512)` NIfTI volume (CT Airways Label) containing `451,530` foreground voxels. 
+
+The benchmark compares this CUDA implementation against `itk.BinaryThinningImageFilter3D` (which is run sequentially on the CPU).
+
+| Method | Output Voxel Count | Time (Seconds) | Speedup vs ITK | Matches ITK CPU? |
+| :--- | :--- | :--- | :--- | :--- |
+| **Mode 0 (GPU Subgrid)** | 4,286 | **0.72 s** | **194x** | Topologically equivalent |
+| **Mode 1 (Hybrid CPU)** | 4,281 | 1.82 s | 77x | **Yes (100% Identical)** |
+| **ITK (CPU Baseline)** | 4,281 | 140.27 s | 1x | Baseline |
+
+To reproduce these benchmarks yourself:
+```bash
+# Ensure you installed with dev dependencies: pip install -e ".[dev]"
+python examples/process_nifti.py
+```
+*(The script will cache the slow ITK result to disk on the first run, so subsequent runs finish instantly).*

binary_thinning_3d_cuda-1.1.8/binary_thinning_3d_cuda.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+binary_thinning_3d/__init__.py
+binary_thinning_3d_cuda.egg-info/PKG-INFO
+binary_thinning_3d_cuda.egg-info/SOURCES.txt
+binary_thinning_3d_cuda.egg-info/dependency_links.txt
+binary_thinning_3d_cuda.egg-info/requires.txt
+binary_thinning_3d_cuda.egg-info/top_level.txt
+csrc/thinning.cpp
+csrc/thinning_kernel.cu
+tests/test_thinning.py

binary_thinning_3d_cuda-1.1.8/binary_thinning_3d_cuda.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

binary_thinning_3d_cuda-1.1.8/binary_thinning_3d_cuda.egg-info/requires.txt

@@ -0,0 +1,6 @@
+torch
+numpy
+
+[dev]
+SimpleITK
+itk-thickness3d

binary_thinning_3d_cuda-1.1.8/binary_thinning_3d_cuda.egg-info/top_level.txt

@@ -0,0 +1 @@
+binary_thinning_3d

binary_thinning_3d_cuda-1.1.8/csrc/thinning.cpp

@@ -0,0 +1,8 @@
+#include <torch/extension.h>
+
+void binary_thinning_cuda(torch::Tensor image, int mode);
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+  m.def("binary_thinning", &binary_thinning_cuda, "3D Binary Thinning (CUDA)",
+        pybind11::arg("image"), pybind11::arg("mode") = 0);
+}

binary_thinning_3d_cuda-1.1.8/csrc/thinning_kernel.cu

@@ -0,0 +1,511 @@
+/**
+ * 3D Binary Thinning CUDA Kernel
+ *
+ * Voxel value assumptions:
+ * - 0: Background
+ * - 1: Foreground (object)
+ * - 2: Internal marker for "candidate for deletion" during a thinning
+ * iteration.
+ *
+ * The algorithm iteratively identifies border points that are "simple" (can be
+ * removed without changing the topology) and marks them with 2. It then
+ * resolves these candidates either sequentially (Mode 1) or in parallel
+ * subgrids (Mode 2) to ensure topological correctness.
+ */
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include <thrust/copy.h>
+#include <thrust/device_ptr.h>
+#include <thrust/execution_policy.h>
+#include <thrust/iterator/counting_iterator.h>
+#include <torch/extension.h>
+#include <vector>
+
+__constant__ int d_eulerLUT[256] = {
+    0, 1,  0, -1, 0, -1, 0, 1,  0, -3, 0, -1, 0, -1, 0, 1,  0, -1, 0, 1,  0, 1,
+    0, -1, 0, 3,  0, 1,  0, 1,  0, -1, 0, -3, 0, -1, 0, 3,  0, 1,  0, 1,  0, -1,
+    0, 3,  0, 1,  0, -1, 0, 1,  0, 1,  0, -1, 0, 3,  0, 1,  0, 1,  0, -1, 0, -3,
+    0, 3,  0, -1, 0, 1,  0, 1,  0, 3,  0, -1, 0, 1,  0, -1, 0, 1,  0, 1,  0, -1,
+    0, 3,  0, 1,  0, 1,  0, -1, 0, 1,  0, 3,  0, 3,  0, 1,  0, 5,  0, 3,  0, 3,
+    0, 1,  0, -1, 0, 1,  0, 1,  0, -1, 0, 3,  0, 1,  0, 1,  0, -1, 0, -7, 0, -1,
+    0, -1, 0, 1,  0, -3, 0, -1, 0, -1, 0, 1,  0, -1, 0, 1,  0, 1,  0, -1, 0, 3,
+    0, 1,  0, 1,  0, -1, 0, -3, 0, -1, 0, 3,  0, 1,  0, 1,  0, -1, 0, 3,  0, 1,
+    0, -1, 0, 1,  0, 1,  0, -1, 0, 3,  0, 1,  0, 1,  0, -1, 0, -3, 0, 3,  0, -1,
+    0, 1,  0, 1,  0, 3,  0, -1, 0, 1,  0, -1, 0, 1,  0, 1,  0, -1, 0, 3,  0, 1,
+    0, 1,  0, -1, 0, 1,  0, 3,  0, 3,  0, 1,  0, 5,  0, 3,  0, 3,  0, 1,  0, -1,
+    0, 1,  0, 1,  0, -1, 0, 3,  0, 1,  0, 1,  0, -1};
+
+__device__ bool is_euler_invariant(const int *neighbors) {
+  int eulerChar = 0;
+  unsigned char n;
+
+  // Octant SWU
+  n = 1;
+  if (neighbors[24] == 1)
+    n |= 128;
+  if (neighbors[25] == 1)
+    n |= 64;
+  if (neighbors[15] == 1)
+    n |= 32;
+  if (neighbors[16] == 1)
+    n |= 16;
+  if (neighbors[21] == 1)
+    n |= 8;
+  if (neighbors[22] == 1)
+    n |= 4;
+  if (neighbors[12] == 1)
+    n |= 2;
+  eulerChar += d_eulerLUT[n];
+
+  // Octant SEU
+  n = 1;
+  if (neighbors[26] == 1)
+    n |= 128;
+  if (neighbors[23] == 1)
+    n |= 64;
+  if (neighbors[17] == 1)
+    n |= 32;
+  if (neighbors[14] == 1)
+    n |= 16;
+  if (neighbors[25] == 1)
+    n |= 8;
+  if (neighbors[22] == 1)
+    n |= 4;
+  if (neighbors[16] == 1)
+    n |= 2;
+  eulerChar += d_eulerLUT[n];
+
+  // Octant NWU
+  n = 1;
+  if (neighbors[18] == 1)
+    n |= 128;
+  if (neighbors[21] == 1)
+    n |= 64;
+  if (neighbors[9] == 1)
+    n |= 32;
+  if (neighbors[12] == 1)
+    n |= 16;
+  if (neighbors[19] == 1)
+    n |= 8;
+  if (neighbors[22] == 1)
+    n |= 4;
+  if (neighbors[10] == 1)
+    n |= 2;
+  eulerChar += d_eulerLUT[n];
+
+  // Octant NEU
+  n = 1;
+  if (neighbors[20] == 1)
+    n |= 128;
+  if (neighbors[23] == 1)
+    n |= 64;
+  if (neighbors[19] == 1)
+    n |= 32;
+  if (neighbors[22] == 1)
+    n |= 16;
+  if (neighbors[11] == 1)
+    n |= 8;
+  if (neighbors[14] == 1)
+    n |= 4;
+  if (neighbors[10] == 1)
+    n |= 2;
+  eulerChar += d_eulerLUT[n];
+
+  // Octant SWB
+  n = 1;
+  if (neighbors[6] == 1)
+    n |= 128;
+  if (neighbors[15] == 1)
+    n |= 64;
+  if (neighbors[7] == 1)
+    n |= 32;
+  if (neighbors[16] == 1)
+    n |= 16;
+  if (neighbors[3] == 1)
+    n |= 8;
+  if (neighbors[12] == 1)
+    n |= 4;
+  if (neighbors[4] == 1)
+    n |= 2;
+  eulerChar += d_eulerLUT[n];
+
+  // Octant SEB
+  n = 1;
+  if (neighbors[8] == 1)
+    n |= 128;
+  if (neighbors[7] == 1)
+    n |= 64;
+  if (neighbors[17] == 1)
+    n |= 32;
+  if (neighbors[16] == 1)
+    n |= 16;
+  if (neighbors[5] == 1)
+    n |= 8;
+  if (neighbors[4] == 1)
+    n |= 4;
+  if (neighbors[14] == 1)
+    n |= 2;
+  eulerChar += d_eulerLUT[n];
+
+  // Octant NWB
+  n = 1;
+  if (neighbors[0] == 1)
+    n |= 128;
+  if (neighbors[9] == 1)
+    n |= 64;
+  if (neighbors[3] == 1)
+    n |= 32;
+  if (neighbors[12] == 1)
+    n |= 16;
+  if (neighbors[1] == 1)
+    n |= 8;
+  if (neighbors[10] == 1)
+    n |= 4;
+  if (neighbors[4] == 1)
+    n |= 2;
+  eulerChar += d_eulerLUT[n];
+
+  // Octant NEB
+  n = 1;
+  if (neighbors[2] == 1)
+    n |= 128;
+  if (neighbors[1] == 1)
+    n |= 64;
+  if (neighbors[11] == 1)
+    n |= 32;
+  if (neighbors[10] == 1)
+    n |= 16;
+  if (neighbors[5] == 1)
+    n |= 8;
+  if (neighbors[4] == 1)
+    n |= 4;
+  if (neighbors[14] == 1)
+    n |= 2;
+  eulerChar += d_eulerLUT[n];
+
+  return (eulerChar == 0);
+}
+
+__host__ __device__ int uf_find(int i, int *parent) {
+  while (parent[i] != i) {
+    parent[i] = parent[parent[i]];
+    i = parent[i];
+  }
+  return i;
+}
+
+__host__ __device__ void uf_union(int i, int j, int *parent) {
+  int root_i = uf_find(i, parent);
+  int root_j = uf_find(j, parent);
+  if (root_i != root_j) {
+    parent[root_i] = root_j;
+  }
+}
+
+__host__ __device__ bool is_simple_point(const int *neighbors) {
+  int parent[27];
+  for (int i = 0; i < 27; ++i) {
+    parent[i] = i;
+  }
+
+  for (int i = 0; i < 27; ++i) {
+    if (i == 13 || neighbors[i] != 1)
+      continue;
+    int x1 = i % 3;
+    int y1 = (i / 3) % 3;
+    int z1 = i / 9;
+
+    for (int j = i + 1; j < 27; ++j) {
+      if (j == 13 || neighbors[j] != 1)
+        continue;
+      int x2 = j % 3;
+      int y2 = (j / 3) % 3;
+      int z2 = j / 9;
+
+      if (abs(x1 - x2) <= 1 && abs(y1 - y2) <= 1 && abs(z1 - z2) <= 1) {
+        uf_union(i, j, parent);
+      }
+    }
+  }
+
+  int components = 0;
+  for (int i = 0; i < 27; ++i) {
+    if (i == 13)
+      continue;
+    if (neighbors[i] == 1 && parent[i] == i) {
+      components++;
+    }
+  }
+
+  return (components <= 1);
+}
+
+__global__ void mark_deletable_points_kernel(unsigned char *img, int d, int h,
+                                             int w, int currentBorder) {
+  int x = blockIdx.x * blockDim.x + threadIdx.x;
+  int y = blockIdx.y * blockDim.y + threadIdx.y;
+  int z = blockIdx.z * blockDim.z + threadIdx.z;
+
+  if (x >= w || y >= h || z >= d)
+    return;
+
+  size_t idx = (size_t)z * (h * w) + y * w + x;
+  if (img[idx] == 0 || img[idx] == 2)
+    return;
+
+  int neighbors[27];
+  int num_neighbors = -1;
+  bool isBorderPoint = false;
+
+  for (int dz = -1; dz <= 1; ++dz) {
+    for (int dy = -1; dy <= 1; ++dy) {
+      for (int dx = -1; dx <= 1; ++dx) {
+        int nx = x + dx;
+        int ny = y + dy;
+        int nz = z + dz;
+
+        int n_idx = (dz + 1) * 9 + (dy + 1) * 3 + (dx + 1);
+
+        int val = 0;
+        if (nx >= 0 && nx < w && ny >= 0 && ny < h && nz >= 0 && nz < d) {
+          size_t flat_n_idx = (size_t)nz * (h * w) + ny * w + nx;
+          val = img[flat_n_idx];
+        }
+
+        int binary_val = (val > 0) ? 1 : 0;
+        neighbors[n_idx] = binary_val;
+
+        if (binary_val == 1) {
+          num_neighbors++;
+        }
+
+        if (dx == 0 && dy == -1 && dz == 0 && currentBorder == 1 && val == 0)
+          isBorderPoint = true; // N
+        if (dx == 0 && dy == 1 && dz == 0 && currentBorder == 2 && val == 0)
+          isBorderPoint = true; // S
+        if (dx == 1 && dy == 0 && dz == 0 && currentBorder == 3 && val == 0)
+          isBorderPoint = true; // E
+        if (dx == -1 && dy == 0 && dz == 0 && currentBorder == 4 && val == 0)
+          isBorderPoint = true; // W
+        if (dx == 0 && dy == 0 && dz == 1 && currentBorder == 5 && val == 0)
+          isBorderPoint = true; // U
+        if (dx == 0 && dy == 0 && dz == -1 && currentBorder == 6 && val == 0)
+          isBorderPoint = true; // B
+      }
+    }
+  }
+
+  if (!isBorderPoint)
+    return;
+  if (num_neighbors == 1)
+    return;
+  if (!is_euler_invariant(neighbors))
+    return;
+  if (!is_simple_point(neighbors))
+    return;
+
+  img[idx] = 2; // mark for deletion
+}
+
+struct is_marked {
+  unsigned char *img;
+  __host__ __device__ is_marked(unsigned char *_img) : img(_img) {}
+  __device__ bool operator()(const size_t &idx) const { return img[idx] == 2; }
+};
+
+__global__ void subgrid_recheck_kernel(unsigned char *img, int d, int h, int w,
+                                       unsigned int *marked_indices, int count,
+                                       int color, int *changed) {
+  int i = blockIdx.x * blockDim.x + threadIdx.x;
+  if (i >= count)
+    return;
+
+  size_t idx = marked_indices[i];
+  if (img[idx] != 2)
+    return; // Already handled by previous color or untouched
+
+  int x = idx % w;
+  int y = (idx / w) % h;
+  int z = idx / (w * h);
+
+  int p = (x % 2) + (y % 2) * 2 + (z % 2) * 4;
+  if (p != color)
+    return;
+
+  img[idx] = 0; // Temporarily delete
+
+  int neighbors[27];
+  for (int dz = -1; dz <= 1; ++dz) {
+    for (int dy = -1; dy <= 1; ++dy) {
+      for (int dx = -1; dx <= 1; ++dx) {
+        int nx = x + dx;
+        int ny = y + dy;
+        int nz = z + dz;
+        int n_idx = (dz + 1) * 9 + (dy + 1) * 3 + (dx + 1);
+
+        int val = 0;
+        if (nx >= 0 && nx < w && ny >= 0 && ny < h && nz >= 0 && nz < d) {
+          size_t flat_n_idx = (size_t)nz * (h * w) + ny * w + nx;
+          val = img[flat_n_idx];
+        }
+        neighbors[n_idx] = (val > 0) ? 1 : 0;
+      }
+    }
+  }
+
+  if (!is_simple_point(neighbors)) {
+    img[idx] = 1; // Not simple anymore, restore
+  } else {
+    atomicAdd(changed, 1);
+  }
+}
+
+__global__ void apply_updates_kernel(unsigned char *img, unsigned int *indices,
+                                     int count, unsigned char val) {
+  int i = blockIdx.x * blockDim.x + threadIdx.x;
+  if (i < count) {
+    img[indices[i]] = val;
+  }
+}
+
+void binary_thinning_cuda(torch::Tensor image, int mode) {
+  TORCH_CHECK(image.is_cuda(), "image must be a CUDA tensor");
+  TORCH_CHECK(image.is_contiguous(), "image must be contiguous");
+  TORCH_CHECK(image.scalar_type() == torch::kByte,
+              "image must be a ByteTensor (uint8)");
+  TORCH_CHECK(image.dim() == 3, "image must be a 3D tensor");
+
+  int d = image.size(0);
+  int h = image.size(1);
+  int w = image.size(2);
+  size_t total_size = (size_t)d * h * w;
+
+  unsigned char *d_img = image.data_ptr<unsigned char>();
+
+  int *d_changed;
+  cudaMalloc(&d_changed, sizeof(int));
+
+  unsigned int *d_marked_indices = nullptr;
+  unsigned char *h_img = nullptr;
+
+  cudaMalloc(&d_marked_indices, total_size * sizeof(unsigned int));
+  if (mode == 1) { // Mode 1: Exact ITK Hybrid
+    h_img = new unsigned char[total_size];
+    cudaMemcpy(h_img, d_img, total_size, cudaMemcpyDeviceToHost);
+  }
+
+  dim3 blockSize(8, 4, 4);
+  dim3 gridSize((w + blockSize.x - 1) / blockSize.x,
+                (h + blockSize.y - 1) / blockSize.y,
+                (d + blockSize.z - 1) / blockSize.z);
+
+  int h_changed = 0;
+  do {
+    h_changed = 0;
+    for (int border = 1; border <= 6; ++border) {
+      mark_deletable_points_kernel<<<gridSize, blockSize>>>(d_img, d, h, w,
+                                                            border);
+
+      cudaMemset(d_changed, 0, sizeof(int));
+
+      thrust::counting_iterator<size_t> first(0);
+      thrust::counting_iterator<size_t> last(total_size);
+      thrust::device_ptr<unsigned int> dest(d_marked_indices);
+
+      auto end_ptr =
+          thrust::copy_if(thrust::device, first, last, dest, is_marked(d_img));
+      int h_count = end_ptr - dest;
+
+      if (h_count > 0) {
+        if (mode == 1) {
+          // Mode 1: CPU Sequential (Exact ITK Match)
+          std::vector<unsigned int> h_marked(h_count);
+          cudaMemcpy(h_marked.data(), d_marked_indices,
+                     h_count * sizeof(unsigned int), cudaMemcpyDeviceToHost);
+
+          std::vector<unsigned int> h_deleted;
+          std::vector<unsigned int> h_restored;
+          h_deleted.reserve(h_count);
+          h_restored.reserve(h_count);
+
+          for (int i = 0; i < h_count; ++i) {
+            unsigned int idx = h_marked[i];
+
+            int x = idx % w;
+            int y = (idx / w) % h;
+            int z = idx / (w * h);
+
+            h_img[idx] = 0; // Temporarily delete
+
+            int neighbors[27];
+            for (int dz = -1; dz <= 1; ++dz) {
+              for (int dy = -1; dy <= 1; ++dy) {
+                for (int dx = -1; dx <= 1; ++dx) {
+                  int nx = x + dx;
+                  int ny = y + dy;
+                  int nz = z + dz;
+                  int n_idx = (dz + 1) * 9 + (dy + 1) * 3 + (dx + 1);
+
+                  int val = 0;
+                  if (nx >= 0 && nx < w && ny >= 0 && ny < h && nz >= 0 &&
+                      nz < d) {
+                    size_t flat_n_idx = (size_t)nz * (h * w) + ny * w + nx;
+                    val = h_img[flat_n_idx];
+                  }
+                  neighbors[n_idx] = (val > 0) ? 1 : 0;
+                }
+              }
+            }
+
+            if (!is_simple_point(neighbors)) {
+              h_img[idx] = 1; // Not simple anymore, restore
+              h_restored.push_back(idx);
+            } else {
+              h_deleted.push_back(idx);
+            }
+          }
+
+          if (!h_deleted.empty()) {
+            cudaMemcpy(d_marked_indices, h_deleted.data(),
+                       h_deleted.size() * sizeof(unsigned int),
+                       cudaMemcpyHostToDevice);
+            int threads = 256;
+            int blocks = (h_deleted.size() + threads - 1) / threads;
+            apply_updates_kernel<<<blocks, threads>>>(d_img, d_marked_indices,
+                                                      h_deleted.size(), 0);
+            h_changed += h_deleted.size();
+          }
+
+          if (!h_restored.empty()) {
+            cudaMemcpy(d_marked_indices, h_restored.data(),
+                       h_restored.size() * sizeof(unsigned int),
+                       cudaMemcpyHostToDevice);
+            int threads = 256;
+            int blocks = (h_restored.size() + threads - 1) / threads;
+            apply_updates_kernel<<<blocks, threads>>>(d_img, d_marked_indices,
+                                                      h_restored.size(), 1);
+          }
+        } else if (mode == 0) {
+          // Mode 0: GPU Subgrid (8-color parallel) - Topologically safe, purely
+          // GPU
+          int threads = 256;
+          int blocks = (h_count + threads - 1) / threads;
+          for (int color = 0; color < 8; ++color) {
+            subgrid_recheck_kernel<<<blocks, threads>>>(
+                d_img, d, h, w, d_marked_indices, h_count, color, d_changed);
+          }
+          int changed_this_border = 0;
+          cudaMemcpy(&changed_this_border, d_changed, sizeof(int),
+                     cudaMemcpyDeviceToHost);
+          h_changed += changed_this_border;
+        }
+      }
+    }
+  } while (h_changed > 0);
+
+  cudaFree(d_marked_indices);
+  if (mode == 1) {
+    delete[] h_img;
+  }
+  cudaFree(d_changed);
+}

binary_thinning_3d_cuda-1.1.8/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=40.8.0", "wheel", "torch", "numpy"]
+build-backend = "setuptools.build_meta"

binary_thinning_3d_cuda-1.1.8/setup.cfg

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

binary_thinning_3d_cuda-1.1.8/setup.py

@@ -0,0 +1,57 @@
+import os
+from setuptools import setup, Extension
+from torch.utils.cpp_extension import BuildExtension, CUDAExtension, CUDA_HOME
+
+# Read README.md for long_description
+this_directory = os.path.abspath(os.path.dirname(__file__))
+with open(os.path.join(this_directory, "README.md"), encoding="utf-8") as f:
+    long_description = f.read()
+
+# Check if CUDA is available. If not, we are likely building a source distribution (sdist)
+# or just gathering metadata, so we use a dummy extension.
+if CUDA_HOME is None:
+    # Use a dummy extension so metadata can be gathered without CUDA checks
+    ext_modules = [
+        Extension(
+            "binary_thinning_3d.cuda_thinning_ext",
+            ["csrc/thinning.cpp", "csrc/thinning_kernel.cu"],
+        )
+    ]
+else:
+    # Use the real CUDAExtension for binary wheel builds
+    ext_modules = [
+        CUDAExtension(
+            "binary_thinning_3d.cuda_thinning_ext",
+            [
+                "csrc/thinning.cpp",
+                "csrc/thinning_kernel.cu",
+            ],
+        ),
+    ]
+
+setup(
+    name="binary_thinning_3d_cuda",
+    version="1.1.8",
+    author="Shiyang Chen",
+    author_email="sychen52@gmail.com",
+    description="A fast 3D binary thinning implementation using CUDA and PyTorch.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/sychen52/binary_thinning_3d_cuda",
+    project_urls={
+        "Bug Tracker": "https://github.com/sychen52/binary_thinning_3d_cuda/issues",
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: POSIX :: Linux",
+        "Topic :: Scientific/Engineering :: Image Processing",
+        "Intended Audience :: Science/Research",
+    ],
+    packages=["binary_thinning_3d"],
+    install_requires=["torch", "numpy"],
+    extras_require={"dev": ["SimpleITK", "itk-thickness3d"]},
+    python_requires=">=3.8",
+    ext_modules=ext_modules,
+    cmdclass={"build_ext": BuildExtension},
+)

binary_thinning_3d_cuda-1.1.8/tests/test_thinning.py

@@ -0,0 +1,29 @@
+import torch
+from binary_thinning_3d import binary_thinning
+
+
+def test_thinning():
+    # Create a 5x5x5 block and put a 3x3x3 cube in the middle
+    t = torch.zeros((5, 5, 5), dtype=torch.uint8, device="cuda")
+    t[1:4, 1:4, 1:4] = 1
+
+    print("Original sum:", t.sum().item())
+
+    # Run thinning
+    binary_thinning(t)
+
+    print("Thinned sum:", t.sum().item())
+
+    print("Coordinates of remaining points:")
+    coords = torch.nonzero(t)
+    for c in coords:
+        print(c.tolist())
+
+    print("Center pixel value:", t[2, 2, 2].item())
+    assert t.sum().item() == 3
+    assert t[2, 2, 2].item() == 1
+    print("Test passed!")
+
+
+if __name__ == "__main__":
+    test_thinning()