imops 0.8.8__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

imops/cpp/interp2d/delaunator/delaunator.hpp

@@ -0,0 +1,170 @@
+// MIT License
+
+// Copyright (c) 2018 Volodymyr Bilonenko
+
+// 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.
+
+
+#pragma once
+
+#ifdef DELAUNATOR_HEADER_ONLY
+#define INLINE inline
+#else
+#define INLINE
+#endif
+
+#include <limits>
+#include <vector>
+#include <ostream>
+
+namespace delaunator {
+
+constexpr std::size_t INVALID_INDEX =
+    (std::numeric_limits<std::size_t>::max)();
+
+class Point
+{
+public:
+    Point(double x, double y) : m_x(x), m_y(y)
+    {}
+    Point() : m_x(0), m_y(0)
+    {}
+
+    double x() const
+    { return m_x; }
+
+    double y() const
+    { return m_y; }
+
+    double magnitude2() const
+    { return m_x * m_x + m_y * m_y; }
+
+    static double determinant(const Point& p1, const Point& p2)
+    {
+        return p1.m_x * p2.m_y - p1.m_y * p2.m_x;
+    }
+
+    static Point vector(const Point& p1, const Point& p2)
+    {
+        return Point(p2.m_x - p1.m_x, p2.m_y - p1.m_y);
+    }
+
+    static double dist2(const Point& p1, const Point& p2)
+    {
+        Point vec = vector(p1, p2);
+        return vec.m_x * vec.m_x + vec.m_y * vec.m_y;
+    }
+
+    static bool equal(const Point& p1, const Point& p2, double span)
+    {
+        double dist = dist2(p1, p2) / span;
+
+        // ABELL - This number should be examined to figure how how
+        // it correlates with the breakdown of calculating determinants.
+        return dist < 1e-20;
+    }
+
+private:
+    double m_x;
+    double m_y;
+};
+
+inline std::ostream& operator<<(std::ostream& out, const Point& p)
+{
+    out << p.x() << "/" << p.y();
+    return out;
+}
+
+
+class Points
+{
+public:
+    using const_iterator = Point const *;
+
+    Points(const std::vector<double>& coords) : m_coords(coords)
+    {}
+
+    const Point& operator[](size_t offset)
+    {
+        return reinterpret_cast<const Point&>(
+            *(m_coords.data() + (offset * 2)));
+    };
+
+    Points::const_iterator begin() const
+        { return reinterpret_cast<const Point *>(m_coords.data()); }
+    Points::const_iterator end() const
+        { return reinterpret_cast<const Point *>(
+            m_coords.data() + m_coords.size()); }
+    size_t size() const
+        { return m_coords.size() / 2; }
+
+private:
+    const std::vector<double>& m_coords;
+};
+
+class Delaunator {
+
+public:
+    std::vector<double> const& coords;
+    Points m_points;
+
+    // 'triangles' stores the indices to the 'X's of the input
+    // 'coords'.
+    std::vector<std::size_t> triangles;
+
+    // 'halfedges' store indices into 'triangles'.  If halfedges[X] = Y,
+    // It says that there's an edge from X to Y where a) X and Y are
+    // both indices into triangles and b) X and Y are indices into different
+    // triangles in the array.  This allows you to get from a triangle to
+    // its adjacent triangle.  If the a triangle edge has no adjacent triangle,
+    // its half edge will be INVALID_INDEX.
+    std::vector<std::size_t> halfedges;
+
+    std::vector<std::size_t> hull_prev;
+    std::vector<std::size_t> hull_next;
+
+    // This contains indexes into the triangles array.
+    std::vector<std::size_t> hull_tri;
+    std::size_t hull_start;
+
+    INLINE Delaunator(std::vector<double> const& in_coords);
+    INLINE double get_hull_area();
+    INLINE double get_triangle_area();
+
+private:
+    std::vector<std::size_t> m_hash;
+    Point m_center;
+    std::size_t m_hash_size;
+    std::vector<std::size_t> m_edge_stack;
+
+    INLINE std::size_t legalize(std::size_t a);
+    INLINE std::size_t hash_key(double x, double y) const;
+    INLINE std::size_t add_triangle(
+        std::size_t i0,
+        std::size_t i1,
+        std::size_t i2,
+        std::size_t a,
+        std::size_t b,
+        std::size_t c);
+    INLINE void link(std::size_t a, std::size_t b);
+};
+
+} //namespace delaunator
+
+#undef INLINE

imops/cpp/interp2d/interpolator.h

@@ -0,0 +1,52 @@
+#include "triangulator.h"
+
+class Interpolator {
+
+public:
+    using pyarr_double = py::array_t<double, py::array::c_style | py::array::forcecast>;
+    const Triangulator triangulation;
+    Interpolator(const Triangulator::pyarr_size_t& pypoints, int n_jobs,
+                 std::optional<Triangulator::pyarr_size_t> pytriangles)
+        : triangulation(pypoints, n_jobs, pytriangles) {
+    }
+
+    pyarr_double operator()(const Triangulator::pyarr_size_t& int_points,
+                            const pyarr_double& values, const Triangulator::pyarr_size_t& neighbors,
+                            double fill_value = 0.0) {
+        if (static_cast<long>(triangulation.points.size() / 2) != values.shape(0)) {
+            throw std::invalid_argument("Length mismatch between known points and their values");
+        }
+        if (neighbors.shape(0) != int_points.shape(0)) {
+            throw std::invalid_argument("Length mismatch between int_points and their neighbors");
+        }
+
+        size_t n = int_points.shape(0);
+        std::vector<double> int_values(n);
+
+        omp_set_dynamic(0);  // Explicitly disable dynamic teams
+        omp_set_num_threads(triangulation.n_jobs_);
+
+        #pragma parallel for
+        for (size_t i = 0; i < n; ++i) {
+            size_t x = int_points.at(i, 0);
+            size_t y = int_points.at(i, 1);
+            auto location_info = triangulation.locate_point(x, y, neighbors.at(i));
+            if (location_info.has_value()) {
+                size_t t = location_info->first;
+                auto& coords_info = location_info->second;
+                double one_over_2area = 1.0 / static_cast<double>(coords_info[3]);
+                double lambda_1 = static_cast<double>(coords_info[0]);
+                double lambda_2 = static_cast<double>(coords_info[1]);
+                double lambda_3 = static_cast<double>(coords_info[2]);
+                double f1 = values.at(triangulation.triangles.at(t));
+                double f2 = values.at(triangulation.triangles.at(t + 1));
+                double f3 = values.at(triangulation.triangles.at(t + 2));
+                int_values[i] = (f1 * lambda_1 + f2 * lambda_2 + f3 * lambda_3) * one_over_2area;
+            } else {
+                int_values[i] = fill_value;
+            }
+        }
+
+        return {{n}, {sizeof(double)}, int_values.data()};
+    }
+};

imops/cpp/interp2d/triangulator.h

@@ -0,0 +1,198 @@
+#include <omp.h>
+#include <memory>
+#include <array>
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <pybind11/embed.h>
+#include <pybind11/stl.h>
+#include "delaunator/delaunator-header-only.hpp"
+#include "utils.h"
+
+namespace py = pybind11;
+
+class Triangulator {
+private:
+    size_t n_jobs_;
+    friend class Interpolator;
+
+public:
+    using pyarr_size_t = py::array_t<size_t, py::array::c_style | py::array::forcecast>;
+    std::vector<size_t> points;
+    std::vector<size_t> triangles;
+    std::vector<std::vector<size_t>> point2tri;
+    std::unordered_map<uint64_t, std::array<size_t, 2>> edge2tri;
+
+    Triangulator(const pyarr_size_t& pypoints, int n_jobs,
+                 std::optional<pyarr_size_t> pytriangles) {
+        if (n_jobs <= 0 and n_jobs != -1) {
+            throw std::invalid_argument(
+                "Invalid number of workers, has to be -1 or positive integer");
+        }
+        if (pytriangles.has_value()) {
+            if (pytriangles->shape(1) != 3 or pytriangles->shape(0) == 0 or
+                pytriangles->size() / 3 != pytriangles->shape(0)) {
+                throw std::invalid_argument("Passed triangles argument has an incorrect shape");
+            }
+        }
+
+        n_jobs_ = n_jobs == -1 ? omp_get_num_procs() : n_jobs;
+        size_t n = pypoints.shape(0);
+
+        points.resize(2 * n);
+
+        omp_set_dynamic(0);  // Explicitly disable dynamic teams
+        omp_set_num_threads(n_jobs_);
+
+        if (pytriangles.has_value()) {
+            #pragma parallel for
+            for (size_t i = 0; i < n; ++i) {
+                size_t j = 2 * i;
+                points.at(j) = pypoints.at(i, 0);
+                points.at(j + 1) = pypoints.at(i, 1);
+            }
+
+            size_t m = pytriangles->shape(0);
+            triangles.resize(3 * m);
+
+            #pragma parallel for
+            for (size_t i = 0; i < m; ++i) {
+                size_t j = 3 * i;
+                triangles.at(j) = pytriangles->at(i, 0);
+                triangles.at(j + 1) = pytriangles->at(i, 1);
+                triangles.at(j + 2) = pytriangles->at(i, 2);
+            }
+        }
+
+        else {
+            std::vector<double> double_points(2 * n);
+            #pragma parallel for
+            for (size_t i = 0; i < n; ++i) {
+                double_points.at(2 * i) = static_cast<double>(pypoints.at(i, 0));
+                double_points.at(2 * i + 1) = static_cast<double>(pypoints.at(i, 1));
+            }
+            delaunator::Delaunator delaunated(double_points);
+            triangles = std::move(delaunated.triangles);
+
+            #pragma parallel for
+            for (size_t i = 0; i < n; ++i) {
+                size_t j = 2 * i;
+                points.at(j) = static_cast<size_t>(delaunated.coords.at(j));
+                points.at(j + 1) = static_cast<size_t>(delaunated.coords.at(j + 1));
+            }
+        }
+
+        point2tri.resize(n);
+        for (size_t i = 0; i < triangles.size() / 3; ++i) {
+            size_t t = 3 * i;
+            for (size_t j = 0; j < 3; ++j) {
+                size_t a = triangles.at(t + j);
+                size_t b = triangles.at(t + fast_mod(j + 1, 3));
+                point2tri.at(a).push_back(t);
+                uint64_t e = a < b ? elegant_pair(a, b) : elegant_pair(b, a);
+                auto got = edge2tri.find(e);
+                if (got != edge2tri.end()) {
+                    got->second.at(1) = t;
+                } else {
+                    edge2tri[e] = {t, t};
+                }
+            }
+        }
+    }
+
+    inline std::optional<std::pair<size_t, std::array<int64_t, 4>>> locate_point(
+        size_t x, size_t y, size_t neighbor) const {
+        size_t nx = points.at(2 * neighbor);
+        size_t ny = points.at(2 * neighbor + 1);
+        int64_t curr_t = -1;
+        size_t curr_a, curr_b;
+        for (size_t t : point2tri.at(neighbor)) {
+            auto coords_info = barycentric_coords(x, y, t);
+            if (point_in_triangle(coords_info)) {
+                return {std::make_pair(t, coords_info)};
+            }
+            for (size_t j = 0; j < 3; ++j) {
+                size_t a = triangles.at(t + j);
+                size_t b = triangles.at(t + fast_mod(j + 1, 3));
+                if (a == neighbor or b == neighbor) {
+                    continue;
+                }
+                size_t ax = points.at(2 * a);
+                size_t ay = points.at(2 * a + 1);
+                size_t bx = points.at(2 * b);
+                size_t by = points.at(2 * b + 1);
+                if (segments_intersection(nx, ny, x, y, ax, ay, bx, by)) {
+                    curr_t = static_cast<int64_t>(t);
+                    curr_a = a;
+                    curr_b = b;
+                    if (curr_a > curr_b) {
+                        std::swap(curr_a, curr_b);
+                    }
+                    break;
+                }
+            }
+            if (curr_t != -1) {
+                break;
+            }
+        }
+
+        if (curr_t == -1) {
+            return std::nullopt;
+        }
+
+        while (true) {
+            uint64_t e = elegant_pair(curr_a, curr_b);  // already curr_a < curr_b
+            auto& adj_t = edge2tri.at(e);
+            if (adj_t.at(0) == adj_t.at(1)) {
+                return std::nullopt;
+            }
+            size_t t = (adj_t.at(0) == static_cast<size_t>(curr_t)) ? adj_t.at(1) : adj_t.at(0);
+            auto coords_info = barycentric_coords(x, y, t);
+            if (point_in_triangle(coords_info)) {
+                return {std::make_pair(t, coords_info)};
+            }
+            for (size_t i = 0; i < 3; ++i) {
+                size_t a = triangles.at(t + i);
+                size_t b = triangles.at(t + fast_mod(i + 1, 3));
+                if (a > b) {
+                    std::swap(a, b);
+                }
+                if (a == curr_a and b == curr_b) {
+                    continue;
+                }
+                size_t ax = points.at(2 * a);
+                size_t ay = points.at(2 * a + 1);
+                size_t bx = points.at(2 * b);
+                size_t by = points.at(2 * b + 1);
+                if (segments_intersection(nx, ny, x, y, ax, ay, bx, by)) {
+                    curr_t = static_cast<int64_t>(t);
+                    curr_a = a;
+                    curr_b = b;
+                    break;
+                }
+            }
+        }
+    }
+
+    inline std::array<int64_t, 4> barycentric_coords(size_t x, size_t y, size_t t) const {
+        size_t r1 = 2 * triangles.at(t);
+        auto x1 = static_cast<int64_t>(points.at(r1));
+        auto y1 = static_cast<int64_t>(points.at(r1 + 1));
+        size_t r2 = 2 * triangles.at(t + 1);
+        auto x2 = static_cast<int64_t>(points.at(r2));
+        auto y2 = static_cast<int64_t>(points.at(r2 + 1));
+        size_t r3 = 2 * triangles.at(t + 2);
+        auto x3 = static_cast<int64_t>(points.at(r3));
+        auto y3 = static_cast<int64_t>(points.at(r3 + 1));
+        auto x1y2 = x1 * y2, x1y3 = x1 * y3;
+        auto x2y3 = x2 * y3, x2y1 = x2 * y1;
+        auto x3y1 = x3 * y1, x3y2 = x3 * y2;
+        int64_t xx = static_cast<int64_t>(x);
+        int64_t yy = static_cast<int64_t>(y);
+        std::array<int64_t, 4> coords_info;
+        coords_info[0] = x2y3 - x3y2 + (y2 - y3) * xx + (x3 - x2) * yy;
+        coords_info[1] = x3y1 - x1y3 + (y3 - y1) * xx + (x1 - x3) * yy;
+        coords_info[2] = x1y2 - x2y1 + (y1 - y2) * xx + (x2 - x1) * yy;
+        coords_info[3] = x1y2 - x1y3 + x2y3 - x2y1 + x3y1 - x3y2;
+        return coords_info;
+    }
+};

imops/cpp/interp2d/utils.h

@@ -0,0 +1,63 @@
+// Szudzik’s Pairing Function https://en.wikipedia.org/wiki/Pairing_function#Other_pairing_functions
+inline uint64_t elegant_pair(size_t a, size_t b) {
+    return static_cast<uint64_t>(b) * b + a;  // implicit cast
+}
+
+inline size_t fast_mod(const size_t i, const size_t c) {
+    return i >= c ? i % c : i;
+}
+
+inline bool on_segment(size_t Ax, size_t Ay, size_t Bx, size_t By, size_t Cx, size_t Cy) {
+    return Bx <= std::max(Ax, Cx) and Bx >= std::min(Ax, Cx) and By <= std::max(Ay, Cy) and
+           By >= std::min(Ay, Cy);
+}
+
+inline int32_t orientation(int64_t Ax, int64_t Ay, int64_t Bx, int64_t By, int64_t Cx, int64_t Cy) {
+    int64_t val = (By - Ay) * (Cx - Bx) - (Bx - Ax) * (Cy - By);
+    if (val > 0) {
+        return 1;
+    } else if (val < 0) {
+        return 2;
+    }
+    return 0;
+}
+
+inline bool segments_intersection(size_t Ax, size_t Ay, size_t Bx, size_t By, size_t Cx, size_t Cy,
+                                  size_t Dx, size_t Dy) {
+    auto o1 = orientation(Ax, Ay, Bx, By, Cx, Cy);
+    auto o2 = orientation(Ax, Ay, Bx, By, Dx, Dy);
+    auto o3 = orientation(Cx, Cy, Dx, Dy, Ax, Ay);
+    auto o4 = orientation(Cx, Cy, Dx, Dy, Bx, By);
+    if ((o1 != o2) and (o3 != o4)) {
+        return true;
+    }
+
+    if ((o1 == 0) and on_segment(Ax, Ay, Cx, Cy, Bx, By)) {
+        return true;
+    }
+
+    if ((o2 == 0) and on_segment(Ax, Ay, Dx, Dy, Bx, By)) {
+        return true;
+    }
+
+    if ((o3 == 0) and on_segment(Cx, Cy, Ax, Ay, Dx, Dy)) {
+        return true;
+    }
+
+    if ((o4 == 0) and on_segment(Cx, Cy, Bx, By, Dx, Dy)) {
+        return true;
+    }
+
+    return false;
+}
+
+inline bool point_in_triangle(const std::array<int64_t, 4>& coords_info) {
+    if (coords_info[3] < 0) {
+        return coords_info[3] <= coords_info[0] and coords_info[0] <= 0 and
+               coords_info[3] <= coords_info[1] and coords_info[1] <= 0 and
+               coords_info[3] <= coords_info[2] and coords_info[2] <= 0;
+    }
+    return coords_info[3] >= coords_info[0] and coords_info[0] >= 0 and
+           coords_info[3] >= coords_info[1] and coords_info[1] >= 0 and
+           coords_info[3] >= coords_info[2] and coords_info[2] >= 0;
+}

imops/cpp/main.cpp

@@ -0,0 +1,13 @@
+#include <cassert>
+#include <iostream>
+#include <stdexcept>
+#include "interp2d/interpolator.h"
+#include <Python.h>
+
+PYBIND11_MODULE(cpp_modules, m) {
+    py::class_<Interpolator>(m, "Linear2DInterpolatorCpp", "Interpolator class")
+        .def(py::init<const Triangulator::pyarr_size_t&, int, std::optional<Triangulator::pyarr_size_t>>())
+        .def("__call__", &Interpolator::operator());
+}
+
+int main() {}

imops/crop.py

@@ -0,0 +1,120 @@
+import numpy as np
+
+from .backend import BackendLike
+from .numeric import _NUMERIC_DEFAULT_NUM_THREADS
+from .pad import pad
+from .utils import AxesLike, AxesParams, assert_subdtype, broadcast_axis, fill_by_indices
+
+
+def crop_to_shape(x: np.ndarray, shape: AxesLike, axis: AxesLike = None, ratio: AxesParams = 0.5) -> np.ndarray:
+    """
+    Crop `x` to match `shape` along `axis`.
+
+    Parameters
+    ----------
+    x: np.ndarray
+        n-dimensional array
+    shape: AxesLike
+        final shape
+    axis: AxesLike
+        axis along which `x` will be padded
+    ratio: AxesParams
+        float or sequence of floats describing what proportion of cropping to apply on the left sides of cropping axes.
+        Remaining ratio of cropping will be applied on the right sides
+
+    Returns
+    -------
+    cropped: np.ndarray
+        cropped array
+
+    Examples
+    --------
+    ```python
+    x  # array of shape [2, 3, 4]
+    cropped = crop_to_shape(x, [1, 2, 3], ratio=0)  # crop to shape [1, 2, 3] from the right
+    cropped = crop_to_shape(x, 2, axis=1, ratio=1)  # crop to shape [2, 2, 4] from the left
+    cropped = crop_to_shape(x, [3, 4, 5])  # fail due to bigger resulting shape
+    ```
+    """
+    x = np.asarray(x)
+    shape = np.asarray(shape)
+    assert_subdtype(shape.dtype, np.integer, 'shape')
+
+    axis, shape, ratio = broadcast_axis(axis, x.ndim, shape, ratio)
+
+    old_shape, new_shape = np.array(x.shape), np.array(fill_by_indices(x.shape, shape, axis))
+    if (old_shape < new_shape).any():
+        raise ValueError(f'The resulting shape cannot be greater than the original one: {old_shape} vs {new_shape}.')
+
+    ndim = len(x.shape)
+    ratio = fill_by_indices(np.zeros(ndim), ratio, axis)
+    start = ((old_shape - new_shape) * ratio).astype(int)
+
+    # TODO: Create contiguous array?
+    return x[tuple(map(slice, start, start + new_shape))]
+
+
+def crop_to_box(
+    x: np.ndarray,
+    box: np.ndarray,
+    axis: AxesLike = None,
+    padding_values: AxesParams = None,
+    num_threads: int = _NUMERIC_DEFAULT_NUM_THREADS,
+    backend: BackendLike = None,
+) -> np.ndarray:
+    """
+    Crop `x` according to `box` along `axis`.
+
+    Parameters
+    ----------
+    x: np.ndarray
+        n-dimensional array
+    box: np.ndarray
+        array of shape (2, x.ndim or len(axis) if axis is passed) describing crop boundaries
+    axis: AxesLike
+        axis along which `x` will be cropped
+    padding_values: AxesParams
+        values to pad with if box exceeds the input's limits
+    num_threads: int
+        the number of threads to use for computation. Default = 4. If negative value passed
+        cpu count + num_threads + 1 threads will be used
+    backend: BackendLike
+        which backend to use. `cython` and `scipy` are available, `cython` is used by default
+
+    Returns
+    -------
+    cropped: np.ndarray
+        cropped array
+
+    Examples
+    --------
+    ```python
+    x  # array of shape [2, 3, 4]
+    cropped = crop_to_box(x, np.array([[0, 0, 0], [1, 1, 1]]))  # crop to shape [1, 1, 1]
+    cropped = crop_to_box(x, np.array([[0, 0, 0], [5, 5, 5]]))  # fail, box exceeds the input's limits
+    cropped = crop_to_box(x, np.array([[0], [5]]), axis=0, padding_values=0)  # pad with 0-s to shape [5, 3, 4]
+    ```
+    """
+    x = np.asarray(x)
+    box = np.asarray(box)
+    assert_subdtype(box.dtype, np.integer, 'box')
+
+    start, stop = box
+    axis, start, stop = broadcast_axis(axis, x.ndim, start, stop)
+
+    slice_start = np.maximum(start, 0)
+    slice_stop = np.minimum(stop, np.array(x.shape)[list(axis)])
+    padding = np.array([slice_start - start, stop - slice_stop], dtype=int).T
+
+    if padding_values is None and padding.any():
+        raise ValueError(f"The box {box} exceeds the input's limits {x.shape}.")
+
+    slice_start = fill_by_indices(np.zeros(x.ndim, int), slice_start, axis)
+    slice_stop = fill_by_indices(x.shape, slice_stop, axis)
+    # TODO: Create contiguous array?
+    x = x[tuple(map(slice, slice_start, slice_stop))]
+
+    if padding_values is not None and padding.any():
+        x = pad(x, padding, axis, padding_values, num_threads=num_threads, backend=backend)
+
+    return x