PyPatchMatch 2.0.0b1__tar.gz → 2.0.0rc1__tar.gz

{pypatchmatch-2.0.0b1 → pypatchmatch-2.0.0rc1}/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.0b1 → pypatchmatch-2.0.0rc1}/PKG-INFO

@@ -1,10 +1,15 @@
 Metadata-Version: 2.4
 Name: PyPatchMatch
-Version: 2.0.0b1
+Version: 2.0.0rc1
 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>
+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
@@ -14,7 +19,10 @@ 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
@@ -24,7 +32,7 @@ Description-Content-Type: text/markdown
 
 [![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 +46,25 @@ 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`).
 
+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 [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 +75,27 @@ 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. 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.
 
-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)):
+`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
+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),
+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 +124,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 +149,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.0rc1}/README.md

@@ -2,7 +2,7 @@
 
 [![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++
@@ -16,14 +16,25 @@ 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`).
 
+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 [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
@@ -34,12 +45,27 @@ 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. 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.
 
-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)):
+`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
+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),
+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"
@@ -68,13 +94,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:
 
@@ -85,12 +119,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.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.0b1 → 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.0b1'
-__version_tuple__ = version_tuple = (2, 0, 0, 'b1')
+__version__ = version = '2.0.0rc1'
+__version_tuple__ = version_tuple = (2, 0, 0, 'rc1')
 
-__commit_id__ = commit_id = 'g987b0e524'
+__commit_id__ = commit_id = 'g75098309c'

{pypatchmatch-2.0.0b1 → pypatchmatch-2.0.0rc1}/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)
@@ -37,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;
@@ -69,16 +75,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 +125,17 @@ cv::Mat Inpainting::run(bool verbose, bool verbose_visualize, unsigned int rando
         target = _expectation_maximization(source, target, level, verbose);
     }
 
-    return target.image();
+    // 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())
+        keep |= m_initial.global_mask() != 0;
+    m_initial.image().copyTo(result, keep);
+    return result;
 }
 
 // EM-Like algorithm (see "PatchMatch" - page 6).
@@ -211,6 +222,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.0rc1}/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.0rc1}/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;
@@ -261,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)
@@ -312,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.0b1 → pypatchmatch-2.0.0rc1}/patchmatch/csrc/nnf.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <stdexcept>
 #include <opencv2/core.hpp>
 #include "masked_image.h"
 
@@ -87,6 +88,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)
     {
@@ -111,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;
 };