cc-csf 1.0.0__tar.gz

cc_csf-1.0.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include cc_csf.cpp
+include README.md
+include pyproject.toml
+recursive-include src *.h *.cpp

cc_csf-1.0.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: cc_csf
+Version: 1.0.0
+Summary: High-performance Zero-Copy OpenMP Pybind11 Cloth Simulation Filter (CSF)
+Author-email: Aman Ranjan <er.amanranjan@gmail.com>
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20
+
+# cc_csf (Zero-Copy OpenMP Cloth Simulation Filter)
+
+High-performance Python wrapper for the Cloth Simulation Filter (CSF) algorithm using Pybind11, OpenMP parallelization, and zero-copy NumPy array buffers.
+
+## Installation
+
+### From Pre-built Wheel
+```bash
+uv pip install cc_csf-1.0.0-cp312-cp312-linux_x86_64.whl
+# or
+pip install cc_csf-1.0.0-cp312-cp312-linux_x86_64.whl
+```
+
+### From Source (In-place or install)
+```bash
+uv pip install -e .
+# or
+pip install .
+```
+
+## Quick Start Example
+
+```python
+import numpy as np
+import cc_csf
+
+# Initialize filter
+csf = cc_csf.CSF()
+
+# Configure parameters:
+# set_params(bSloopSmooth, cloth_resolution, iterations, class_threshold, rigidness)
+csf.set_params(True, 0.5, 500, 0.3, 1)
+
+# Pass Nx3 float64 numpy array (zero-copy buffer)
+xyz = np.random.rand(100000, 3) * 50.0
+csf.set_point_cloud(xyz)
+
+# Execute OpenMP-accelerated filtering
+# Returns list of integer indices belonging to ground points
+ground_indices = csf.do_filtering()
+print(f"Detected {len(ground_indices)} ground points out of {len(xyz)}")
+```
+
+# Building
+
+## Operating System Dependencies (Ubuntu / Debian / Linux)
+Ensure a C++14-compliant compiler and OpenMP libraries are installed:
+
+```bash
+sudo apt update
+sudo apt install -y build-essential g++ libomp-dev python3-dev
+```
+
+## Python Build Dependencies
+Install build tools in your virtual environment:
+
+```bash
+# Using uv (recommended)
+uv pip install pybind11 wheel build setuptools
+
+# Or using standard pip
+pip install pybind11 wheel build setuptools
+```
+
+## Step 1: Compile the Wheel
+From the project root, run:
+
+```bash
+# Using uv with --no-isolation (avoids Debian/Ubuntu ensurepip issues)
+uv run python -m build --no-isolation --wheel cc_csf --outdir wheels
+```
+> [!NOTE]
+> The `--no-isolation` flag uses the current environment's `pybind11` and `setuptools`, bypassing Debian/Ubuntu minimal python `ensurepip` constraints.
+
+### Step 2: Verify the Built Wheel
+The compiled binary wheel is stored in `wheels/`:
+```bash
+ls -lh wheels/
+# Output: cc_csf-1.0.0-cp312-cp312-linux_x86_64.whl 
+```
+---
+
+

cc_csf-1.0.0/README.md

@@ -0,0 +1,83 @@
+# cc_csf (Zero-Copy OpenMP Cloth Simulation Filter)
+
+High-performance Python wrapper for the Cloth Simulation Filter (CSF) algorithm using Pybind11, OpenMP parallelization, and zero-copy NumPy array buffers.
+
+## Installation
+
+### From Pre-built Wheel
+```bash
+uv pip install cc_csf-1.0.0-cp312-cp312-linux_x86_64.whl
+# or
+pip install cc_csf-1.0.0-cp312-cp312-linux_x86_64.whl
+```
+
+### From Source (In-place or install)
+```bash
+uv pip install -e .
+# or
+pip install .
+```
+
+## Quick Start Example
+
+```python
+import numpy as np
+import cc_csf
+
+# Initialize filter
+csf = cc_csf.CSF()
+
+# Configure parameters:
+# set_params(bSloopSmooth, cloth_resolution, iterations, class_threshold, rigidness)
+csf.set_params(True, 0.5, 500, 0.3, 1)
+
+# Pass Nx3 float64 numpy array (zero-copy buffer)
+xyz = np.random.rand(100000, 3) * 50.0
+csf.set_point_cloud(xyz)
+
+# Execute OpenMP-accelerated filtering
+# Returns list of integer indices belonging to ground points
+ground_indices = csf.do_filtering()
+print(f"Detected {len(ground_indices)} ground points out of {len(xyz)}")
+```
+
+# Building
+
+## Operating System Dependencies (Ubuntu / Debian / Linux)
+Ensure a C++14-compliant compiler and OpenMP libraries are installed:
+
+```bash
+sudo apt update
+sudo apt install -y build-essential g++ libomp-dev python3-dev
+```
+
+## Python Build Dependencies
+Install build tools in your virtual environment:
+
+```bash
+# Using uv (recommended)
+uv pip install pybind11 wheel build setuptools
+
+# Or using standard pip
+pip install pybind11 wheel build setuptools
+```
+
+## Step 1: Compile the Wheel
+From the project root, run:
+
+```bash
+# Using uv with --no-isolation (avoids Debian/Ubuntu ensurepip issues)
+uv run python -m build --no-isolation --wheel cc_csf --outdir wheels
+```
+> [!NOTE]
+> The `--no-isolation` flag uses the current environment's `pybind11` and `setuptools`, bypassing Debian/Ubuntu minimal python `ensurepip` constraints.
+
+### Step 2: Verify the Built Wheel
+The compiled binary wheel is stored in `wheels/`:
+```bash
+ls -lh wheels/
+# Output: cc_csf-1.0.0-cp312-cp312-linux_x86_64.whl 
+```
+---
+
+

cc_csf-1.0.0/cc_csf.cpp

@@ -0,0 +1,65 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <pybind11/stl.h>
+#include "CSF.h"
+
+namespace py = pybind11;
+
+class CSFWrapper {
+public:
+    CSF csf;
+    
+    CSFWrapper() {}
+    
+    void set_params(bool bSloopSmooth, double cloth_resolution, int iterations, double class_threshold, int rigidness) {
+        csf.params.bSloopSmooth = bSloopSmooth;
+        csf.params.cloth_resolution = cloth_resolution;
+        csf.params.interations = iterations;
+        csf.params.class_threshold = class_threshold;
+        csf.params.rigidness = rigidness;
+    }
+    
+    void set_point_cloud(py::array_t<double> xyz) {
+        py::buffer_info buf = xyz.request();
+        if (buf.ndim != 2 || buf.shape[1] != 3) {
+            throw std::runtime_error("Input array must be Nx3");
+        }
+        
+        int rows = buf.shape[0];
+        double *ptr = static_cast<double *>(buf.ptr);
+        
+        csf.getPointCloud().resize(rows);
+        
+        #ifdef CSF_USE_OPENMP
+        #pragma omp parallel for
+        #endif
+        for (int i = 0; i < rows; i++) {
+            double px = ptr[i * 3 + 0];
+            double py = ptr[i * 3 + 1];
+            double pz = ptr[i * 3 + 2];
+            
+            csf::Point p;
+            p.x = px;
+            p.y = -pz;
+            p.z = py;
+            
+            csf.getPointCloud()[i] = p;
+        }
+    }
+    
+    std::vector<int> do_filtering() {
+        std::vector<int> ground_indexes, off_ground_indexes;
+        csf.do_filtering(ground_indexes, off_ground_indexes);
+        return ground_indexes;
+    }
+};
+
+PYBIND11_MODULE(cc_csf, m) {
+    m.doc() = "Zero-copy Pybind11 wrapper for CloudCompare CSF";
+    
+    py::class_<CSFWrapper>(m, "CSF")
+        .def(py::init<>())
+        .def("set_params", &CSFWrapper::set_params)
+        .def("set_point_cloud", &CSFWrapper::set_point_cloud)
+        .def("do_filtering", &CSFWrapper::do_filtering);
+}

cc_csf-1.0.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0", "pybind11>=2.10", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cc_csf"
+version = "1.0.0"
+description = "High-performance Zero-Copy OpenMP Pybind11 Cloth Simulation Filter (CSF)"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+    { name = "Aman Ranjan", email = "er.amanranjan@gmail.com" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Development Status :: 5 - Production/Stable",
+    "Topic :: Scientific/Engineering :: GIS",
+]
+dependencies = [
+    "numpy>=1.20",
+]
+
+[tool.cibuildwheel]
+build = "cp310-* cp311-* cp312-* cp313-*"
+skip = "pp* *i686* *musllinux* *aarch64*"
+
+[tool.cibuildwheel.linux]
+manylinux-x86_64-image = "manylinux_2_28"
+repair-wheel-command = "auditwheel repair -w {dest_dir} {wheel}"

cc_csf-1.0.0/setup.cfg

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

cc_csf-1.0.0/setup.py

@@ -0,0 +1,32 @@
+from setuptools import setup, Extension
+import pybind11
+
+sources = [
+    "cc_csf.cpp",
+    "src/c2cdist.cpp",
+    "src/Cloth.cpp",
+    "src/Constraint.cpp",
+    "src/CSF.cpp",
+    "src/Particle.cpp",
+    "src/point_cloud.cpp",
+    "src/Rasterization.cpp",
+    "src/XYZReader.cpp",
+]
+
+ext_modules = [
+    Extension(
+        "cc_csf",
+        sources=sources,
+        include_dirs=[pybind11.get_include(), "src"],
+        extra_compile_args=["-O3", "-march=native", "-ffast-math", "-fopenmp", "-std=c++14"],
+        extra_link_args=["-fopenmp"],
+        define_macros=[("CSF_USE_OPENMP", "1")],
+    ),
+]
+
+setup(
+    name="cc_csf",
+    version="1.0.0",
+    description="High-performance Zero-Copy OpenMP Pybind11 Cloth Simulation Filter (CSF)",
+    ext_modules=ext_modules,
+)

cc_csf-1.0.0/src/CSF.cpp

@@ -0,0 +1,212 @@
+// ======================================================================================
+// Copyright 2017 State Key Laboratory of Remote Sensing Science, 
+// Institute of Remote Sensing Science and Engineering, Beijing Normal University
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ======================================================================================
+
+#define DLL_IMPLEMENT
+
+#include "CSF.h"
+#include "XYZReader.h"
+#include "Vec3.h"
+#include "Rasterization.h"
+#include "c2cdist.h"
+#include <fstream>
+
+
+CSF::CSF(int index) {
+    params.bSloopSmooth     = true;
+    params.time_step        = 0.65;
+    params.class_threshold  = 0.5;
+    params.cloth_resolution = 1;
+    params.rigidness        = 3;
+    params.interations      = 500;
+
+    this->index = index;
+}
+
+CSF::CSF() {
+	params.bSloopSmooth = true;
+	params.time_step = 0.65;
+	params.class_threshold = 0.5;
+	params.cloth_resolution = 1;
+	params.rigidness = 3;
+	params.interations = 500;
+	this->index = 0;
+}
+
+CSF::~CSF()
+{}
+
+void CSF::setPointCloud(std::vector<csf::Point> points) {
+    point_cloud.resize(points.size());
+
+    int pointCount = static_cast<int>(points.size());
+    #ifdef CSF_USE_OPENMP
+    #pragma omp parallel for
+    #endif
+    for (int i = 0; i < pointCount; i++) {
+        csf::Point las;
+        las.x          = points[i].x;
+        las.y          = -points[i].z;
+        las.z          = points[i].y;
+        point_cloud[i] = las;
+    }
+}
+
+void CSF::setPointCloud(double *points, int rows, int cols) {
+	point_cloud.resize(rows);
+    #define A(i, j) points[i * cols + j]
+    for (int i = 0; i < rows; i++) {
+        point_cloud[i] = {A(i, 0), -A(i, 2) , A(i, 1)};
+    }
+}
+
+
+
+void CSF::setPointCloud(double *points, int rows) {
+	#define Mat(i, j) points[i + j * rows]
+	point_cloud.resize(rows);
+    for (int i = 0; i < rows; i++) {
+        point_cloud[i] = {Mat(i, 0), -Mat(i, 2) , Mat(i, 1)};
+    }
+}
+
+void CSF::setPointCloud(csf::PointCloud& pc) {
+    point_cloud.resize(pc.size());
+    int pointCount = static_cast<int>(pc.size());
+    #ifdef CSF_USE_OPENMP
+    #pragma omp parallel for
+    #endif
+    for (int i = 0; i < pointCount; i++) {
+        csf::Point las;
+        las.x          = pc[i].x;
+        las.y          = -pc[i].z;
+        las.z          = pc[i].y;
+        point_cloud[i] = las;
+    }
+}
+
+
+void CSF::readPointsFromFile(std::string filename) {
+    this->point_cloud.resize(0);
+    read_xyz(filename, this->point_cloud);
+}
+
+
+Cloth CSF::do_cloth() {
+    // Terrain
+    std::cout << "[" << this->index << "] Configuring terrain..." << std::endl;
+    csf::Point bbMin, bbMax;
+    point_cloud.computeBoundingBox(bbMin, bbMax);
+    std::cout << "[" << this->index << "]  - bbMin: " << bbMin.x << " " << bbMin.y << " " << bbMin.z << std::endl;
+    std::cout << "[" << this->index << "]  - bbMax: " << bbMax.x << " " << bbMax.y << " " << bbMax.z << std::endl;
+
+    double cloth_y_height = 0.05;
+
+    int clothbuffer_d = 2;
+    Vec3 origin_pos(
+        bbMin.x - clothbuffer_d *params.cloth_resolution,
+        bbMax.y + cloth_y_height,
+        bbMin.z - clothbuffer_d *params.cloth_resolution
+    );
+
+    int width_num = static_cast<int>(
+        std::floor((bbMax.x - bbMin.x) / params.cloth_resolution)
+    ) + 2 * clothbuffer_d;
+
+    int height_num = static_cast<int>(
+        std::floor((bbMax.z - bbMin.z) / params.cloth_resolution)
+    ) + 2 * clothbuffer_d;
+
+    std::cout << "[" << this->index << "] Configuring cloth..." << std::endl;
+    std::cout << "[" << this->index << "]  - width: " << width_num << " "
+         << "height: " << height_num << std::endl;
+
+    Cloth cloth(
+        origin_pos,
+        width_num,
+        height_num,
+        params.cloth_resolution,
+        params.cloth_resolution,
+        0.3,
+        9999,
+        params.rigidness,
+        params.time_step
+    );
+
+    std::cout << "[" << this->index << "] Rasterizing..." << std::endl;
+    Rasterization::RasterTerrian(cloth, point_cloud, cloth.getHeightvals());
+
+    double time_step2 = params.time_step * params.time_step;
+    double gravity    = 0.2;
+
+    std::cout << "[" << this->index << "] Simulating..." << std::endl;
+    cloth.addForce(Vec3(0, -gravity, 0) * time_step2);
+
+    // boost::progress_display pd(params.interations);
+    for (int i = 0; i < params.interations; i++) {
+        double maxDiff = cloth.timeStep();
+        cloth.terrCollision();
+		//params.class_threshold / 100
+        if ((maxDiff != 0) && (maxDiff < 0.005)) {
+            // early stop
+            break;
+        }
+        // pd++;
+    }
+
+    if (params.bSloopSmooth) {
+        std::cout << "[" << this->index << "]  - post handle..." << std::endl;
+        cloth.movableFilter();
+    }
+
+    return cloth;
+}
+
+std::vector<double> CSF::do_cloth_export() {
+    auto cloth = do_cloth();
+    return cloth.toVector();
+}
+
+void CSF::do_filtering(std::vector<int>& groundIndexes,
+                      std::vector<int>& offGroundIndexes,
+                      bool exportCloth) {
+    auto cloth = do_cloth();
+    if (exportCloth)
+        cloth.saveToFile();
+    c2cdist c2c(params.class_threshold);
+    c2c.calCloud2CloudDist(cloth, point_cloud, groundIndexes, offGroundIndexes);
+}
+
+
+void CSF::savePoints(std::vector<int> grp, std::string path) {
+    if (path == "") {
+        return;
+    }
+
+    std::ofstream f1(path.c_str(), std::ios::out);
+
+    if (!f1)
+        return;
+
+    for (std::size_t i = 0; i < grp.size(); i++) {
+        f1 << std::fixed << std::setprecision(8)
+           << point_cloud[grp[i]].x  << "	"
+           << point_cloud[grp[i]].z  << "	"
+           << -point_cloud[grp[i]].y << std::endl;
+    }
+
+    f1.close();
+}

cc_csf-1.0.0/src/CSF.h

@@ -0,0 +1,133 @@
+// ======================================================================================
+// Copyright 2017 State Key Laboratory of Remote Sensing Science, 
+// Institute of Remote Sensing Science and Engineering, Beijing Normal University
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ======================================================================================
+
+// #######################################################################################
+// #                                                                                     #
+// #            CSF: Airborne LiDAR filtering based on Cloth Simulation                  #
+// #                                                                                     #
+// #  Please cite the following paper, If you use this software in your work.            #
+// #                                                                                     #
+// #  Zhang W, Qi J, Wan P, Wang H, Xie D, Wang X, Yan G. An Easy-to-Use Airborne LiDAR  #
+// #  Data Filtering Method Based on Cloth Simulation. Remote Sensing. 2016; 8(6):501.   #
+// #                               (http://ramm.bnu.edu.cn/)                             #
+// #                                                                                     #
+// #                      Wuming Zhang; Jianbo Qi; Peng Wan; Hongtao Wang                #
+// #                                                                                     #
+// #                      contact us: 2009zwm@gmail.com; wpqjbzwm@126.com                #
+// #                                                                                     #
+// #######################################################################################
+
+
+// cloth simulation filter for airborne lidar filtering
+#ifndef _CSF_H_
+#define _CSF_H_
+#include <vector>
+#include <string>
+#include "point_cloud.h"
+#include "Cloth.h"
+
+
+struct Params {
+    // refer to the website:http://ramm.bnu.edu.cn/projects/CSF/ for the setting of these paramters
+    bool bSloopSmooth;
+    double time_step;
+    double class_threshold;
+    double cloth_resolution;
+    int rigidness;
+    int interations;
+};
+
+#ifdef _CSF_DLL_EXPORT_
+# ifdef DLL_IMPLEMENT
+#  define DLL_API    __declspec(dllexport)
+# else // ifdef DLL_IMPLEMENT
+#  define DLL_API    __declspec(dllimport)
+# endif // ifdef DLL_IMPLEMENT
+#endif // ifdef _CSF_DLL_EXPORT_
+
+#ifdef _CSF_DLL_EXPORT_
+class DLL_API CSF
+#else // ifdef _CSF_DLL_EXPORT_
+class CSF
+#endif // ifdef _CSF_DLL_EXPORT_
+{
+public:
+
+    CSF(int index);
+    CSF();
+    ~CSF();
+
+    // set pointcloud from vector
+    void setPointCloud(std::vector<csf::Point> points);
+
+    // set point cloud from a two-dimentional array. it defines a N*3 point cloud by the given rows.
+    // it is the method used to set point cloud from python (numpy array)
+    void setPointCloud(double *points, int rows, int cols);
+
+    // set point cloud from a one-dimentional array. it defines a N*3 point cloud by the given rows.
+    // it is the method used to set point cloud from matlab
+    void setPointCloud(double *points, int rows);
+
+    // read pointcloud from txt file: (X Y Z) for each line
+    void readPointsFromFile(std::string filename);
+
+    inline csf::PointCloud& getPointCloud() {
+        return point_cloud;
+    }
+
+    inline const csf::PointCloud& getPointCloud() const {
+        return point_cloud;
+    }
+
+    // save points to file
+    void savePoints(std::vector<int> grp, std::string path);
+
+    // get size of pointcloud
+    std::size_t size() {
+        return point_cloud.size();
+    }
+
+    // PointCloud set pointcloud
+    void setPointCloud(csf::PointCloud& pc);
+
+    // The results are index of ground points in the original
+    // pointcloud and write the cloth particles coordinates
+    void do_filtering(std::vector<int>& groundIndexes,
+                      std::vector<int>& offGroundIndexes,
+                      bool exportCloth=true);
+    
+
+    std::vector<double> do_cloth_export();
+
+private:
+
+    // Do the filtering and return the Cloth object
+    Cloth do_cloth();
+        
+#ifdef _CSF_DLL_EXPORT_
+    class __declspec (dllexport)csf::PointCloud point_cloud;
+#else // ifdef _CSF_DLL_EXPORT_
+    csf::PointCloud point_cloud;
+#endif // ifdef _CSF_DLL_EXPORT_
+
+public:
+
+    Params params;
+    int index;
+};
+
+#endif // ifndef _CSF_H_