PyPatchMatch 2.0.0b2__tar.gz → 2.0.0rc1__tar.gz

{pypatchmatch-2.0.0b2 → pypatchmatch-2.0.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPatchMatch
-Version: 2.0.0b2
+Version: 2.0.0rc1
 Summary: This library implements the PatchMatch based inpainting algorithm.
 Keywords: inpainting,patchmatch,image-processing,opencv
 Author-Email: The InvokeAI Project <lincoln.stein@gmail.com>, Jiayuan Mao <maojiayuan@gmail.com>, Kyle Schouviller <kyle0654@hotmail.com>, Matthias Wild <mauwii@outlook.de>, Younesse ANDAM <younesse.andam@gmail.com>
@@ -52,6 +52,15 @@ OpenCV installation is needed. On other platforms, e.g. Alpine Linux or Windows
 pip builds from the source distribution, which requires a C++17 compiler, CMake and the
 OpenCV development files (e.g. `apt install libopencv-dev` or `brew install opencv`).
 
+If that build fails, PyPatchMatch is installed without the native library instead of
+blocking the installation: `patchmatch.patchmatch_available` is `False` and the
+inpainting functions raise `RuntimeError`. After installing the missing tools, reinstall
+it without the cached build:
+
+```sh
+pip install --force-reinstall --no-deps --no-cache-dir PyPatchMatch
+```
+
 ## Usage
 
 Python (see
@@ -66,17 +75,22 @@ result = patchmatch.inpaint(image, mask, patch_size=3)
 ```
 
 The mask must have the same height and width as the image. If `mask` is omitted, all
-pure white pixels are treated as holes. The optional keyword argument `global_mask`, in
-the same format, marks pixels that are neither filled nor used as a source; they keep
-their values (see
+pure white pixels are treated as holes. Only the holes are filled; all other pixels keep
+their values. The optional keyword argument `global_mask`, in the same format, marks
+pixels that are neither filled nor used as a source; they keep their values as well (see
 [examples/py_example_global_mask.py](https://github.com/mauwii/PyPatchMatch/blob/main/examples/py_example_global_mask.py)).
 `patchmatch.patchmatch_available` tells whether the native library could be loaded.
 The previous import path `from patchmatch import patch_match` keeps working.
 
+`patch_size` is the radius of the compared patches, which span `2 * patch_size + 1`
+pixels in each direction. Larger patches follow larger structures but are much slower;
+the default of 15 compares 31x31 patches, the examples use 3.
+
 `patchmatch.set_random_seed(seed)` sets the seed of the randomized search and
 `patchmatch.set_verbose(True)` prints the progress of the native code to stderr.
 `patchmatch.inpaint_regularity(image, mask, ijmap)` additionally guides the search with
-a regularity map, an HxWx3 float32 array with the regularity coordinates of each pixel.
+a regularity map, an HxWx3 float32 array with the regularity coordinates of each pixel
+in its first two channels. Its `guide_weight` must be at least 0.
 
 C++ (see
 [examples/cpp_example.cpp](https://github.com/mauwii/PyPatchMatch/blob/main/examples/cpp_example.cpp),

{pypatchmatch-2.0.0b2 → pypatchmatch-2.0.0rc1}/README.md

@@ -22,6 +22,15 @@ OpenCV installation is needed. On other platforms, e.g. Alpine Linux or Windows
 pip builds from the source distribution, which requires a C++17 compiler, CMake and the
 OpenCV development files (e.g. `apt install libopencv-dev` or `brew install opencv`).
 
+If that build fails, PyPatchMatch is installed without the native library instead of
+blocking the installation: `patchmatch.patchmatch_available` is `False` and the
+inpainting functions raise `RuntimeError`. After installing the missing tools, reinstall
+it without the cached build:
+
+```sh
+pip install --force-reinstall --no-deps --no-cache-dir PyPatchMatch
+```
+
 ## Usage
 
 Python (see
@@ -36,17 +45,22 @@ result = patchmatch.inpaint(image, mask, patch_size=3)
 ```
 
 The mask must have the same height and width as the image. If `mask` is omitted, all
-pure white pixels are treated as holes. The optional keyword argument `global_mask`, in
-the same format, marks pixels that are neither filled nor used as a source; they keep
-their values (see
+pure white pixels are treated as holes. Only the holes are filled; all other pixels keep
+their values. The optional keyword argument `global_mask`, in the same format, marks
+pixels that are neither filled nor used as a source; they keep their values as well (see
 [examples/py_example_global_mask.py](https://github.com/mauwii/PyPatchMatch/blob/main/examples/py_example_global_mask.py)).
 `patchmatch.patchmatch_available` tells whether the native library could be loaded.
 The previous import path `from patchmatch import patch_match` keeps working.
 
+`patch_size` is the radius of the compared patches, which span `2 * patch_size + 1`
+pixels in each direction. Larger patches follow larger structures but are much slower;
+the default of 15 compares 31x31 patches, the examples use 3.
+
 `patchmatch.set_random_seed(seed)` sets the seed of the randomized search and
 `patchmatch.set_verbose(True)` prints the progress of the native code to stderr.
 `patchmatch.inpaint_regularity(image, mask, ijmap)` additionally guides the search with
-a regularity map, an HxWx3 float32 array with the regularity coordinates of each pixel.
+a regularity map, an HxWx3 float32 array with the regularity coordinates of each pixel
+in its first two channels. Its `guide_weight` must be at least 0.
 
 C++ (see
 [examples/cpp_example.cpp](https://github.com/mauwii/PyPatchMatch/blob/main/examples/cpp_example.cpp),

{pypatchmatch-2.0.0b2 → pypatchmatch-2.0.0rc1}/patchmatch/_lib.py

@@ -80,9 +80,13 @@ def find_library() -> Path:
         candidate = Path(directory) / LIBRARY_NAME
         if candidate.is_file():
             return candidate
+    # Without a wheel for the platform, a failed build from the sdist installs the
+    # package without the library, see the overrides in pyproject.toml.
     raise OSError(
-        f"{LIBRARY_NAME} not found in {list(package.__path__)}; "
-        "reinstall PyPatchMatch or build it from source with OpenCV available"
+        f"{LIBRARY_NAME} not found in {list(package.__path__)}. Without a wheel for "
+        "this platform, PyPatchMatch is built from source, which needs a C++ "
+        "compiler, CMake and OpenCV. Install them and reinstall it without the "
+        "cache: pip install --force-reinstall --no-deps --no-cache-dir pypatchmatch"
     )
 
 
@@ -95,6 +99,8 @@ def load_library() -> ctypes.CDLL:
     lib.PM_set_verbose.restype = None
     lib.PM_free_pymat.argtypes = [CMatT]
     lib.PM_free_pymat.restype = None
+    lib.PM_last_error.argtypes = []
+    lib.PM_last_error.restype = ctypes.c_char_p
 
     lib.PM_inpaint.argtypes = [CMatT, CMatT, ctypes.c_int]
     lib.PM_inpaint2.argtypes = [CMatT, CMatT, CMatT, ctypes.c_int]

{pypatchmatch-2.0.0b2 → pypatchmatch-2.0.0rc1}/patchmatch/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.0.0b2'
-__version_tuple__ = version_tuple = (2, 0, 0, 'b2')
+__version__ = version = '2.0.0rc1'
+__version_tuple__ = version_tuple = (2, 0, 0, 'rc1')
 
-__commit_id__ = commit_id = 'gd8a13321b'
+__commit_id__ = commit_id = 'g75098309c'

{pypatchmatch-2.0.0b2 → pypatchmatch-2.0.0rc1}/patchmatch/csrc/inpaint.cpp

@@ -44,7 +44,6 @@ namespace
         auto source_ptr = source.get_image(ys, xs);
         auto target_ptr = target.ptr<double>(yt, xt);
 
-#pragma unroll
         for (int c = 0; c < 3; ++c)
             target_ptr[c] += static_cast<double>(source_ptr[c]) * weight;
         target_ptr[3] += weight;
@@ -126,11 +125,16 @@ cv::Mat Inpainting::run(bool verbose, bool verbose_visualize, unsigned int rando
         target = _expectation_maximization(source, target, level, verbose);
     }
 
-    // Globally masked pixels are neither filled nor used as a source, so the pyramid
-    // leaves them black. Keep their input values instead.
+    // Only the holes are filled. The votes of overlapping patches also change the known
+    // pixels near the holes, and the pyramid leaves globally masked pixels black, which
+    // are neither filled nor used as a source. Keep the input values of both.
     cv::Mat result = target.image();
+    if (result.empty()) // OpenCV rejects empty operands in matrix expressions
+        return result;
+    cv::Mat keep = m_initial.mask() == 0;
     if (!m_initial.global_mask().empty())
-        m_initial.image().copyTo(result, m_initial.global_mask());
+        keep |= m_initial.global_mask() != 0;
+    m_initial.image().copyTo(result, keep);
     return result;
 }
 

{pypatchmatch-2.0.0b2 → pypatchmatch-2.0.0rc1}/patchmatch/csrc/nnf.cpp

@@ -287,27 +287,6 @@ int PatchSSDDistanceMetric::operator()(const MaskedImage &source, int source_y,
     return distance_masked_images(source, source_y, source_x, target, target_y, target_x, m_patch_size);
 }
 
-int DebugPatchSSDDistanceMetric::operator()(const MaskedImage &source, int source_y, int source_x, const MaskedImage &target, int target_y, int target_x) const
-{
-    fprintf(stderr, "DebugPatchSSDDistanceMetric: %d %d %d %d\n", source.size().width, source.size().height, m_width, m_height);
-    return distance_masked_images(source, source_y, source_x, target, target_y, target_x, m_patch_size);
-}
-
-int RegularityGuidedPatchDistanceMetricV1::operator()(const MaskedImage &source, int source_y, int source_x, const MaskedImage &target, int target_y, int target_x) const
-{
-    double dx = remainder(double(source_x - target_x) / source.size().width, m_dx1);
-    double dy = remainder(double(source_y - target_y) / source.size().height, m_dy2);
-
-    double score1 = sqrt(dx * dx + dy * dy) / m_scale;
-    if (score1 < 0 || score1 > 1)
-        score1 = 1;
-    score1 *= PatchDistanceMetric::kDistanceScale;
-
-    double score2 = distance_masked_images(source, source_y, source_x, target, target_y, target_x, m_patch_size);
-    double score = score1 * m_weight + score2 / (1 + m_weight);
-    return static_cast<int>(score / (1 + m_weight));
-}
-
 int RegularityGuidedPatchDistanceMetricV2::operator()(const MaskedImage &source, int source_y, int source_x, const MaskedImage &target, int target_y, int target_x) const
 {
     if (target_y < 0 || target_y >= target.size().height || target_x < 0 || target_x >= target.size().width)
@@ -338,6 +317,11 @@ int RegularityGuidedPatchDistanceMetricV2::operator()(const MaskedImage &source,
     }
 
     double score2 = distance_masked_images(source, source_y, source_x, target, target_y, target_x, m_patch_size);
-    double score = score1 * m_weight + score2;
-    return int(score / (1 + m_weight));
+    double score = (score1 * m_weight + score2) / (1 + m_weight);
+    // The distance indexes the similarity table in Inpainting, so keep it in range.
+    if (!(score > 0))
+        return 0;
+    if (score >= PatchDistanceMetric::kDistanceScale)
+        return PatchDistanceMetric::kDistanceScale;
+    return static_cast<int>(score);
 }

{pypatchmatch-2.0.0b2 → pypatchmatch-2.0.0rc1}/patchmatch/csrc/nnf.h

@@ -1,7 +1,6 @@
 #pragma once
 
-#include <cassert>
-#include <cmath>
+#include <stdexcept>
 #include <opencv2/core.hpp>
 #include "masked_image.h"
 
@@ -116,44 +115,19 @@ public:
     static const int kSSDScale;
 };
 
-class DebugPatchSSDDistanceMetric : public PatchDistanceMetric
-{
-public:
-    DebugPatchSSDDistanceMetric(int patch_size, int width, int height) : PatchDistanceMetric(patch_size), m_width(width), m_height(height) {}
-    virtual int operator()(const MaskedImage &source, int source_y, int source_x, const MaskedImage &target, int target_y, int target_x) const;
-
-protected:
-    int m_width, m_height;
-};
-
-class RegularityGuidedPatchDistanceMetricV1 : public PatchDistanceMetric
-{
-public:
-    RegularityGuidedPatchDistanceMetricV1(int patch_size, double dx1, double dy1, double dx2, double dy2, double weight)
-        : PatchDistanceMetric(patch_size), m_dx1(dx1), m_dy1(dy1), m_dx2(dx2), m_dy2(dy2), m_weight(weight)
-    {
-
-        assert(m_dy1 == 0);
-        assert(m_dx2 == 0);
-        m_scale = sqrt(m_dx1 * m_dx1 + m_dy2 * m_dy2) / 4;
-    }
-    virtual int operator()(const MaskedImage &source, int source_y, int source_x, const MaskedImage &target, int target_y, int target_x) const;
-
-protected:
-    double m_dx1, m_dy1, m_dx2, m_dy2;
-    double m_scale, m_weight;
-};
-
 class RegularityGuidedPatchDistanceMetricV2 : public PatchDistanceMetric
 {
 public:
     RegularityGuidedPatchDistanceMetricV2(int patch_size, cv::Mat ijmap, double weight)
         : PatchDistanceMetric(patch_size), m_ijmap(ijmap), m_weight(weight)
     {
+        // The distance is divided by 1 + weight, so a negative weight flips its sign.
+        if (!(weight >= 0))
+            throw std::invalid_argument("the guide weight must be >= 0");
     }
     virtual int operator()(const MaskedImage &source, int source_y, int source_x, const MaskedImage &target, int target_y, int target_x) const;
 
 protected:
     cv::Mat m_ijmap;
-    double m_width, m_height, m_weight;
+    double m_weight;
 };

pypatchmatch-2.0.0rc1/patchmatch/csrc/pyinterface.cpp

@@ -0,0 +1,214 @@
+#include <atomic>
+#include <cstring>
+#include <exception>
+#include <memory>
+#include <string>
+
+#include "pyinterface.h"
+#include "inpaint.h"
+
+int _dtype_py_to_cv(int dtype_py);
+int _dtype_cv_to_py(int dtype_cv);
+cv::Mat _py_to_cv2(PM_mat_t pymat);
+PM_mat_t _cv2_to_py(cv::Mat cvmat);
+
+namespace
+{
+    // The settings are set by one thread while others may be inpainting, since ctypes
+    // releases the GIL.
+    std::atomic<unsigned int> &random_seed()
+    {
+        static std::atomic value{1212u};
+        return value;
+    }
+
+    std::atomic<bool> &verbose()
+    {
+        static std::atomic value{false};
+        return value;
+    }
+
+    // Message of the last failed call on the calling thread, see PM_last_error.
+    std::string &last_error()
+    {
+        thread_local std::string message;
+        return message;
+    }
+
+    void set_last_error(const char *message) noexcept
+    {
+        try
+        {
+            last_error() = message;
+        }
+        catch (...)
+        {
+            last_error().clear();
+        }
+    }
+
+    // A C++ exception must not propagate through the C interface into ctypes, which
+    // would abort the process. Report it with an empty result instead.
+    template <typename Func>
+    PM_mat_t guarded(Func &&func) noexcept
+    {
+        try
+        {
+            return func();
+        }
+        catch (const std::exception &e)
+        {
+            set_last_error(e.what());
+        }
+        catch (...)
+        {
+            set_last_error("unknown error");
+        }
+        return PM_mat_t{nullptr, {0, 0, 0}, 0};
+    }
+}
+
+const char *PM_last_error()
+{
+    return last_error().c_str();
+}
+
+void PM_set_random_seed(unsigned int seed)
+{
+    random_seed().store(seed);
+}
+
+void PM_set_verbose(int value)
+{
+    verbose().store(value != 0);
+}
+
+void PM_free_pymat(PM_mat_t pymat)
+{
+    // Takes back the ownership of the buffer that _cv2_to_py released. The buffer
+    // crosses the C interface as a plain pointer, so it cannot be a std::vector
+    // (SonarCloud cpp:S5945).
+    std::unique_ptr<unsigned char[]> data(static_cast<unsigned char *>(pymat.data_ptr)); // NOSONAR
+}
+
+PM_mat_t PM_inpaint(PM_mat_t source_py, PM_mat_t mask_py, int patch_size)
+{
+    return guarded([source_py, mask_py, patch_size] {
+        cv::Mat source = _py_to_cv2(source_py);
+        cv::Mat mask = _py_to_cv2(mask_py);
+        auto metric = PatchSSDDistanceMetric(patch_size);
+        cv::Mat result = Inpainting(source, mask, &metric).run(verbose().load(), false, random_seed().load());
+        return _cv2_to_py(result);
+    });
+}
+
+PM_mat_t PM_inpaint_regularity(PM_mat_t source_py, PM_mat_t mask_py, PM_mat_t ijmap_py, int patch_size, float guide_weight)
+{
+    return guarded([source_py, mask_py, ijmap_py, patch_size, guide_weight] {
+        cv::Mat source = _py_to_cv2(source_py);
+        cv::Mat mask = _py_to_cv2(mask_py);
+        cv::Mat ijmap = _py_to_cv2(ijmap_py);
+
+        auto metric = RegularityGuidedPatchDistanceMetricV2(patch_size, ijmap, guide_weight);
+        cv::Mat result = Inpainting(source, mask, &metric).run(verbose().load(), false, random_seed().load());
+        return _cv2_to_py(result);
+    });
+}
+
+PM_mat_t PM_inpaint2(PM_mat_t source_py, PM_mat_t mask_py, PM_mat_t global_mask_py, int patch_size)
+{
+    return guarded([source_py, mask_py, global_mask_py, patch_size] {
+        cv::Mat source = _py_to_cv2(source_py);
+        cv::Mat mask = _py_to_cv2(mask_py);
+        cv::Mat global_mask = _py_to_cv2(global_mask_py);
+
+        auto metric = PatchSSDDistanceMetric(patch_size);
+        cv::Mat result = Inpainting(source, mask, global_mask, &metric).run(verbose().load(), false, random_seed().load());
+        return _cv2_to_py(result);
+    });
+}
+
+PM_mat_t PM_inpaint2_regularity(PM_mat_t source_py, PM_mat_t mask_py, PM_mat_t global_mask_py, PM_mat_t ijmap_py, int patch_size, float guide_weight)
+{
+    return guarded([source_py, mask_py, global_mask_py, ijmap_py, patch_size, guide_weight] {
+        cv::Mat source = _py_to_cv2(source_py);
+        cv::Mat mask = _py_to_cv2(mask_py);
+        cv::Mat global_mask = _py_to_cv2(global_mask_py);
+        cv::Mat ijmap = _py_to_cv2(ijmap_py);
+
+        auto metric = RegularityGuidedPatchDistanceMetricV2(patch_size, ijmap, guide_weight);
+        cv::Mat result = Inpainting(source, mask, global_mask, &metric).run(verbose().load(), false, random_seed().load());
+        return _cv2_to_py(result);
+    });
+}
+
+int _dtype_py_to_cv(int dtype_py)
+{
+    switch (dtype_py)
+    {
+    case PM_UINT8:
+        return CV_8U;
+    case PM_INT8:
+        return CV_8S;
+    case PM_UINT16:
+        return CV_16U;
+    case PM_INT16:
+        return CV_16S;
+    case PM_INT32:
+        return CV_32S;
+    case PM_FLOAT32:
+        return CV_32F;
+    case PM_FLOAT64:
+        return CV_64F;
+    }
+
+    return CV_8U;
+}
+
+int _dtype_cv_to_py(int dtype_cv)
+{
+    switch (dtype_cv)
+    {
+    case CV_8U:
+        return PM_UINT8;
+    case CV_8S:
+        return PM_INT8;
+    case CV_16U:
+        return PM_UINT16;
+    case CV_16S:
+        return PM_INT16;
+    case CV_32S:
+        return PM_INT32;
+    case CV_32F:
+        return PM_FLOAT32;
+    case CV_64F:
+        return PM_FLOAT64;
+    }
+
+    return PM_UINT8;
+}
+
+cv::Mat _py_to_cv2(PM_mat_t pymat)
+{
+    int dtype = CV_MAKETYPE(_dtype_py_to_cv(pymat.dtype), pymat.shape.channels);
+    return cv::Mat(cv::Size(pymat.shape.width, pymat.shape.height), dtype, pymat.data_ptr).clone();
+}
+
+PM_mat_t _cv2_to_py(cv::Mat cvmat)
+{
+    if (!cvmat.isContinuous())
+        cvmat = cvmat.clone();
+
+    PM_shape_t shape = {cvmat.size().width, cvmat.size().height, cvmat.channels()};
+    int dtype = _dtype_cv_to_py(cvmat.depth());
+    size_t dsize = cvmat.total() * cvmat.elemSize();
+
+    // A null pointer reports an error to Python, so allocate at least one byte. A failed
+    // allocation throws std::bad_alloc, which guarded() reports.
+    auto data = std::make_unique<unsigned char[]>(dsize > 0 ? dsize : 1);
+    if (dsize > 0)
+        std::memcpy(data.get(), cvmat.data, dsize);
+
+    // Python passes the buffer back to PM_free_pymat, which frees it.
+    return PM_mat_t{data.release(), shape, dtype};
+}

{pypatchmatch-2.0.0b2 → pypatchmatch-2.0.0rc1}/patchmatch/csrc/pyinterface.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <opencv2/core.hpp>
 #include <cstdlib>
 #include <cstdio>
@@ -29,6 +31,10 @@ extern "C"
         int dtype;
     };
 
+    // The PM_inpaint* functions return a null data_ptr on failure; this returns the
+    // error message of the last failure on the calling thread.
+    const char *PM_last_error(void);
+
     void PM_set_random_seed(unsigned int seed);
     void PM_set_verbose(int value);
 

{pypatchmatch-2.0.0b2 → pypatchmatch-2.0.0rc1}/patchmatch/patch_match.py

@@ -17,6 +17,8 @@ from __future__ import annotations
 
 import ctypes
 import logging
+import math
+import operator
 from collections.abc import Callable
 from typing import TypeAlias
 
@@ -47,6 +49,9 @@ except OSError as e:
 # True if the native library was loaded successfully.
 patchmatch_available = _lib is not None
 
+# The native code computes 2 * patch_size + 1 as a C int.
+_MAX_PATCH_SIZE = (2**31 - 2) // 2
+
 
 def _get_lib() -> ctypes.CDLL:
     if _lib is None:
@@ -78,13 +83,17 @@ def inpaint(
             white pixels (255, 255, 255) are treated as holes.
         global_mask: mask like ``mask`` of pixels that are neither filled nor used as
             a source; they keep their values from ``image``.
-        patch_size: patch size for the inpainting algorithm.
+        patch_size: radius of the compared patches, which span
+            ``(2 * patch_size + 1) ** 2`` pixels. Larger patches follow larger
+            structures but are much slower; the examples use 3.
 
     Returns:
-        The repaired image, with the same shape as ``image``.
+        The repaired image, with the same shape as ``image``. Only the holes are
+        filled; all other pixels keep their values from ``image``.
     """
     lib = _get_lib()
-    image, mask, global_mask = _prepare_inputs(image, mask, global_mask, patch_size)
+    patch_size = _check_patch_size(patch_size)
+    image, mask, global_mask = _prepare_inputs(image, mask, global_mask)
 
     if global_mask is None:
         return _call(lib.PM_inpaint, image, mask, ctypes.c_int(patch_size))
@@ -103,12 +112,15 @@ def inpaint_regularity(
     """Like :func:`inpaint`, additionally guided by a regularity map.
 
     Args:
-        ijmap: HxWx3 float32 array with the regularity coordinates of each pixel;
-            a map of a different size is scaled to the image.
-        guide_weight: weight of the regularity term relative to the patch distance.
+        ijmap: HxWx3 float32 array of finite values with the regularity coordinates
+            of each pixel in the first two channels; the third channel is unused.
+            A map of a different size is scaled to the image.
+        guide_weight: non-negative weight of the regularity term relative to the
+            patch distance.
     """
     lib = _get_lib()
-    image, mask, global_mask = _prepare_inputs(image, mask, global_mask, patch_size)
+    patch_size = _check_patch_size(patch_size)
+    image, mask, global_mask = _prepare_inputs(image, mask, global_mask)
 
     if not (
         isinstance(ijmap, np.ndarray)
@@ -118,25 +130,46 @@ def inpaint_regularity(
         and ijmap.size > 0
     ):
         raise ValueError("ijmap must be a non-empty HxWx3 float32 array")
+    # NaN and infinity turn into out-of-range patch distances in the native code
+    if not np.isfinite(ijmap).all():
+        raise ValueError("ijmap must only contain finite values")
     ijmap = np.ascontiguousarray(ijmap)
 
+    # the native code divides by 1 + guide_weight and indexes a table with the result
+    guide_weight = float(guide_weight)
+    if not (math.isfinite(guide_weight) and guide_weight >= 0):
+        raise ValueError(
+            f"guide_weight must be a finite number >= 0, got {guide_weight}"
+        )
+
     args = (ijmap, ctypes.c_int(patch_size), ctypes.c_float(guide_weight))
     if global_mask is None:
         return _call(lib.PM_inpaint_regularity, image, mask, *args)
     return _call(lib.PM_inpaint2_regularity, image, mask, global_mask, *args)
 
 
+def _check_patch_size(patch_size: int) -> int:
+    try:
+        patch_size = operator.index(patch_size)
+    except TypeError:
+        raise TypeError(
+            f"patch_size must be an integer, got {type(patch_size).__name__}"
+        ) from None
+    # The native code crashes for 0 and never terminates for negative sizes. ctypes
+    # silently wraps larger values into the C int range, e.g. 2**31 to a negative size.
+    if not 1 <= patch_size <= _MAX_PATCH_SIZE:
+        raise ValueError(
+            f"patch_size must be between 1 and {_MAX_PATCH_SIZE}, got {patch_size}"
+        )
+    return patch_size
+
+
 def _prepare_inputs(
     image: ImageLike,
     mask: ImageLike | None,
     global_mask: ImageLike | None,
-    patch_size: int,
 ) -> tuple[np.ndarray, np.ndarray, np.ndarray | None]:
     """Validate the inputs and convert them to contiguous arrays."""
-    # the native code crashes for 0 and never terminates for negative sizes
-    if patch_size < 1:
-        raise ValueError(f"patch_size must be at least 1, got {patch_size}")
-
     image = _canonize_image_array(image)
     mask = _default_mask(image) if mask is None else _canonize_mask_array(mask)
     if global_mask is not None:
@@ -154,12 +187,17 @@ def _prepare_inputs(
 
 def _call(func: Callable[..., CMatT], *args: object) -> np.ndarray:
     """Call ``func`` with arrays converted to pymats and copy the result."""
+    lib = _get_lib()
     c_args = [np_to_pymat(a) if isinstance(a, np.ndarray) else a for a in args]
     ret = func(*c_args)
+    if not ret.data_ptr:
+        # the error message is kept per thread, like the call itself
+        message = lib.PM_last_error().decode(errors="replace").strip()
+        raise RuntimeError(f"patchmatch failed: {message}")
     try:
         return pymat_to_np(ret)
     finally:
-        _get_lib().PM_free_pymat(ret)
+        lib.PM_free_pymat(ret)
 
 
 def _canonize_image_array(image: ImageLike) -> np.ndarray:

{pypatchmatch-2.0.0b2 → pypatchmatch-2.0.0rc1}/pyproject.toml

@@ -59,6 +59,15 @@ metadata.version.provider = "scikit_build_core.metadata.setuptools_scm"
 sdist.include = ["examples/images/forest_pruned.bmp", "patchmatch/_version.py"]
 sdist.exclude = [".*", "examples", "uv.lock"]
 
+# Without a matching wheel, pip builds the sdist, which needs a C++ compiler, CMake and
+# OpenCV. If that fails, build a wheel without the native library instead of failing
+# the installation; patchmatch_available is then False, as with 1.x. Builds from the
+# source tree still fail, and cibuildwheel rejects the pure wheel of a failed build.
+[[tool.scikit-build.overrides]]
+if.from-sdist = true
+if.failed = true
+wheel.cmake = false
+
 [tool.setuptools_scm]
 version_file = "patchmatch/_version.py"
 # used when building without git metadata, e.g. from a GitHub source archive

{pypatchmatch-2.0.0b2 → pypatchmatch-2.0.0rc1}/scripts/build_opencv.py

@@ -6,6 +6,7 @@ wheels small and free of OpenCV's GUI/codec dependencies.
 Usage: python build_opencv.py  (installs into $OpenCV_ROOT)
 """
 
+import hashlib
 import os
 import shutil
 import subprocess
@@ -19,6 +20,9 @@ OPENCV_VERSION = "4.14.0"
 OPENCV_URL = (
     f"https://github.com/opencv/opencv/archive/refs/tags/{OPENCV_VERSION}.tar.gz"
 )
+# The wheels link this code statically, so the archive is pinned by its SHA-256.
+# Update it together with the version, e.g. with `sha256sum` or `shasum -a 256`.
+OPENCV_SHA256 = "ee8fb9b30eb60850431b4656447080e3737b56e45719c92b67f245950609f86e"
 
 CMAKE_OPTIONS = {
     "CMAKE_BUILD_TYPE": "Release",
@@ -87,6 +91,18 @@ def find_cmake() -> str:
     return str(scripts / ("cmake.exe" if os.name == "nt" else "cmake"))
 
 
+def verify_archive(archive: Path) -> None:
+    sha256 = hashlib.sha256()
+    with archive.open("rb") as f:
+        for chunk in iter(lambda: f.read(1 << 20), b""):
+            sha256.update(chunk)
+    if sha256.hexdigest() != OPENCV_SHA256:
+        sys.exit(
+            f"SHA-256 mismatch for {OPENCV_URL}: "
+            f"expected {OPENCV_SHA256}, got {sha256.hexdigest()}"
+        )
+
+
 def main() -> None:
     # OpenCV_ROOT is the variable CMake's find_package(OpenCV) looks for.
     root = os.environ.get("OpenCV_ROOT")  # noqa: SIM112
@@ -102,6 +118,7 @@ def main() -> None:
         archive = Path(tmp) / "opencv.tar.gz"
         print(f"Downloading {OPENCV_URL}", flush=True)
         urllib.request.urlretrieve(OPENCV_URL, archive)
+        verify_archive(archive)
         with tarfile.open(archive) as tar:
             # extraction filters are missing on older patch releases, e.g. the
             # last Windows installer of Python 3.10 (3.10.11)

{pypatchmatch-2.0.0b2 → pypatchmatch-2.0.0rc1}/tests/test_e2e.py

@@ -41,9 +41,8 @@ def assert_plausible_fill(
 
     assert not white_pixels(result)[holes].any(), "holes were not filled"
 
-    # the known part of the image is reconstructed almost unchanged
-    outside = np.abs(result[~holes].astype(float) - source[~holes]).mean()
-    assert outside < 1, outside
+    # only the holes are filled
+    np.testing.assert_array_equal(result[~holes], source[~holes])
 
     # the filling blends in with its surroundings
     band = surrounding(holes) & ~excluded

{pypatchmatch-2.0.0b2 → pypatchmatch-2.0.0rc1}/tests/test_patch_match.py

@@ -45,9 +45,13 @@ def seed():
 
 
 def assert_filled(result: np.ndarray, source: np.ndarray) -> None:
+    """The hole is filled and all other pixels keep their values."""
     assert result.shape == source.shape
     assert result.dtype == np.uint8
     assert not (result[HOLE] == 255).all(axis=-1).any()
+    known = np.ones(source.shape[:2], dtype=bool)
+    known[HOLE] = False
+    np.testing.assert_array_equal(result[known], source[known])
 
 
 # --- package ----------------------------------------------------------------
@@ -79,6 +83,8 @@ def test_inpaint_explicit_mask(image, hole_mask):
     result = patchmatch.inpaint(image, hole_mask, patch_size=3)
     assert result.shape == image.shape
     assert (result[HOLE] != 0).any()
+    known = hole_mask == 0
+    np.testing.assert_array_equal(result[known], image[known])
 
 
 def test_inpaint_global_mask(image, hole_mask):
@@ -90,6 +96,14 @@ def test_inpaint_global_mask(image, hole_mask):
     np.testing.assert_array_equal(result[:8], image[:8])
 
 
+@pytest.mark.parametrize("shape", [(0, 0, 3), (0, 10, 3), (10, 0, 3)])
+def test_inpaint_empty_image(shape):
+    empty = np.zeros(shape, dtype=np.uint8)
+    global_mask = np.zeros(shape[:2], dtype=np.uint8)
+    assert patchmatch.inpaint(empty, patch_size=3).shape == shape
+    assert patchmatch.inpaint(empty, global_mask=global_mask).shape == shape
+
+
 @pytest.mark.parametrize("patch_size", [1, 3, 7])
 def test_inpaint_patch_sizes(image, patch_size):
     assert_filled(patchmatch.inpaint(image, patch_size=patch_size), image)
@@ -243,7 +257,8 @@ def test_mask_size_must_match_image(image, ijmap, func, argument):
         func(image, **kwargs)
 
 
-@pytest.mark.parametrize("patch_size", [0, -1])
+# 2**31 wrapped to a negative C int, which never terminated
+@pytest.mark.parametrize("patch_size", [0, -1, 2**30, 2**31])
 @pytest.mark.parametrize(
     "func",
     [patchmatch.inpaint, patchmatch.inpaint_regularity],
@@ -255,6 +270,18 @@ def test_invalid_patch_size(image, ijmap, func, patch_size):
         func(image, None, patch_size=patch_size, **kwargs)
 
 
+def test_patch_size_must_be_an_integer(image):
+    with pytest.raises(TypeError, match="patch_size must be an integer"):
+        patchmatch.inpaint(image, patch_size=3.0)
+
+
+def test_patch_size_accepts_numpy_integers(image):
+    expected = patchmatch.inpaint(image, patch_size=3)
+    np.testing.assert_array_equal(
+        patchmatch.inpaint(image, patch_size=np.int64(3)), expected
+    )
+
+
 @pytest.mark.parametrize(
     "bad_ijmap",
     [
@@ -262,14 +289,46 @@ def test_invalid_patch_size(image, ijmap, func, patch_size):
         np.zeros((HEIGHT, WIDTH, 2), dtype=np.float32),
         np.zeros((0, WIDTH, 3), dtype=np.float32),
         [[[0.0, 0.0, 0.0]]],
+        np.full((HEIGHT, WIDTH, 3), np.nan, dtype=np.float32),
+        np.full((HEIGHT, WIDTH, 3), np.inf, dtype=np.float32),
     ],
-    ids=["float64", "2-channel", "empty", "list"],
+    ids=["float64", "2-channel", "empty", "list", "nan", "inf"],
 )
 def test_inpaint_regularity_invalid_ijmap(image, bad_ijmap):
     with pytest.raises(ValueError, match="ijmap"):
         patchmatch.inpaint_regularity(image, None, bad_ijmap)
 
 
+@pytest.mark.parametrize("guide_weight", [-1.0, -0.5, float("nan"), float("inf")])
+def test_inpaint_regularity_invalid_guide_weight(image, ijmap, guide_weight):
+    # a weight of -1 used to crash the native code, other negative weights made it
+    # read outside of the similarity table
+    with pytest.raises(ValueError, match="guide_weight"):
+        patchmatch.inpaint_regularity(image, None, ijmap, guide_weight=guide_weight)
+
+
+# --- native errors ----------------------------------------------------------
+
+
+def test_native_exception_raises_runtime_error():
+    # A null data pointer with a non-empty shape fails an OpenCV assertion. The
+    # exception must not propagate through the C interface and abort the process.
+    lib = patch_match._get_lib()
+    bad = _lib.CMatT(None, _lib.CShapeT(4, 4, 3), 0)
+    args = (bad, bad, ctypes.c_int(3))
+    with pytest.raises(RuntimeError, match=r"patchmatch failed: .*Assertion failed"):
+        patch_match._call(lib.PM_inpaint, *args)
+
+
+def test_native_rejects_negative_guide_weight(image, hole_mask, ijmap):
+    """The C++ metric checks the weight as well, for callers that bypass Python."""
+    lib = patch_match._get_lib()
+    mask = hole_mask[..., np.newaxis]
+    args = (image, mask, ijmap, ctypes.c_int(3), ctypes.c_float(-1))
+    with pytest.raises(RuntimeError, match="guide weight must be >= 0"):
+        patch_match._call(lib.PM_inpaint_regularity, *args)
+
+
 # --- missing native library -------------------------------------------------
 
 
@@ -297,6 +356,27 @@ def test_find_library_reports_missing_file(monkeypatch):
         _lib.find_library()
 
 
+def test_import_without_native_library():
+    """A failed build from the sdist installs the package without the library.
+
+    The import has to work and explain how to fix it, see the overrides in
+    pyproject.toml. The module is reloaded in a separate process, so the other
+    tests keep the loaded library.
+    """
+    code = (
+        "import importlib\n"
+        "from patchmatch import _lib, patch_match\n"
+        "_lib.LIBRARY_NAME = 'missing-library'\n"
+        "importlib.reload(patch_match)\n"
+        "assert not patch_match.patchmatch_available\n"
+    )
+    process = subprocess.run(
+        [sys.executable, "-c", code], capture_output=True, text=True, check=True
+    )
+    assert "missing-library not found" in process.stderr
+    assert "--no-cache-dir" in process.stderr
+
+
 # --- ctypes conversion ------------------------------------------------------
 
 

pypatchmatch-2.0.0b2/patchmatch/csrc/pyinterface.cpp

@@ -1,132 +0,0 @@
-#include "pyinterface.h"
-#include "inpaint.h"
-
-static unsigned int PM_seed = 1212;
-static bool PM_verbose = false;
-
-int _dtype_py_to_cv(int dtype_py);
-int _dtype_cv_to_py(int dtype_cv);
-cv::Mat _py_to_cv2(PM_mat_t pymat);
-PM_mat_t _cv2_to_py(cv::Mat cvmat);
-
-void PM_set_random_seed(unsigned int seed)
-{
-    PM_seed = seed;
-}
-
-void PM_set_verbose(int value)
-{
-    PM_verbose = static_cast<bool>(value);
-}
-
-void PM_free_pymat(PM_mat_t pymat)
-{
-    free(pymat.data_ptr);
-}
-
-PM_mat_t PM_inpaint(PM_mat_t source_py, PM_mat_t mask_py, int patch_size)
-{
-    cv::Mat source = _py_to_cv2(source_py);
-    cv::Mat mask = _py_to_cv2(mask_py);
-    auto metric = PatchSSDDistanceMetric(patch_size);
-    cv::Mat result = Inpainting(source, mask, &metric).run(PM_verbose, false, PM_seed);
-    return _cv2_to_py(result);
-}
-
-PM_mat_t PM_inpaint_regularity(PM_mat_t source_py, PM_mat_t mask_py, PM_mat_t ijmap_py, int patch_size, float guide_weight)
-{
-    cv::Mat source = _py_to_cv2(source_py);
-    cv::Mat mask = _py_to_cv2(mask_py);
-    cv::Mat ijmap = _py_to_cv2(ijmap_py);
-
-    auto metric = RegularityGuidedPatchDistanceMetricV2(patch_size, ijmap, guide_weight);
-    cv::Mat result = Inpainting(source, mask, &metric).run(PM_verbose, false, PM_seed);
-    return _cv2_to_py(result);
-}
-
-PM_mat_t PM_inpaint2(PM_mat_t source_py, PM_mat_t mask_py, PM_mat_t global_mask_py, int patch_size)
-{
-    cv::Mat source = _py_to_cv2(source_py);
-    cv::Mat mask = _py_to_cv2(mask_py);
-    cv::Mat global_mask = _py_to_cv2(global_mask_py);
-
-    auto metric = PatchSSDDistanceMetric(patch_size);
-    cv::Mat result = Inpainting(source, mask, global_mask, &metric).run(PM_verbose, false, PM_seed);
-    return _cv2_to_py(result);
-}
-
-PM_mat_t PM_inpaint2_regularity(PM_mat_t source_py, PM_mat_t mask_py, PM_mat_t global_mask_py, PM_mat_t ijmap_py, int patch_size, float guide_weight)
-{
-    cv::Mat source = _py_to_cv2(source_py);
-    cv::Mat mask = _py_to_cv2(mask_py);
-    cv::Mat global_mask = _py_to_cv2(global_mask_py);
-    cv::Mat ijmap = _py_to_cv2(ijmap_py);
-
-    auto metric = RegularityGuidedPatchDistanceMetricV2(patch_size, ijmap, guide_weight);
-    cv::Mat result = Inpainting(source, mask, global_mask, &metric).run(PM_verbose, false, PM_seed);
-    return _cv2_to_py(result);
-}
-
-int _dtype_py_to_cv(int dtype_py)
-{
-    switch (dtype_py)
-    {
-    case PM_UINT8:
-        return CV_8U;
-    case PM_INT8:
-        return CV_8S;
-    case PM_UINT16:
-        return CV_16U;
-    case PM_INT16:
-        return CV_16S;
-    case PM_INT32:
-        return CV_32S;
-    case PM_FLOAT32:
-        return CV_32F;
-    case PM_FLOAT64:
-        return CV_64F;
-    }
-
-    return CV_8U;
-}
-
-int _dtype_cv_to_py(int dtype_cv)
-{
-    switch (dtype_cv)
-    {
-    case CV_8U:
-        return PM_UINT8;
-    case CV_8S:
-        return PM_INT8;
-    case CV_16U:
-        return PM_UINT16;
-    case CV_16S:
-        return PM_INT16;
-    case CV_32S:
-        return PM_INT32;
-    case CV_32F:
-        return PM_FLOAT32;
-    case CV_64F:
-        return PM_FLOAT64;
-    }
-
-    return PM_UINT8;
-}
-
-cv::Mat _py_to_cv2(PM_mat_t pymat)
-{
-    int dtype = CV_MAKETYPE(_dtype_py_to_cv(pymat.dtype), pymat.shape.channels);
-    return cv::Mat(cv::Size(pymat.shape.width, pymat.shape.height), dtype, pymat.data_ptr).clone();
-}
-
-PM_mat_t _cv2_to_py(cv::Mat cvmat)
-{
-    PM_shape_t shape = {cvmat.size().width, cvmat.size().height, cvmat.channels()};
-    int dtype = _dtype_cv_to_py(cvmat.depth());
-    size_t dsize = cvmat.total() * cvmat.elemSize();
-
-    void *data_ptr = reinterpret_cast<void *>(malloc(dsize));
-    memcpy(data_ptr, reinterpret_cast<void *>(cvmat.data), dsize);
-
-    return PM_mat_t{data_ptr, shape, dtype};
-}