PyPatchMatch 2.0.0b1__tar.gz → 2.0.0b2__tar.gz

{pypatchmatch-2.0.0b1 → pypatchmatch-2.0.0b2}/CMakeLists.txt

@@ -61,3 +61,16 @@ install(TARGETS patchmatch
   LIBRARY DESTINATION patchmatch
   RUNTIME DESTINATION patchmatch
 )
+
+# A static OpenCV becomes part of the library, so a wheel has to ship its licenses,
+# which scripts/build_opencv.py collects in <prefix>/licenses.
+if(DEFINED SKBUILD_METADATA_DIR AND NOT OpenCV_SHARED)
+  set(PATCHMATCH_OPENCV_LICENSES "${OpenCV_INSTALL_PATH}/licenses")
+  if(EXISTS "${PATCHMATCH_OPENCV_LICENSES}/opencv-LICENSE")
+    install(DIRECTORY "${PATCHMATCH_OPENCV_LICENSES}/"
+      DESTINATION "${SKBUILD_METADATA_DIR}/licenses/opencv")
+  else()
+    message(WARNING "No OpenCV licenses in ${PATCHMATCH_OPENCV_LICENSES}, "
+      "the wheel will not include them")
+  endif()
+endif()

pypatchmatch-2.0.0b2/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: PyPatchMatch
+Version: 2.0.0b2
+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>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.14
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Typing :: Typed
+Project-URL: Source Code, https://github.com/mauwii/PyPatchMatch
+Project-URL: Issues, https://github.com/mauwii/PyPatchMatch/issues
+Project-URL: Release Notes, https://github.com/mauwii/PyPatchMatch/releases
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Requires-Dist: pillow
+Description-Content-Type: text/markdown
+
+# PatchMatch based Inpainting
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blueviolet.svg)](https://github.com/mauwii/PyPatchMatch/blob/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/PyPatchMatch)](https://pypi.org/project/PyPatchMatch/)
+[![Downloads](https://static.pepy.tech/badge/pypatchmatch)](https://pepy.tech/projects/pypatchmatch)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+This library implements the PatchMatch based inpainting algorithm. It provides both C++
+and Python interfaces. This implementation is heavily based on the implementation by
+Younesse ANDAM: [younesse-cv/PatchMatch](https://github.com/younesse-cv/PatchMatch),
+with some bug fixes, and updates.
+
+## Installation
+
+```sh
+pip install PyPatchMatch
+```
+
+Wheels for Linux (glibc, x86_64 and aarch64), macOS 11+ (arm64 and x86_64) and Windows
+(x64) ship the compiled library with a statically linked OpenCV, so no compiler or
+OpenCV installation is needed. On other platforms, e.g. Alpine Linux or Windows on ARM,
+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`).
+
+## Usage
+
+Python (see
+[examples/py_example.py](https://github.com/mauwii/PyPatchMatch/blob/main/examples/py_example.py)):
+
+```python
+import patchmatch
+
+image = ...  # HxWx3 uint8 numpy array or PIL image
+mask = ...  # HxW uint8 or bool numpy array or PIL image, non-zero marks the holes
+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
+[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.
+
+`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.
+
+C++ (see
+[examples/cpp_example.cpp](https://github.com/mauwii/PyPatchMatch/blob/main/examples/cpp_example.cpp),
+build and run it with
+[examples/cpp_example_run.sh](https://github.com/mauwii/PyPatchMatch/blob/main/examples/cpp_example_run.sh)):
+
+```cpp
+#include "inpaint.h"
+
+int main() {
+    cv::Mat image = ...;
+    cv::Mat mask = ...;
+
+    auto metric = PatchSSDDistanceMetric(5);
+    cv::Mat result = Inpainting(image, mask, &metric).run();
+}
+```
+
+The library is built with CMake; `PATCHMATCH_BUILD_EXAMPLES` builds the example and
+`PATCHMATCH_WITH_HIGHGUI` enables the debug visualization of `Inpainting::run`.
+
+## Development
+
+The project is managed with [uv](https://docs.astral.sh/uv/):
+
+```sh
+uv sync                        # create .venv, build the library, install dev deps
+uv run pre-commit install      # enable ruff and the other hooks on commit
+uv run pytest                  # run the test suite
+uv run pytest -m "not e2e"     # only the fast unit tests
+```
+
+Releases are published to PyPI by creating a GitHub release; the version is taken from
+its tag (e.g. `v2.0.0`).
+
+## License
+
+PyPatchMatch is released under the
+[MIT License](https://github.com/mauwii/PyPatchMatch/blob/main/LICENSE). The wheels
+contain a statically linked build of OpenCV core (Apache-2.0) and its bundled
+third-party code; their licenses are included in the `licenses/opencv` directory of the
+wheel's `.dist-info`.
+
+## README and COPYRIGHT by Younesse ANDAM
+
+@Author: Younesse ANDAM
+
+@Contact: <younesse.andam@gmail.com>
+
+Description:
+
+This project is a personal implementation of an algorithm called PATCHMATCH
+that restores missing areas in an image. The algorithm is presented in the following
+paper PatchMatch A Randomized Correspondence Algorithm for Structural Image Editing by
+C.Barnes, E.Shechtman, A.Finkelstein and Dan B.Goldman ACM Transactions on Graphics
+(Proc. SIGGRAPH), vol.28, aug-2009
+
+For more information please refer to
+<https://gfx.cs.princeton.edu/pubs/Barnes_2009_PAR/>
+
+Copyright (c) 2010-2011

pypatchmatch-2.0.0b1/PKG-INFO → pypatchmatch-2.0.0b2/README.md

@@ -1,30 +1,8 @@
-Metadata-Version: 2.4
-Name: PyPatchMatch
-Version: 2.0.0b1
-Summary: This library implements the PatchMatch based inpainting algorithm.
-Author-Email: The InvokeAI Project <lincoln.stein@gmail.com>, Kyle Schouviller <kyle0654@hotmail.com>, Matthias Wild <mauwii@outlook.de>, Younesse ANDAM <younesse.andam@gmail.com>
-License-Expression: MIT
-License-File: LICENSE
-Classifier: Programming Language :: C++
-Classifier: Programming Language :: Python :: 3
-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: Programming Language :: Python :: 3.14
-Classifier: Topic :: Multimedia :: Graphics
-Classifier: Topic :: Scientific/Engineering :: Image Processing
-Project-URL: Source Code, https://github.com/mauwii/PyPatchMatch
-Requires-Python: >=3.10
-Requires-Dist: numpy
-Requires-Dist: pillow
-Description-Content-Type: text/markdown
-
 # PatchMatch based Inpainting
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blueviolet.svg)](https://github.com/mauwii/PyPatchMatch/blob/main/LICENSE)
 [![PyPI](https://img.shields.io/pypi/v/PyPatchMatch)](https://pypi.org/project/PyPatchMatch/)
-[![Downloads](https://static.pepy.tech/badge/pypatchmatch)](https://pepy.tech/project/pypatchmatch)
+[![Downloads](https://static.pepy.tech/badge/pypatchmatch)](https://pepy.tech/projects/pypatchmatch)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 
 This library implements the PatchMatch based inpainting algorithm. It provides both C++
@@ -38,14 +16,16 @@ with some bug fixes, and updates.
 pip install PyPatchMatch
 ```
 
-Wheels for Linux, macOS and Windows ship the compiled library including the required
-OpenCV runtime, so no compiler or OpenCV installation is needed. On other platforms pip
-builds from the source distribution, which requires a C++17 compiler, CMake and the
+Wheels for Linux (glibc, x86_64 and aarch64), macOS 11+ (arm64 and x86_64) and Windows
+(x64) ship the compiled library with a statically linked OpenCV, so no compiler or
+OpenCV installation is needed. On other platforms, e.g. Alpine Linux or Windows on ARM,
+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`).
 
 ## Usage
 
-Python (see [examples/py_example.py](examples/py_example.py)):
+Python (see
+[examples/py_example.py](https://github.com/mauwii/PyPatchMatch/blob/main/examples/py_example.py)):
 
 ```python
 import patchmatch
@@ -56,12 +36,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.
+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
+[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.
 
-C++ (see [examples/cpp_example.cpp](examples/cpp_example.cpp), build and run it with
-[examples/cpp_example_run.sh](examples/cpp_example_run.sh)):
+`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.
+
+C++ (see
+[examples/cpp_example.cpp](https://github.com/mauwii/PyPatchMatch/blob/main/examples/cpp_example.cpp),
+build and run it with
+[examples/cpp_example_run.sh](https://github.com/mauwii/PyPatchMatch/blob/main/examples/cpp_example_run.sh)):
 
 ```cpp
 #include "inpaint.h"
@@ -90,13 +80,21 @@ uv run pytest -m "not e2e"     # only the fast unit tests
 ```
 
 Releases are published to PyPI by creating a GitHub release; the version is taken from
-its tag (e.g. `v1.1.0`).
+its tag (e.g. `v2.0.0`).
+
+## License
+
+PyPatchMatch is released under the
+[MIT License](https://github.com/mauwii/PyPatchMatch/blob/main/LICENSE). The wheels
+contain a statically linked build of OpenCV core (Apache-2.0) and its bundled
+third-party code; their licenses are included in the `licenses/opencv` directory of the
+wheel's `.dist-info`.
 
 ## README and COPYRIGHT by Younesse ANDAM
 
 @Author: Younesse ANDAM
 
-@Contact: younesse.andam@gmail.com
+@Contact: <younesse.andam@gmail.com>
 
 Description:
 
@@ -107,12 +105,6 @@ C.Barnes, E.Shechtman, A.Finkelstein and Dan B.Goldman ACM Transactions on Graph
 (Proc. SIGGRAPH), vol.28, aug-2009
 
 For more information please refer to
-http://www.cs.princeton.edu/gfx/pubs/Barnes_2009_PAR/index.php
+<https://gfx.cs.princeton.edu/pubs/Barnes_2009_PAR/>
 
 Copyright (c) 2010-2011
-
-## Requirements
-
-To run the project you need to install Opencv library and link it to your project.
-Opencv can be download it here
-http://opencv.org/downloads.html

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

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

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

@@ -9,13 +9,11 @@
 
 namespace
 {
-    static std::vector<double> kDistance2Similarity;
-
-    void init_kDistance2Similarity()
+    std::vector<double> make_distance2similarity()
     {
         double base[11] = {1.0, 0.99, 0.96, 0.83, 0.38, 0.11, 0.02, 0.005, 0.0006, 0.0001, 0};
         int length = (PatchDistanceMetric::kDistanceScale + 1);
-        kDistance2Similarity.resize(length);
+        std::vector<double> table(length);
         for (int i = 0; i < length; ++i)
         {
             double t = (double)i / length;
@@ -23,8 +21,17 @@ namespace
             int k = j + 1;
             double vj = (j < 11) ? base[j] : 0;
             double vk = (k < 11) ? base[k] : 0;
-            kDistance2Similarity[i] = vj + (100 * t - j) * (vk - vj);
+            table[i] = vj + (100 * t - j) * (vk - vj);
         }
+        return table;
+    }
+
+    // Built on first use. The initialization of a local static is thread-safe, which
+    // matters because the Python bindings release the GIL during inpainting.
+    const std::vector<double> &distance2similarity()
+    {
+        static const std::vector<double> table = make_distance2similarity();
+        return table;
     }
 
     inline void _weighted_copy(const MaskedImage &source, int ys, int xs, cv::Mat &target, int yt, int xt, double weight)
@@ -69,16 +76,11 @@ void Inpainting::_initialize_pyramid()
         source = source.downsample();
         m_pyramid.push_back(source);
     }
-
-    if (kDistance2Similarity.size() == 0)
-    {
-        init_kDistance2Similarity();
-    }
 }
 
 cv::Mat Inpainting::run(bool verbose, bool verbose_visualize, unsigned int random_seed)
 {
-    srand(random_seed);
+    NearestNeighborField::seed_random(random_seed);
     const int nr_levels = m_pyramid.size();
 
     MaskedImage source, target;
@@ -124,7 +126,12 @@ cv::Mat Inpainting::run(bool verbose, bool verbose_visualize, unsigned int rando
         target = _expectation_maximization(source, target, level, verbose);
     }
 
-    return target.image();
+    // Globally masked pixels are neither filled nor used as a source, so the pyramid
+    // leaves them black. Keep their input values instead.
+    cv::Mat result = target.image();
+    if (!m_initial.global_mask().empty())
+        m_initial.image().copyTo(result, m_initial.global_mask());
+    return result;
 }
 
 // EM-Like algorithm (see "PatchMatch" - page 6).
@@ -211,6 +218,7 @@ void Inpainting::_expectation_step(
     auto source_size = nnf.source_size();
     auto target_size = nnf.target_size();
     const int patch_size = m_distance_metric->patch_size();
+    const auto &kDistance2Similarity = distance2similarity();
 
     for (int i = 0; i < source_size.height; ++i)
     {

{pypatchmatch-2.0.0b1 → pypatchmatch-2.0.0b2}/patchmatch/csrc/masked_image.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cassert>
 #include <opencv2/core.hpp>
 
 class MaskedImage

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

@@ -1,6 +1,7 @@
 #include <algorithm>
 #include <iostream>
 #include <cmath>
+#include <random>
 
 #include "masked_image.h"
 #include "nnf.h"
@@ -17,9 +18,35 @@ T clamp(T value, T min_value, T max_value)
     return std::min(std::max(value, min_value), max_value);
 }
 
+namespace
+{
+    // One generator per thread, so concurrent inpaintings with the same seed give the
+    // same results. It only drives the randomized search, which has to be reproducible
+    // from a seed, so a standard generator is the right choice. SonarCloud's PRNG rule
+    // (cpp:S2245) flags every declaration of its type, hence the NOSONAR markers.
+    std::mt19937 &random_engine() // NOSONAR
+    {
+        thread_local std::mt19937 engine; // NOSONAR
+        return engine;
+    }
+
+    // The modulo instead of std::uniform_int_distribution keeps the sequence identical
+    // on all platforms.
+    inline int random_int(int n)
+    {
+        return static_cast<int>(random_engine()() % static_cast<unsigned int>(n));
+    }
+}
+
+void NearestNeighborField::seed_random(unsigned int seed)
+{
+    random_engine().seed(seed);
+}
+
 void NearestNeighborField::_randomize_field(int max_retry, bool reset)
 {
     auto this_size = source_size();
+    auto this_target_size = target_size();
     for (int i = 0; i < this_size.height; ++i)
     {
         for (int j = 0; j < this_size.width; ++j)
@@ -37,8 +64,8 @@ void NearestNeighborField::_randomize_field(int max_retry, bool reset)
             int i_target = 0, j_target = 0;
             for (int t = 0; t < max_retry; ++t)
             {
-                i_target = rand() % this_size.height;
-                j_target = rand() % this_size.width;
+                i_target = random_int(this_target_size.height);
+                j_target = random_int(this_target_size.width);
                 if (m_target.is_globally_masked(i_target, j_target))
                     continue;
 
@@ -138,8 +165,8 @@ void NearestNeighborField::_minimize_link(int y, int x, int direction)
     int random_scale = (std::min(this_target_size.height, this_target_size.width) - 1) / 2;
     while (random_scale > 0)
     {
-        int yp = this_ptr[0] + (rand() % (2 * random_scale + 1) - random_scale);
-        int xp = this_ptr[1] + (rand() % (2 * random_scale + 1) - random_scale);
+        int yp = this_ptr[0] + (random_int(2 * random_scale + 1) - random_scale);
+        int xp = this_ptr[1] + (random_int(2 * random_scale + 1) - random_scale);
         yp = clamp(yp, 0, target_size().height - 1);
         xp = clamp(xp, 0, target_size().width - 1);
 
@@ -201,10 +228,9 @@ namespace
             const unsigned char *p_sgm = nullptr;
             const unsigned char *p_tgm = nullptr;
             if (!source.global_mask().empty())
-            {
                 p_sgm = source.global_mask().ptr<unsigned char>(yys, 0);
+            if (!target.global_mask().empty())
                 p_tgm = target.global_mask().ptr<unsigned char>(yyt, 0);
-            }
 
             const auto *p_sgy = source.grady().ptr<unsigned char>(yys, 0);
             const auto *p_tgy = target.grady().ptr<unsigned char>(yyt, 0);
@@ -216,7 +242,7 @@ namespace
                 int xxs = xs + dx, xxt = xt + dx;
                 wsum += 1;
 
-                if (xxs <= 0 || xxs >= source_size.width - 1 || xxt <= 0 || xxt >= source_size.width - 1)
+                if (xxs <= 0 || xxs >= source_size.width - 1 || xxt <= 0 || xxt >= target_size.width - 1)
                 {
                     distance += PatchSSDDistanceMetric::kSSDScale;
                     continue;

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

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <cassert>
+#include <cmath>
 #include <opencv2/core.hpp>
 #include "masked_image.h"
 
@@ -87,6 +89,9 @@ public:
 
     void minimize(int nr_pass);
 
+    // Seeds the random search of the calling thread.
+    static void seed_random(unsigned int seed);
+
 private:
     inline int _distance(int source_y, int source_x, int target_y, int target_x)
     {

{pypatchmatch-2.0.0b1 → pypatchmatch-2.0.0b2}/patchmatch/csrc/pyinterface.cpp

@@ -115,8 +115,7 @@ int _dtype_cv_to_py(int dtype_cv)
 
 cv::Mat _py_to_cv2(PM_mat_t pymat)
 {
-    int dtype = _dtype_py_to_cv(pymat.dtype);
-    dtype = CV_MAKETYPE(pymat.dtype, pymat.shape.channels);
+    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();
 }
 

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

@@ -76,14 +76,15 @@ def inpaint(
         mask: 1-channel uint8 or bool mask of the hole(s) to fill (non-zero = hole),
             with the same height and width as ``image``. If ``None``, all pure
             white pixels (255, 255, 255) are treated as holes.
-        global_mask: mask like ``mask`` of pixels that must not be used as a source.
+        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.
 
     Returns:
         The repaired image, with the same shape as ``image``.
     """
     lib = _get_lib()
-    image, mask, global_mask = _prepare_inputs(image, mask, global_mask)
+    image, mask, global_mask = _prepare_inputs(image, mask, global_mask, patch_size)
 
     if global_mask is None:
         return _call(lib.PM_inpaint, image, mask, ctypes.c_int(patch_size))
@@ -107,15 +108,16 @@ def inpaint_regularity(
         guide_weight: weight of the regularity term relative to the patch distance.
     """
     lib = _get_lib()
-    image, mask, global_mask = _prepare_inputs(image, mask, global_mask)
+    image, mask, global_mask = _prepare_inputs(image, mask, global_mask, patch_size)
 
     if not (
         isinstance(ijmap, np.ndarray)
         and ijmap.ndim == 3
         and ijmap.shape[2] == 3
         and ijmap.dtype == np.float32
+        and ijmap.size > 0
     ):
-        raise ValueError("ijmap must be an HxWx3 float32 array")
+        raise ValueError("ijmap must be a non-empty HxWx3 float32 array")
     ijmap = np.ascontiguousarray(ijmap)
 
     args = (ijmap, ctypes.c_int(patch_size), ctypes.c_float(guide_weight))
@@ -125,9 +127,16 @@ def inpaint_regularity(
 
 
 def _prepare_inputs(
-    image: ImageLike, mask: ImageLike | None, global_mask: ImageLike | None
+    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:

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

@@ -10,12 +10,18 @@ license = "MIT"
 license-files = ["LICENSE"]
 authors = [
     { name = "The InvokeAI Project", email = "lincoln.stein@gmail.com" },
+    { name = "Jiayuan Mao", email = "maojiayuan@gmail.com" },
     { name = "Kyle Schouviller", email = "kyle0654@hotmail.com" },
     { name = "Matthias Wild", email = "mauwii@outlook.de" },
     { name = "Younesse ANDAM", email = "younesse.andam@gmail.com" },
 ]
 requires-python = ">=3.10"
+keywords = ["inpainting", "patchmatch", "image-processing", "opencv"]
 classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
     "Programming Language :: C++",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.10",
@@ -25,12 +31,15 @@ classifiers = [
     "Programming Language :: Python :: 3.14",
     "Topic :: Multimedia :: Graphics",
     "Topic :: Scientific/Engineering :: Image Processing",
+    "Typing :: Typed",
 ]
 dependencies = ["numpy", "pillow"]
 dynamic = ["version"]
 
 [project.urls]
 "Source Code" = "https://github.com/mauwii/PyPatchMatch"
+Issues = "https://github.com/mauwii/PyPatchMatch/issues"
+"Release Notes" = "https://github.com/mauwii/PyPatchMatch/releases"
 
 [dependency-groups]
 dev = [{ include-group = "test" }, "pre-commit", "ruff"]

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

@@ -3,7 +3,7 @@
 The patchmatch library only needs opencv_core. Linking it statically keeps the
 wheels small and free of OpenCV's GUI/codec dependencies.
 
-Usage: python build_opencv.py [PREFIX]  (default: $OpenCV_ROOT)
+Usage: python build_opencv.py  (installs into $OpenCV_ROOT)
 """
 
 import os
@@ -36,9 +36,14 @@ CMAKE_OPTIONS = {
     "BUILD_opencv_apps": "OFF",
     "BUILD_opencv_python3": "OFF",
     "OPENCV_GENERATE_PKGCONFIG": "OFF",
+    # CMakeLists.txt ships the licenses from here with the wheels
+    "OPENCV_LICENSES_INSTALL_PATH": "licenses",
     # only core is built, so disable every optional backend and codec
     "WITH_ADE": "OFF",
     "WITH_AVIF": "OFF",
+    # ARM HAL libraries, patchmatch uses no function they accelerate
+    "WITH_CAROTENE": "OFF",
+    "WITH_KLEIDICV": "OFF",
     "WITH_EIGEN": "OFF",
     "WITH_FFMPEG": "OFF",
     "WITH_GSTREAMER": "OFF",
@@ -84,8 +89,10 @@ def find_cmake() -> str:
 
 def main() -> None:
     # OpenCV_ROOT is the variable CMake's find_package(OpenCV) looks for.
-    default = os.environ.get("OpenCV_ROOT")  # noqa: SIM112
-    prefix = Path(sys.argv[1] if len(sys.argv) > 1 else default)
+    root = os.environ.get("OpenCV_ROOT")  # noqa: SIM112
+    if not root:
+        sys.exit("OpenCV_ROOT must be set to the installation prefix")
+    prefix = Path(root)
     if any(prefix.rglob("OpenCVConfig.cmake")):
         print(f"OpenCV already installed in {prefix}")
         return
@@ -115,6 +122,11 @@ def main() -> None:
         )
         subprocess.run([cmake, "--install", build, "--config", "Release"], check=True)
 
+        # OpenCV installs only the licenses of its 3rdparty code
+        licenses = prefix / CMAKE_OPTIONS["OPENCV_LICENSES_INSTALL_PATH"]
+        licenses.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(source / "LICENSE", licenses / "opencv-LICENSE")
+
 
 if __name__ == "__main__":
     main()

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

@@ -25,9 +25,16 @@ def surrounding(mask: np.ndarray, width: int = 10) -> np.ndarray:
     return (np.array(grown) > 0) & ~mask
 
 
-def assert_plausible_fill(source: np.ndarray, result: np.ndarray) -> None:
-    """Check an inpainting result of ``source`` without a ground truth image."""
-    holes = white_pixels(source)
+def assert_plausible_fill(
+    source: np.ndarray, result: np.ndarray, excluded: np.ndarray | None = None
+) -> None:
+    """Check an inpainting result of ``source`` without a ground truth image.
+
+    ``excluded`` marks the pixels of a global mask, which are not filled.
+    """
+    if excluded is None:
+        excluded = np.zeros(source.shape[:2], dtype=bool)
+    holes = white_pixels(source) & ~excluded
     assert holes.any()
     assert result.shape == source.shape
     assert result.dtype == np.uint8
@@ -39,7 +46,7 @@ def assert_plausible_fill(source: np.ndarray, result: np.ndarray) -> None:
     assert outside < 1, outside
 
     # the filling blends in with its surroundings
-    band = surrounding(holes)
+    band = surrounding(holes) & ~excluded
     color_diff = np.abs(result[holes].mean(axis=0) - source[band].mean(axis=0))
     assert color_diff.max() < 10, color_diff
 
@@ -79,15 +86,37 @@ def test_remove_white_regions(pruned_image, tmp_path, as_array):
 
 
 def test_global_mask(pruned_image):
-    """examples/py_example_global_mask.py: extra hole excluded as patch source."""
+    """examples/py_example_global_mask.py: the globally masked plant is kept."""
     source = np.array(pruned_image)
-    source[:100, :100] = 255
     global_mask = np.zeros_like(source[..., 0])
-    global_mask[:100, :100] = 1
+    global_mask[290:, 100:180] = 1
 
     result = patchmatch.inpaint(source, global_mask=global_mask, patch_size=3)
 
-    assert_plausible_fill(source, result)
+    excluded = global_mask.astype(bool)
+    np.testing.assert_array_equal(result[excluded], source[excluded])
+    assert_plausible_fill(source, result, excluded)
+
+
+def test_global_mask_is_not_used_as_source(pruned_image):
+    """A red block next to a hole fills it, unless the block is globally masked."""
+    source = np.array(pruned_image)
+    source[200:300, 20:120] = (255, 0, 0)
+    mask = np.zeros(source.shape[:2], dtype=np.uint8)
+    mask[210:290, 120:160] = 1
+    global_mask = np.zeros_like(mask)
+    global_mask[200:300, 20:120] = 1
+
+    def red_in_hole(result: np.ndarray) -> bool:
+        red = (result[..., 0] > 150) & (result[..., 1] < 80) & (result[..., 2] < 80)
+        return bool(red[mask == 1].any())
+
+    assert red_in_hole(patchmatch.inpaint(source, mask, patch_size=3))
+
+    result = patchmatch.inpaint(source, mask, global_mask=global_mask, patch_size=3)
+    assert not red_in_hole(result)
+    excluded = global_mask == 1
+    np.testing.assert_array_equal(result[excluded], source[excluded])
 
 
 @pytest.mark.parametrize("hole_value", [1, 255])

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

@@ -3,6 +3,7 @@
 import ctypes
 import subprocess
 import sys
+from concurrent.futures import ThreadPoolExecutor
 
 import numpy as np
 import pytest
@@ -83,9 +84,10 @@ def test_inpaint_explicit_mask(image, hole_mask):
 def test_inpaint_global_mask(image, hole_mask):
     global_mask = np.zeros_like(hole_mask)
     global_mask[:8] = 1
-    assert_filled(
-        patchmatch.inpaint(image, global_mask=global_mask, patch_size=3), image
-    )
+    result = patchmatch.inpaint(image, global_mask=global_mask, patch_size=3)
+    assert_filled(result, image)
+    # excluded pixels keep their values instead of the zeros of the pyramid
+    np.testing.assert_array_equal(result[:8], image[:8])
 
 
 @pytest.mark.parametrize("patch_size", [1, 3, 7])
@@ -108,6 +110,17 @@ def test_inpaint_is_deterministic_with_seed(image):
     np.testing.assert_array_equal(first, second)
 
 
+def test_concurrent_inpaint_is_deterministic(image):
+    # the native code runs without the GIL, so the threads really overlap
+    expected = patchmatch.inpaint(image, patch_size=3)
+    with ThreadPoolExecutor(4) as pool:
+        results = list(
+            pool.map(lambda _: patchmatch.inpaint(image, patch_size=3), range(16))
+        )
+    for result in results:
+        np.testing.assert_array_equal(result, expected)
+
+
 @pytest.mark.parametrize("verbose", [True, False])
 def test_set_verbose_prints_progress(verbose):
     # The native code writes to its own C runtime's stderr. On Windows the DLL
@@ -230,14 +243,27 @@ def test_mask_size_must_match_image(image, ijmap, func, argument):
         func(image, **kwargs)
 
 
+@pytest.mark.parametrize("patch_size", [0, -1])
+@pytest.mark.parametrize(
+    "func",
+    [patchmatch.inpaint, patchmatch.inpaint_regularity],
+    ids=lambda f: f.__name__,
+)
+def test_invalid_patch_size(image, ijmap, func, patch_size):
+    kwargs = {"ijmap": ijmap} if func is patchmatch.inpaint_regularity else {}
+    with pytest.raises(ValueError, match="patch_size"):
+        func(image, None, patch_size=patch_size, **kwargs)
+
+
 @pytest.mark.parametrize(
     "bad_ijmap",
     [
         np.zeros((HEIGHT, WIDTH, 3), dtype=np.float64),
         np.zeros((HEIGHT, WIDTH, 2), dtype=np.float32),
+        np.zeros((0, WIDTH, 3), dtype=np.float32),
         [[[0.0, 0.0, 0.0]]],
     ],
-    ids=["float64", "2-channel", "list"],
+    ids=["float64", "2-channel", "empty", "list"],
 )
 def test_inpaint_regularity_invalid_ijmap(image, bad_ijmap):
     with pytest.raises(ValueError, match="ijmap"):

pypatchmatch-2.0.0b1/README.md

@@ -1,96 +0,0 @@
-# PatchMatch based Inpainting
-
-[![License: MIT](https://img.shields.io/badge/License-MIT-blueviolet.svg)](https://github.com/mauwii/PyPatchMatch/blob/main/LICENSE)
-[![PyPI](https://img.shields.io/pypi/v/PyPatchMatch)](https://pypi.org/project/PyPatchMatch/)
-[![Downloads](https://static.pepy.tech/badge/pypatchmatch)](https://pepy.tech/project/pypatchmatch)
-[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
-
-This library implements the PatchMatch based inpainting algorithm. It provides both C++
-and Python interfaces. This implementation is heavily based on the implementation by
-Younesse ANDAM: [younesse-cv/PatchMatch](https://github.com/younesse-cv/PatchMatch),
-with some bug fixes, and updates.
-
-## Installation
-
-```sh
-pip install PyPatchMatch
-```
-
-Wheels for Linux, macOS and Windows ship the compiled library including the required
-OpenCV runtime, so no compiler or OpenCV installation is needed. On other platforms 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`).
-
-## Usage
-
-Python (see [examples/py_example.py](examples/py_example.py)):
-
-```python
-import patchmatch
-
-image = ...  # HxWx3 uint8 numpy array or PIL image
-mask = ...  # HxW uint8 or bool numpy array or PIL image, non-zero marks the holes
-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.
-`patchmatch.patchmatch_available` tells whether the native library could be loaded.
-The previous import path `from patchmatch import patch_match` keeps working.
-
-C++ (see [examples/cpp_example.cpp](examples/cpp_example.cpp), build and run it with
-[examples/cpp_example_run.sh](examples/cpp_example_run.sh)):
-
-```cpp
-#include "inpaint.h"
-
-int main() {
-    cv::Mat image = ...;
-    cv::Mat mask = ...;
-
-    auto metric = PatchSSDDistanceMetric(5);
-    cv::Mat result = Inpainting(image, mask, &metric).run();
-}
-```
-
-The library is built with CMake; `PATCHMATCH_BUILD_EXAMPLES` builds the example and
-`PATCHMATCH_WITH_HIGHGUI` enables the debug visualization of `Inpainting::run`.
-
-## Development
-
-The project is managed with [uv](https://docs.astral.sh/uv/):
-
-```sh
-uv sync                        # create .venv, build the library, install dev deps
-uv run pre-commit install      # enable ruff and the other hooks on commit
-uv run pytest                  # run the test suite
-uv run pytest -m "not e2e"     # only the fast unit tests
-```
-
-Releases are published to PyPI by creating a GitHub release; the version is taken from
-its tag (e.g. `v1.1.0`).
-
-## README and COPYRIGHT by Younesse ANDAM
-
-@Author: Younesse ANDAM
-
-@Contact: younesse.andam@gmail.com
-
-Description:
-
-This project is a personal implementation of an algorithm called PATCHMATCH
-that restores missing areas in an image. The algorithm is presented in the following
-paper PatchMatch A Randomized Correspondence Algorithm for Structural Image Editing by
-C.Barnes, E.Shechtman, A.Finkelstein and Dan B.Goldman ACM Transactions on Graphics
-(Proc. SIGGRAPH), vol.28, aug-2009
-
-For more information please refer to
-http://www.cs.princeton.edu/gfx/pubs/Barnes_2009_PAR/index.php
-
-Copyright (c) 2010-2011
-
-## Requirements
-
-To run the project you need to install Opencv library and link it to your project.
-Opencv can be download it here
-http://opencv.org/downloads.html