spatialetl-providers-common-interpcgal 0.1__tar.gz

spatialetl_providers_common_interpcgal-0.1/CMakeLists.txt

@@ -0,0 +1,50 @@
+cmake_minimum_required(VERSION 3.10.2)
+project(interpcgal)
+
+include(CheckIncludeFileCXX)
+check_include_file_cxx("cstdint" HAVE_CSTDINT)
+if(NOT HAVE_CSTDINT)
+    message(FATAL_ERROR "C++ compiler must support <cstdint>")
+endif()
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
+set(CMAKE_BUILD_TYPE Release)
+
+# Try to import all Python components potentially needed by nanobind
+find_package(Python 3.9
+  REQUIRED COMPONENTS Interpreter Development.Module
+  OPTIONAL_COMPONENTS Development.SABIModule)
+# Import nanobind through CMake's find_package mechanism
+find_package(nanobind CONFIG REQUIRED)
+
+set(SOURCE_DIR "src/")
+include_directories(${SOURCE_DIR})
+
+# We are now ready to compile the actual extension module
+nanobind_add_module(
+  # Name of the extension
+  nninterpol
+
+  # Target the stable ABI for Python 3.12+, which reduces
+  # the number of binary wheels that must be built. This
+  # does nothing on older Python versions
+  STABLE_ABI
+
+  # Source code goes here
+ ${SOURCE_DIR}/nninterpol.cpp
+)
+
+# Install directive for scikit-build-core
+install(TARGETS nninterpol LIBRARY DESTINATION spatialetl/operator/interpolator/interpcgal)
+
+find_package(CGAL CONFIG REQUIRED)
+target_link_libraries(nninterpol PRIVATE CGAL::CGAL)
+
+target_compile_definitions(nninterpol PRIVATE
+    -D__STDC_LIMIT_MACROS
+    -D__STDC_CONSTANT_MACROS
+)

spatialetl_providers_common_interpcgal-0.1/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.1
+Name: spatialetl-providers-common-interpcgal
+Version: 0.1
+Summary: Natural Neighbor Interpolation using CGAL
+Author-Email: Fabien RÉTIF <fabien.retif@snale.net>
+

spatialetl_providers_common_interpcgal-0.1/pyproject.toml

@@ -0,0 +1,44 @@
+# MIT License
+# Copyright (c) 2024 [SNALE - French SAS Company - RCS 951 724 616]
+#
+# 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.
+[build-system]
+requires = ["scikit-build-core >=0.4.3", "nanobind >=1.3.2"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "spatialetl-providers-common-interpcgal"
+version = "0.1"
+description = "Natural Neighbor Interpolation using CGAL"
+authors = [
+    {name = "Fabien RÉTIF", email = "fabien.retif@snale.net"},
+]
+
+[tool.scikit-build]
+# Protect the configuration against future changes in scikit-build-core
+minimum-version = "0.4"
+# Setuptools-style build caching in a local directory
+build-dir = "build/{wheel_tag}"
+# Build stable ABI wheels for CPython 3.12+
+wheel.py-api = "cp312"
+
+[tool.uv.sources]
+# These names must match the names as defined in the pyproject.toml of the workspace items,
+# *not* the workspace folder paths
+spatialetl = {workspace = true}

spatialetl_providers_common_interpcgal-0.1/setup.py

@@ -0,0 +1,23 @@
+# MIT License
+# Copyright (c) 2024 [SNALE - French SAS Company - RCS 951 724 616]
+#
+# 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.
+from setuptools import setup
+
+setup()

spatialetl_providers_common_interpcgal-0.1/src/nninterpol.cpp

@@ -0,0 +1,92 @@
+// Natural Neighbor Interpolation following the CGAL User Manual:
+// https://doc.cgal.org/latest/Interpolation/index.html
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/vector.h>
+
+namespace nb = nanobind;
+
+#include <cstdint>
+#include <stdint.h>
+#include <ctime>
+
+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+#include <CGAL/Delaunay_triangulation_2.h>
+#include <CGAL/Triangulation_vertex_base_with_info_2.h>
+#include <CGAL/natural_neighbor_coordinates_2.h>
+#include <CGAL/interpolation_functions.h>
+
+typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
+typedef CGAL::Triangulation_vertex_base_with_info_2<unsigned, K>    Vb;
+typedef CGAL::Triangulation_data_structure_2<Vb>      Tds;
+typedef CGAL::Delaunay_triangulation_2<K, Tds>        Delaunay_triangulation;
+typedef Delaunay_triangulation::Vertex_handle         Vertex_handle;
+typedef K::FT                                         Coord_type;
+typedef K::Point_2                                    Point;
+typedef std::vector< std::pair<Point, Coord_type> >   Coordinate_vector;
+typedef std::map<Point, Coord_type, K::Less_xy_2>     Point_value_map;
+typedef std::vector<std::vector<double>>              CVdouble2d;
+using Vdouble = nb::ndarray<double, nb::ndim<1>, nb::device::cpu>;
+using Vdouble2d = nb::ndarray<double, nb::ndim<2>, nb::device::cpu>;
+
+template<typename T>
+std::vector<std::vector<T>> make_2d_vector(std::size_t rows, std::size_t cols)
+{
+    return std::vector<std::vector<T>>(rows, std::vector<T>(cols));
+}
+
+Delaunay_triangulation triangulate(Vdouble2d candidates) {
+
+    int ntrainpoints = candidates.shape(0);
+    std::vector< std::pair<Point,unsigned> > points;
+    points.reserve(ntrainpoints);
+
+    Delaunay_triangulation T;
+    for(int i=0; i<ntrainpoints ; i++){
+        Point p(candidates(i,0), candidates(i,1));
+        points.push_back(std::make_pair(p,i));
+    }
+
+    T.insert( points.begin(),points.end() );
+    return T;
+}
+
+CVdouble2d nninterpol(Delaunay_triangulation T, Vdouble z, Vdouble2d xx, Vdouble2d yy, double fill_value) {
+    int dst_x_size = xx.shape(0);
+    int dst_y_size = xx.shape(1);
+    CVdouble2d raster = make_2d_vector<double>(dst_x_size, dst_y_size);
+    Point_value_map values;
+
+    for (Delaunay_triangulation::Vertex_handle v : T.finite_vertex_handles()) {
+          values.insert(std::make_pair(v->point(), z(v->info())));
+    }
+
+    Delaunay_triangulation::Face_handle fh;
+    for(int i=0; i<dst_x_size; i++) {
+        for(int j=0; j<dst_y_size; j++) {
+            Point p(xx(i,j), yy(i,j));
+            fh = T.locate(p, fh);
+            std::vector< std::pair< Point, Coord_type > > coords;
+            CGAL::Triple<std::back_insert_iterator<Coordinate_vector>, K::FT, bool> natneighbor = CGAL::natural_neighbor_coordinates_2(T, p, std::back_inserter(coords),fh);
+
+            if(!natneighbor.third)
+            {
+                raster[i][j] = fill_value;
+            }
+            else
+            {
+                raster[i][j] = CGAL::linear_interpolation(coords.begin(), coords.end(), natneighbor.second, CGAL::Data_access<Point_value_map>(values));
+            }
+        }
+    }
+    return raster;
+}
+
+NB_MODULE(nninterpol, m) {
+    m.doc() = "Natural Neighbor Interpolation using CGAL";
+    nb::class_<Delaunay_triangulation>(m, "Delaunay_triangulation");
+    m.def("triangulate", &triangulate, "Triangulate the source grid using CGAL");
+    m.def("nninterpol", &nninterpol,nb::call_guard<nb::gil_scoped_release>(), "Linear Interpolation using CGAL");
+}