PyPatchMatch 2.0.0rc2__tar.gz → 2.0.0rc4__tar.gz

{pypatchmatch-2.0.0rc2 → pypatchmatch-2.0.0rc4}/CMakeLists.txt

@@ -4,6 +4,7 @@ project(patchmatch LANGUAGES CXX)
 option(PATCHMATCH_BUILD_EXAMPLES "Build the C++ example (requires OpenCV imgcodecs)" OFF)
 option(PATCHMATCH_WITH_HIGHGUI "Enable the debug visualization of Inpainting::run (requires OpenCV highgui)" OFF)
 option(PATCHMATCH_FAST_MATH "Compile with fast-math optimizations" ON)
+option(PATCHMATCH_SANITIZE "Build with AddressSanitizer and UndefinedBehaviorSanitizer, without fast math (GCC, Clang)" OFF)
 
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
@@ -32,13 +33,20 @@ add_library(patchmatch SHARED
 target_include_directories(patchmatch PUBLIC patchmatch/csrc)
 target_link_libraries(patchmatch PUBLIC opencv_core)
 
+# CI adds CMAKE_COMPILE_WARNING_AS_ERROR; the OpenCV headers are system headers
+if(MSVC)
+  target_compile_options(patchmatch PRIVATE /W4)
+else()
+  target_compile_options(patchmatch PRIVATE -Wall -Wextra -Wpedantic -Wshadow)
+endif()
+
 if(MSVC AND NOT OpenCV_SHARED)
   # A static OpenCV (as built by scripts/build_opencv.py) uses the static MSVC runtime.
   set_property(TARGET patchmatch PROPERTY
     MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 endif()
 
-if(PATCHMATCH_FAST_MATH)
+if(PATCHMATCH_FAST_MATH AND NOT PATCHMATCH_SANITIZE)
   if(MSVC)
     target_compile_options(patchmatch PRIVATE /fp:fast)
   else()
@@ -46,6 +54,17 @@ if(PATCHMATCH_FAST_MATH)
   endif()
 endif()
 
+if(PATCHMATCH_SANITIZE)
+  if(MSVC)
+    message(FATAL_ERROR "PATCHMATCH_SANITIZE needs GCC or Clang")
+  endif()
+  # GCC's -fsanitize=undefined leaves out float-cast-overflow
+  set(PATCHMATCH_SANITIZERS -fsanitize=address,undefined,float-cast-overflow)
+  target_compile_options(patchmatch PRIVATE ${PATCHMATCH_SANITIZERS}
+    -fno-sanitize-recover=all -fno-omit-frame-pointer -g)
+  target_link_options(patchmatch PRIVATE ${PATCHMATCH_SANITIZERS})
+endif()
+
 if(PATCHMATCH_WITH_HIGHGUI)
   target_compile_definitions(patchmatch PRIVATE PATCHMATCH_WITH_HIGHGUI)
   target_link_libraries(patchmatch PRIVATE opencv_imgproc opencv_highgui)

{pypatchmatch-2.0.0rc2 → pypatchmatch-2.0.0rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPatchMatch
-Version: 2.0.0rc2
+Version: 2.0.0rc4
 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>
@@ -30,6 +30,8 @@ Description-Content-Type: text/markdown
 
 # PatchMatch based Inpainting
 
+[![CI](https://github.com/mauwii/PyPatchMatch/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/mauwii/PyPatchMatch/actions/workflows/ci.yml)
+[![Quality Gate](https://sonarcloud.io/api/project_badges/measure?project=mauwii_PyPatchMatch&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=mauwii_PyPatchMatch)
 [![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)
@@ -76,7 +78,10 @@ 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. Only the holes are filled; all other pixels keep
-their values. The optional keyword argument `global_mask`, in the same format, marks
+their values. Holes need hard edges: an anti-aliased brush leaves light pixels along
+the edge of its strokes that are not pure white, so they count as known and the fill
+continues them. Paint without anti-aliasing or pass a mask that covers those pixels as
+well. 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.
@@ -121,8 +126,14 @@ uv sync                        # create .venv, build the library, install dev de
 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
+uv run python scripts/evaluate_inpainting.py  # measure the fill quality
 ```
 
+The evaluation cuts holes into the images of `examples/images`, compares the fills with
+the original content and writes `examples/images/evaluation.html`, which shows them side
+by side. `--baseline` evaluates another build of the library as well, e.g. of the main
+branch; the docstring of the script explains the columns.
+
 Releases are published to PyPI by creating a GitHub release; the version is taken from
 its tag (e.g. `v2.0.0`).
 

{pypatchmatch-2.0.0rc2 → pypatchmatch-2.0.0rc4}/README.md

@@ -1,5 +1,7 @@
 # PatchMatch based Inpainting
 
+[![CI](https://github.com/mauwii/PyPatchMatch/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/mauwii/PyPatchMatch/actions/workflows/ci.yml)
+[![Quality Gate](https://sonarcloud.io/api/project_badges/measure?project=mauwii_PyPatchMatch&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=mauwii_PyPatchMatch)
 [![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)
@@ -46,7 +48,10 @@ 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. Only the holes are filled; all other pixels keep
-their values. The optional keyword argument `global_mask`, in the same format, marks
+their values. Holes need hard edges: an anti-aliased brush leaves light pixels along
+the edge of its strokes that are not pure white, so they count as known and the fill
+continues them. Paint without anti-aliasing or pass a mask that covers those pixels as
+well. 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.
@@ -91,8 +96,14 @@ uv sync                        # create .venv, build the library, install dev de
 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
+uv run python scripts/evaluate_inpainting.py  # measure the fill quality
 ```
 
+The evaluation cuts holes into the images of `examples/images`, compares the fills with
+the original content and writes `examples/images/evaluation.html`, which shows them side
+by side. `--baseline` evaluates another build of the library as well, e.g. of the main
+branch; the docstring of the script explains the columns.
+
 Releases are published to PyPI by creating a GitHub release; the version is taken from
 its tag (e.g. `v2.0.0`).
 

{pypatchmatch-2.0.0rc2 → pypatchmatch-2.0.0rc4}/patchmatch/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.0.0rc2'
-__version_tuple__ = version_tuple = (2, 0, 0, 'rc2')
+__version__ = version = '2.0.0rc4'
+__version_tuple__ = version_tuple = (2, 0, 0, 'rc4')
 
-__commit_id__ = commit_id = 'geb61e5d37'
+__commit_id__ = commit_id = 'g6f35e1d41'

{pypatchmatch-2.0.0rc2 → pypatchmatch-2.0.0rc4}/patchmatch/csrc/inpaint.cpp

@@ -1,8 +1,9 @@
 #include <algorithm>
+#include <array>
 #include <iostream>
 #ifdef PATCHMATCH_WITH_HIGHGUI
-#include <opencv2/imgproc.hpp>
 #include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
 #endif
 
 #include "inpaint.h"
@@ -11,17 +12,16 @@ namespace
 {
     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);
+        constexpr std::array<double, 11> base = {1.0, 0.99, 0.96, 0.83, 0.38, 0.11, 0.02, 0.005, 0.0006, 0.0001, 0};
+        const std::size_t length = static_cast<std::size_t>(PatchDistanceMetric::kDistanceScale) + 1;
         std::vector<double> table(length);
-        for (int i = 0; i < length; ++i)
+        for (std::size_t i = 0; i < length; ++i)
         {
-            double t = (double)i / length;
-            int j = (int)(100 * t);
-            int k = j + 1;
-            double vj = (j < 11) ? base[j] : 0;
-            double vk = (k < 11) ? base[k] : 0;
-            table[i] = vj + (100 * t - j) * (vk - vj);
+            const double t = static_cast<double>(i) / static_cast<double>(length);
+            const auto j = static_cast<std::size_t>(100 * t);
+            if (j >= base.size() - 1)
+                continue; // the table is zero from here on
+            table[i] = base[j] + (100 * t - static_cast<double>(j)) * (base[j + 1] - base[j]);
         }
         return table;
     }
@@ -34,7 +34,8 @@ namespace
         return table;
     }
 
-    inline void _weighted_copy(const MaskedImage &source, int ys, int xs, cv::Mat &target, int yt, int xt, double weight)
+    inline void _weighted_copy(
+        const MaskedImage &source, int ys, int xs, cv::Mat &target, int yt, int xt, double weight)
     {
         if (source.is_masked(ys, xs))
             return;
@@ -48,10 +49,29 @@ namespace
             target_ptr[c] += static_cast<double>(source_ptr[c]) * weight;
         target_ptr[3] += weight;
     }
-}
+
+    // Replaces the vote of the pixel if the new one weighs more. It is stored like the
+    // sums of _weighted_copy, so the maximization step divides it by its weight.
+    inline void _best_copy(const MaskedImage &source, int ys, int xs, cv::Mat &target, int yt, int xt, double weight)
+    {
+        if (source.is_masked(ys, xs))
+            return;
+        if (source.is_globally_masked(ys, xs))
+            return;
+
+        auto source_ptr = source.get_image(ys, xs);
+        auto target_ptr = target.ptr<double>(yt, xt);
+        if (weight <= target_ptr[3])
+            return;
+
+        for (int c = 0; c < 3; ++c)
+            target_ptr[c] = static_cast<double>(source_ptr[c]) * weight;
+        target_ptr[3] = weight;
+    }
+} // namespace
 
 /**
- * This algorithme uses a version proposed by Xavier Philippeau.
+ * This algorithm uses a version proposed by Xavier Philippeau.
  */
 
 Inpainting::Inpainting(cv::Mat image, cv::Mat mask, const PatchDistanceMetric *metric)
@@ -70,7 +90,8 @@ void Inpainting::_initialize_pyramid()
 {
     auto source = m_initial;
     m_pyramid.push_back(source);
-    while (source.size().height > m_distance_metric->patch_size() && source.size().width > m_distance_metric->patch_size())
+    while (source.size().height > m_distance_metric->patch_size() &&
+           source.size().width > m_distance_metric->patch_size())
     {
         source = source.downsample();
         m_pyramid.push_back(source);
@@ -80,7 +101,7 @@ void Inpainting::_initialize_pyramid()
 cv::Mat Inpainting::run(bool verbose, bool verbose_visualize, unsigned int random_seed)
 {
     NearestNeighborField::seed_random(random_seed);
-    const int nr_levels = m_pyramid.size();
+    const auto nr_levels = static_cast<int>(m_pyramid.size());
 
     MaskedImage source, target;
     for (int level = nr_levels - 1; level >= 0; --level)
@@ -125,9 +146,9 @@ cv::Mat Inpainting::run(bool verbose, bool verbose_visualize, unsigned int rando
         target = _expectation_maximization(source, target, level, verbose);
     }
 
-    // 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.
+    // Only the holes are filled. The maximization step of level 0 keeps the known pixels,
+    // but the pyramid leaves globally masked pixels black, which are neither filled nor
+    // used as a source. Copy every pixel outside the holes from the input.
     // A plain loop instead of OpenCV matrix expressions: those pull OpenCV's whole
     // expression module into the statically linked library, 40 % more on disk.
     cv::Mat result = target.image();
@@ -191,7 +212,8 @@ MaskedImage Inpainting::_expectation_maximization(MaskedImage source, MaskedImag
         if (level >= 1 && iter_em == nr_iters_em - 1)
         {
             new_source = m_pyramid[level - 1];
-            new_target = target.upsample(new_source.size().width, new_source.size().height, m_pyramid[level - 1].global_mask());
+            new_target =
+                target.upsample(new_source.size().width, new_source.size().height, m_pyramid[level - 1].global_mask());
             upscaled = true;
         }
         else
@@ -203,16 +225,28 @@ MaskedImage Inpainting::_expectation_maximization(MaskedImage source, MaskedImag
         auto vote = cv::Mat(new_target.size(), CV_64FC4);
         vote.setTo(cv::Scalar::all(0));
 
+        // The weighted mean of all overlapping patches blurs the fill, so in the last
+        // iteration of the finest level each pixel takes the value of its most similar
+        // patch instead (similar to "Space-Time Completion of Video", which takes the
+        // mode of the votes). On coarser levels the mean is kept: it lays out the smooth
+        // structure that the finer levels refine, the best vote there makes seams.
+        const bool best_only = level == 0 && iter_em == nr_iters_em - 1;
+
         // Votes for best patch from NNF Source->Target (completeness) and Target->Source (coherence).
-        _expectation_step(m_source2target, 1, vote, new_source, upscaled);
+        _expectation_step(m_source2target, true, vote, new_source, upscaled, best_only);
         if (verbose)
             std::cerr << "  Expectation source to target finished." << std::endl;
-        _expectation_step(m_target2source, 0, vote, new_source, upscaled);
+        _expectation_step(m_target2source, false, vote, new_source, upscaled, best_only);
         if (verbose)
             std::cerr << "  Expectation target to source finished." << std::endl;
 
         // Compile votes and update pixel values.
-        _maximization_step(new_target, vote);
+        // Known pixels are kept on the two finest levels only. On coarser levels those
+        // next to the holes average only the known part of their downsampling kernel,
+        // estimates that reach into the holes; keeping them there made the fills copy
+        // smooth regions, e.g. a concrete wall into the foliage above it.
+        const int new_level = upscaled ? level - 1 : level;
+        _maximization_step(new_target, vote, new_source, new_level <= 1);
         if (verbose)
             std::cerr << "  Minimization step finished." << std::endl;
     }
@@ -222,14 +256,22 @@ MaskedImage Inpainting::_expectation_maximization(MaskedImage source, MaskedImag
 
 // Expectation step: vote for best estimations of each pixel.
 void Inpainting::_expectation_step(
-    const NearestNeighborField &nnf, bool source2target,
-    cv::Mat &vote, const MaskedImage &source, bool upscaled)
+    const NearestNeighborField &nnf, bool source2target, cv::Mat &vote, const MaskedImage &source, bool upscaled,
+    bool best_only)
 {
     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();
 
+    double w = 0;
+    auto copy = [&](int ys, int xs, int yt, int xt) {
+        if (best_only)
+            _best_copy(source, ys, xs, vote, yt, xt, w);
+        else
+            _weighted_copy(source, ys, xs, vote, yt, xt, w);
+    };
+
     for (int i = 0; i < source_size.height; ++i)
     {
         for (int j = 0; j < source_size.width; ++j)
@@ -237,7 +279,7 @@ void Inpainting::_expectation_step(
             if (nnf.source().is_globally_masked(i, j))
                 continue;
             int yp = nnf.at(i, j, 0), xp = nnf.at(i, j, 1), dp = nnf.at(i, j, 2);
-            double w = kDistance2Similarity[dp];
+            w = kDistance2Similarity[dp];
 
             for (int di = -patch_size; di <= patch_size; ++di)
             {
@@ -265,13 +307,13 @@ void Inpainting::_expectation_step(
                         {
                             for (int ux = 0; ux < 2; ++ux)
                             {
-                                _weighted_copy(source, 2 * ys + uy, 2 * xs + ux, vote, 2 * yt + uy, 2 * xt + ux, w);
+                                copy(2 * ys + uy, 2 * xs + ux, 2 * yt + uy, 2 * xt + ux);
                             }
                         }
                     }
                     else
                     {
-                        _weighted_copy(source, ys, xs, vote, yt, xt, w);
+                        copy(ys, xs, yt, xt);
                     }
                 }
             }
@@ -280,7 +322,8 @@ void Inpainting::_expectation_step(
 }
 
 // Maximization Step: maximum likelihood of target pixel.
-void Inpainting::_maximization_step(MaskedImage &target, const cv::Mat &vote)
+void Inpainting::_maximization_step(
+    MaskedImage &target, const cv::Mat &vote, const MaskedImage &source, bool keep_known) const
 {
     auto target_size = target.size();
     for (int i = 0; i < target_size.height; ++i)
@@ -295,6 +338,16 @@ void Inpainting::_maximization_step(MaskedImage &target, const cv::Mat &vote)
                 continue;
             }
 
+            // Known pixels keep their values. Otherwise the votes of patches that overlap
+            // a hole change them, the holes are filled to match the changed surroundings,
+            // and a seam appears once the known pixels are restored at the end.
+            if (keep_known && !source.is_masked(i, j))
+            {
+                const unsigned char *known = source.get_image(i, j);
+                std::copy(known, known + 3, target_ptr);
+                continue;
+            }
+
             if (source_ptr[3] > 0)
             {
                 unsigned char r = cv::saturate_cast<unsigned char>(source_ptr[0] / source_ptr[3]);

{pypatchmatch-2.0.0rc2 → pypatchmatch-2.0.0rc4}/patchmatch/csrc/inpaint.h

@@ -15,8 +15,10 @@ public:
 private:
     void _initialize_pyramid(void);
     MaskedImage _expectation_maximization(MaskedImage source, MaskedImage target, int level, bool verbose);
-    void _expectation_step(const NearestNeighborField &nnf, bool source2target, cv::Mat &vote, const MaskedImage &source, bool upscaled);
-    void _maximization_step(MaskedImage &target, const cv::Mat &vote);
+    void _expectation_step(
+        const NearestNeighborField &nnf, bool source2target, cv::Mat &vote, const MaskedImage &source, bool upscaled,
+        bool best_only);
+    void _maximization_step(MaskedImage &target, const cv::Mat &vote, const MaskedImage &source, bool keep_known) const;
 
     MaskedImage m_initial;
     std::vector<MaskedImage> m_pyramid;

{pypatchmatch-2.0.0rc2 → pypatchmatch-2.0.0rc4}/patchmatch/csrc/masked_image.cpp

@@ -1,4 +1,5 @@
 #include "masked_image.h"
+
 #include <algorithm>
 #include <iostream>
 
@@ -73,7 +74,9 @@ MaskedImage MaskedImage::downsample() const
             if (ksum > 0)
             {
                 auto target_ptr = ret.get_mutable_image(y / 2, x / 2);
-                target_ptr[0] = r, target_ptr[1] = g, target_ptr[2] = b;
+                target_ptr[0] = static_cast<unsigned char>(r);
+                target_ptr[1] = static_cast<unsigned char>(g);
+                target_ptr[2] = static_cast<unsigned char>(b);
                 ret.set_mask(y / 2, x / 2, 0);
             }
             else

{pypatchmatch-2.0.0rc2 → pypatchmatch-2.0.0rc4}/patchmatch/csrc/masked_image.h

@@ -14,12 +14,14 @@ public:
     {
         // pass
     }
-    MaskedImage(cv::Mat image, cv::Mat mask, cv::Mat global_mask) : m_image(image), m_mask(mask), m_global_mask(global_mask), m_image_grad_computed(false)
+    MaskedImage(cv::Mat image, cv::Mat mask, cv::Mat global_mask)
+        : m_image(image), m_mask(mask), m_global_mask(global_mask), m_image_grad_computed(false)
     {
         // pass
     }
-    MaskedImage(cv::Mat image, cv::Mat mask, cv::Mat global_mask, cv::Mat grady, cv::Mat gradx, bool grad_computed) : m_image(image), m_mask(mask), m_global_mask(global_mask),
-                                                                                                                      m_image_grady(grady), m_image_gradx(gradx), m_image_grad_computed(grad_computed)
+    MaskedImage(cv::Mat image, cv::Mat mask, cv::Mat global_mask, cv::Mat grady, cv::Mat gradx, bool grad_computed)
+        : m_image(image), m_mask(mask), m_global_mask(global_mask), m_image_grady(grady), m_image_gradx(gradx),
+          m_image_grad_computed(grad_computed)
     {
         // pass
     }
@@ -31,11 +33,18 @@ public:
         m_mask = cv::Mat(cv::Size(width, height), CV_8U);
         m_mask = cv::Scalar::all(0);
     }
+    // cv::Mat's move assignment is not noexcept, so the implicit one would not be
+    MaskedImage(const MaskedImage &) = default;
+    MaskedImage(MaskedImage &&) noexcept = default;
+    MaskedImage &operator=(const MaskedImage &) = default;
+    MaskedImage &operator=(MaskedImage &&) noexcept = default;
+    ~MaskedImage() = default;
+
     inline MaskedImage clone()
     {
         return MaskedImage(
-            m_image.clone(), m_mask.clone(), m_global_mask.clone(),
-            m_image_grady.clone(), m_image_gradx.clone(), m_image_grad_computed);
+            m_image.clone(), m_mask.clone(), m_global_mask.clone(), m_image_grady.clone(), m_image_gradx.clone(),
+            m_image_grad_computed);
     }
 
     inline cv::Size size() const

{pypatchmatch-2.0.0rc2 → pypatchmatch-2.0.0rc4}/patchmatch/csrc/nnf.cpp

@@ -1,14 +1,16 @@
+#include "nnf.h"
+
 #include <algorithm>
-#include <iostream>
 #include <cmath>
+#include <cstdint>
+#include <iostream>
 #include <random>
 
 #include "masked_image.h"
-#include "nnf.h"
 
 /**
  * Nearest-Neighbor Field (see PatchMatch algorithm).
- * This algorithme uses a version proposed by Xavier Philippeau.
+ * This algorithm uses a version proposed by Xavier Philippeau.
  *
  */
 
@@ -36,7 +38,7 @@ namespace
     {
         return static_cast<int>(random_engine()() % static_cast<unsigned int>(n));
     }
-}
+} // namespace
 
 void NearestNeighborField::seed_random(unsigned int seed)
 {
@@ -98,8 +100,11 @@ void NearestNeighborField::_initialize_field_from(const NearestNeighborField &ot
             auto this_value = mutable_ptr(i, j);
             auto other_value = other.ptr(ilow, jlow);
 
-            this_value[0] = static_cast<int>(other_value[0] * fi);
-            this_value[1] = static_cast<int>(other_value[1] * fj);
+            // Keep the offset within the coarse pixel, so that neighbors still point to
+            // neighbors. Without it, both pixels of a pair point to the same target pixel,
+            // which makes the upscaled fill blocky.
+            this_value[0] = clamp(static_cast<int>(other_value[0] * fi + (i - ilow * fi)), 0, target_size().height - 1);
+            this_value[1] = clamp(static_cast<int>(other_value[1] * fj + (j - jlow * fj)), 0, target_size().width - 1);
             this_value[2] = _distance(i, j, this_value[0], this_value[1]);
         }
     }
@@ -196,12 +201,11 @@ namespace
     }
 
     int distance_masked_images(
-        const MaskedImage &source, int ys, int xs,
-        const MaskedImage &target, int yt, int xt,
-        int patch_size)
+        const MaskedImage &source, int ys, int xs, const MaskedImage &target, int yt, int xt, int patch_size)
     {
-        long double distance = 0;
-        long double wsum = 0;
+        // Exact integer sums: long double is emulated in software on Linux aarch64
+        std::int64_t distance = 0;
+        std::int64_t wsum = 0;
 
         source.compute_image_gradients();
         target.compute_image_gradients();
@@ -215,7 +219,7 @@ namespace
 
             if (yys <= 0 || yys >= source_size.height - 1 || yyt <= 0 || yyt >= target_size.height - 1)
             {
-                distance += (long double)(PatchSSDDistanceMetric::kSSDScale) * (2 * patch_size + 1);
+                distance += std::int64_t{PatchSSDDistanceMetric::kSSDScale} * (2 * patch_size + 1);
                 wsum += 2 * patch_size + 1;
                 continue;
             }
@@ -272,22 +276,23 @@ namespace
             }
         }
 
-        distance /= (long double)(PatchSSDDistanceMetric::kSSDScale);
-
-        int res = int(PatchDistanceMetric::kDistanceScale * distance / wsum);
+        const double scaled = static_cast<double>(distance) / PatchSSDDistanceMetric::kSSDScale;
+        const auto res = static_cast<int>(PatchDistanceMetric::kDistanceScale * scaled / static_cast<double>(wsum));
         if (res < 0 || res > PatchDistanceMetric::kDistanceScale)
             return PatchDistanceMetric::kDistanceScale;
         return res;
     }
 
-}
+} // namespace
 
-int PatchSSDDistanceMetric::operator()(const MaskedImage &source, int source_y, int source_x, const MaskedImage &target, int target_y, int target_x) const
+int PatchSSDDistanceMetric::operator()(
+    const MaskedImage &source, int source_y, int source_x, const MaskedImage &target, int target_y, int target_x) const
 {
     return distance_masked_images(source, source_y, source_x, target, target_y, target_x, m_patch_size);
 }
 
-int RegularityGuidedPatchDistanceMetricV2::operator()(const MaskedImage &source, int source_y, int source_x, const MaskedImage &target, int target_y, int target_x) const
+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)
         return PatchDistanceMetric::kDistanceScale;

{pypatchmatch-2.0.0rc2 → pypatchmatch-2.0.0rc4}/patchmatch/csrc/nnf.h

@@ -1,7 +1,8 @@
 #pragma once
 
-#include <stdexcept>
 #include <opencv2/core.hpp>
+#include <stdexcept>
+
 #include "masked_image.h"
 
 class PatchDistanceMetric
@@ -10,8 +11,13 @@ public:
     PatchDistanceMetric(int patch_size) : m_patch_size(patch_size) {}
     virtual ~PatchDistanceMetric() = default;
 
-    inline int patch_size() const { return m_patch_size; }
-    virtual int operator()(const MaskedImage &source, int source_y, int source_x, const MaskedImage &target, int target_y, int target_x) const = 0;
+    inline int patch_size() const
+    {
+        return m_patch_size;
+    }
+    virtual int operator()(
+        const MaskedImage &source, int source_y, int source_x, const MaskedImage &target, int target_y,
+        int target_x) const = 0;
     static const int kDistanceScale;
 
 protected:
@@ -25,13 +31,16 @@ public:
     {
         // pass
     }
-    NearestNeighborField(const MaskedImage &source, const MaskedImage &target, const PatchDistanceMetric *metric, int max_retry = 20)
+    NearestNeighborField(
+        const MaskedImage &source, const MaskedImage &target, const PatchDistanceMetric *metric, int max_retry = 20)
         : m_source(source), m_target(target), m_distance_metric(metric)
     {
         m_field = cv::Mat(m_source.size(), CV_32SC3);
         _randomize_field(max_retry);
     }
-    NearestNeighborField(const MaskedImage &source, const MaskedImage &target, const PatchDistanceMetric *metric, const NearestNeighborField &other, int max_retry = 20)
+    NearestNeighborField(
+        const MaskedImage &source, const MaskedImage &target, const PatchDistanceMetric *metric,
+        const NearestNeighborField &other, int max_retry = 20)
         : m_source(source), m_target(target), m_distance_metric(metric)
     {
         m_field = cv::Mat(m_source.size(), CV_32SC3);
@@ -111,7 +120,9 @@ class PatchSSDDistanceMetric : public PatchDistanceMetric
 {
 public:
     using PatchDistanceMetric::PatchDistanceMetric;
-    virtual int operator()(const MaskedImage &source, int source_y, int source_x, const MaskedImage &target, int target_y, int target_x) const;
+    virtual int operator()(
+        const MaskedImage &source, int source_y, int source_x, const MaskedImage &target, int target_y,
+        int target_x) const;
     static const int kSSDScale;
 };
 
@@ -125,7 +136,9 @@ public:
         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;
+    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;

{pypatchmatch-2.0.0rc2 → pypatchmatch-2.0.0rc4}/patchmatch/csrc/pyinterface.cpp

@@ -1,10 +1,11 @@
+#include "pyinterface.h"
+
 #include <atomic>
 #include <cstring>
 #include <exception>
 #include <memory>
 #include <string>
 
-#include "pyinterface.h"
 #include "inpaint.h"
 
 int _dtype_py_to_cv(int dtype_py);
@@ -66,7 +67,7 @@ namespace
         }
         return PM_mat_t{nullptr, {0, 0, 0}, 0};
     }
-}
+} // namespace
 
 const char *PM_last_error()
 {
@@ -85,10 +86,8 @@ void PM_set_verbose(int value)
 
 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
+    // Frees the buffer that _cv2_to_py released.
+    std::default_delete<unsigned char[]>()(static_cast<unsigned char *>(pymat.data_ptr));
 }
 
 PM_mat_t PM_inpaint(PM_mat_t source_py, PM_mat_t mask_py, int patch_size)
@@ -102,7 +101,8 @@ PM_mat_t PM_inpaint(PM_mat_t source_py, PM_mat_t mask_py, int patch_size)
     });
 }
 
-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)
+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);
@@ -123,12 +123,15 @@ PM_mat_t PM_inpaint2(PM_mat_t source_py, PM_mat_t mask_py, PM_mat_t global_mask_
         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());
+        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)
+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);
@@ -137,7 +140,8 @@ PM_mat_t PM_inpaint2_regularity(PM_mat_t source_py, PM_mat_t mask_py, PM_mat_t g
         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());
+        cv::Mat result =
+            Inpainting(source, mask, global_mask, &metric).run(verbose().load(), false, random_seed().load());
         return _cv2_to_py(result);
     });
 }

{pypatchmatch-2.0.0rc2 → pypatchmatch-2.0.0rc4}/patchmatch/csrc/pyinterface.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include <opencv2/core.hpp>
-#include <cstdlib>
 #include <cstdio>
+#include <cstdlib>
 #include <cstring>
+#include <opencv2/core.hpp>
 
 extern "C"
 {
@@ -42,6 +42,7 @@ extern "C"
     PM_mat_t PM_inpaint(PM_mat_t image, PM_mat_t mask, int patch_size);
     PM_mat_t PM_inpaint_regularity(PM_mat_t image, PM_mat_t mask, PM_mat_t ijmap, int patch_size, float guide_weight);
     PM_mat_t PM_inpaint2(PM_mat_t image, PM_mat_t mask, PM_mat_t global_mask, int patch_size);
-    PM_mat_t PM_inpaint2_regularity(PM_mat_t image, PM_mat_t mask, PM_mat_t global_mask, PM_mat_t ijmap, int patch_size, float guide_weight);
+    PM_mat_t PM_inpaint2_regularity(
+        PM_mat_t image, PM_mat_t mask, PM_mat_t global_mask, PM_mat_t ijmap, int patch_size, float guide_weight);
 
 } /*  extern "C" */

{pypatchmatch-2.0.0rc2 → pypatchmatch-2.0.0rc4}/scripts/build_opencv.py

@@ -134,8 +134,11 @@ def main() -> None:
             options.update(WINDOWS_CMAKE_OPTIONS)
         defines = [f"-D{key}={value}" for key, value in options.items()]
         subprocess.run([cmake, "-S", source, "-B", build, *defines], check=True)
+        # without a count, `make -j` starts all compilations at once
+        jobs = str(os.cpu_count() or 1)
         subprocess.run(
-            [cmake, "--build", build, "--config", "Release", "--parallel"], check=True
+            [cmake, "--build", build, "--config", "Release", "--parallel", jobs],
+            check=True,
         )
         subprocess.run([cmake, "--install", build, "--config", "Release"], check=True)
 

pypatchmatch-2.0.0rc4/scripts/evaluate_inpainting.py

@@ -0,0 +1,450 @@
+"""Measure how well patchmatch fills holes, to compare versions of the library.
+
+The holes are cut into images whose content is known: forest.bmp and the images listed
+in examples/images/SOURCES.md. forest_pruned.bmp and every ``*_pruned.*`` image in the
+git-ignored examples/images/local/ are added as object removals without a ground
+truth; their pure white pixels are the holes.
+
+Usage:
+    uv run python scripts/evaluate_inpainting.py
+    uv run python scripts/evaluate_inpainting.py --baseline main/libpatchmatch.dylib
+    uv run python scripts/evaluate_inpainting.py --patch-size 15 --seeds 1 --cases brick
+
+Besides the table, it writes examples/images/evaluation.html (git-ignored): the holes,
+the fills (of --baseline too) and the originals side by side. It embeds the images of
+examples/images/local/ as well, so keep it out of the repository.
+
+The e2e tests use measure() to check the seam and the detail of forest_pruned.bmp.
+
+Columns, means over the seeds:
+    seam    color difference of neighbors across the border of the holes, relative to
+            neighbors on either side of it; about 1.0 in the original images
+    detail  color difference of neighbors inside the holes, relative to their
+            surroundings; 0.85 to 1.1 in the original images, lower is blurrier
+    error   mean color error against the original on images reduced to 1/8, which
+            compares the structure of the fill rather than its pixels
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import ctypes
+import html
+import io
+import time
+from collections.abc import Iterator
+from datetime import datetime
+from pathlib import Path
+from typing import NamedTuple
+
+import numpy as np
+from PIL import Image
+
+import patchmatch
+from patchmatch import _lib, patch_match
+
+IMAGES = Path(__file__).resolve().parents[1] / "examples" / "images"
+LOCAL = IMAGES / "local"
+REPORT = IMAGES / "evaluation.html"
+
+# (center y, center x, radius y, radius x) of an elliptic hole
+HOLES = {
+    "brick": (256, 256, 55, 55),
+    "grass": (256, 256, 60, 60),
+    "gravel": (256, 256, 60, 60),
+    "coffee": (260, 85, 55, 60),
+    "chelsea": (52, 215, 24, 40),
+}
+COLUMNS = ("seam", "detail", "error")
+
+
+class Case(NamedTuple):
+    name: str
+    image: np.ndarray
+    holes: np.ndarray
+    truth: np.ndarray | None
+
+
+class Result(NamedTuple):
+    values: dict[str, float]  # means over the seeds
+    seconds: float  # per seed
+    fill: np.ndarray  # of seed 0
+
+
+def load(path: Path) -> np.ndarray:
+    return np.array(Image.open(path).convert("RGB"))
+
+
+def white(image: np.ndarray) -> np.ndarray:
+    return (image == 255).all(axis=2)
+
+
+def ellipse(shape: tuple[int, ...], cy: int, cx: int, ry: int, rx: int) -> np.ndarray:
+    yy, xx = np.mgrid[: shape[0], : shape[1]]
+    return ((yy - cy) / ry) ** 2 + ((xx - cx) / rx) ** 2 < 1
+
+
+def cut(name: str, truth: np.ndarray, holes: np.ndarray) -> Case:
+    image = truth.copy()
+    image[holes] = 255
+    return Case(name, image, holes, truth)
+
+
+def cases() -> Iterator[Case]:
+    forest = load(IMAGES / "forest.bmp")
+    pruned = load(IMAGES / "forest_pruned.bmp")
+    yield Case("forest", pruned, white(pruned), None)
+    yield cut("trees", forest, ellipse(forest.shape, 70, 560, 45, 55))
+    meadow = np.zeros(forest.shape[:2], dtype=bool)
+    meadow[318:350, 380:470] = True
+    yield cut("meadow", forest, meadow)
+    for name, hole in HOLES.items():
+        truth = load(IMAGES / f"{name}.png")
+        yield cut(name, truth, ellipse(truth.shape, *hole))
+    for path in sorted(LOCAL.glob("*_pruned.*")):
+        image = load(path)
+        yield Case(path.stem.removesuffix("_pruned"), image, white(image), None)
+
+
+def grow(mask: np.ndarray, radius: int) -> np.ndarray:
+    grown = mask.copy()
+    for _ in range(radius):
+        step = grown.copy()
+        step[1:] |= grown[:-1]
+        step[:-1] |= grown[1:]
+        step[:, 1:] |= grown[:, :-1]
+        step[:, :-1] |= grown[:, 1:]
+        grown = step
+    return grown
+
+
+def neighbor_difference(
+    image: np.ndarray, first: np.ndarray, second: np.ndarray
+) -> float:
+    """Mean color difference of adjacent pixels, one in ``first``, one in ``second``."""
+    pixels = image.astype(int)
+    dx = np.abs(pixels[:, 1:] - pixels[:, :-1]).sum(axis=2)
+    dy = np.abs(pixels[1:] - pixels[:-1]).sum(axis=2)
+    pairs_x = (first[:, 1:] & second[:, :-1]) | (second[:, 1:] & first[:, :-1])
+    pairs_y = (first[1:] & second[:-1]) | (second[1:] & first[:-1])
+    return float(np.concatenate([dx[pairs_x], dy[pairs_y]]).mean())
+
+
+def coarse_error(image: np.ndarray, truth: np.ndarray, holes: np.ndarray) -> float:
+    def reduce(array: np.ndarray) -> np.ndarray:
+        return np.array(Image.fromarray(array).reduce(8)).astype(float)
+
+    cells = reduce(holes.astype(np.uint8) * 255) > 200
+    return float(np.abs(reduce(image)[cells] - reduce(truth)[cells]).mean())
+
+
+def measure(
+    result: np.ndarray, holes: np.ndarray, truth: np.ndarray | None = None
+) -> dict[str, float]:
+    """The columns of the table for the fill ``result`` of ``holes``."""
+    known = ~holes
+    inner_ring = holes & grow(known, 8)
+    outer_ring = known & grow(holes, 8)
+    inside = holes & ~grow(known, 2)
+    around = grow(holes, 24) & ~grow(holes, 2)
+    along = (
+        neighbor_difference(result, inner_ring, inner_ring)
+        + neighbor_difference(result, outer_ring, outer_ring)
+    ) / 2
+    values = {
+        "seam": neighbor_difference(result, holes, known) / along,
+        "detail": neighbor_difference(result, inside, inside)
+        / neighbor_difference(result, around, around),
+    }
+    if truth is not None:
+        values["error"] = coarse_error(result, truth, holes)
+    return values
+
+
+def load_library(path: Path) -> ctypes.CDLL:
+    """Load another build of the library than the installed one."""
+    _lib.find_library = lambda: path
+    return _lib.load_library()
+
+
+def evaluate(library: ctypes.CDLL, case: Case, patch_size: int, seeds: int) -> Result:
+    patch_match._lib = library
+    mask = case.holes.astype(np.uint8)
+    rows, fills = [], []
+    start = time.perf_counter()
+    for seed in range(seeds):
+        patchmatch.set_random_seed(seed)
+        fills.append(patchmatch.inpaint(case.image, mask, patch_size=patch_size))
+        rows.append(measure(fills[-1], case.holes, case.truth))
+    seconds = (time.perf_counter() - start) / seeds
+    values = {key: float(np.mean([row[key] for row in rows])) for key in rows[0]}
+    return Result(values, seconds, fills[0])
+
+
+def print_row(name: str, results: list[Result]) -> None:
+    """One line of the table, with ``old -> new`` for a baseline."""
+    cells = []
+    for key in COLUMNS:
+        found = [
+            f"{result.values[key]:.2f}" for result in results if key in result.values
+        ]
+        cells.append(f"{' -> '.join(found):16}")
+    seconds = " -> ".join(f"{result.seconds:.1f}s" for result in results)
+    print(f"{name:10} {''.join(cells)}{seconds}", flush=True)
+
+
+# Report ------------------------------------------------------------------------------
+
+STYLE = """
+:root { color-scheme: light dark; --bg: #f7f7f5; --fg: #1d1d1b; --muted: #6f6f6a;
+  --card: #fff; --line: #e3e3de; --good: #1b7f3b; --bad: #b42318; }
+@media (prefers-color-scheme: dark) { :root { --bg: #161615; --fg: #efefec;
+  --muted: #a3a39c; --card: #22221f; --line: #3a3a36; --good: #5bd181;
+  --bad: #ff8a7a; } }
+* { box-sizing: border-box; }
+body { margin: 0; padding: 0 16px 64px; background: var(--bg); color: var(--fg);
+  font: 15px/1.5 system-ui, -apple-system, "Segoe UI", sans-serif; }
+main { max-width: 1440px; margin: 0 auto; }
+header { padding: 24px 0 8px; }
+h1 { font-size: 22px; margin: 0 0 4px; }
+.meta, .hint { color: var(--muted); font-size: 13px; margin: 0; }
+.controls { position: sticky; top: 0; z-index: 1; display: flex; flex-wrap: wrap;
+  gap: 8px 24px; padding: 10px 0; background: var(--bg);
+  border-bottom: 1px solid var(--line); }
+.controls label { cursor: pointer; }
+table { border-collapse: collapse; margin: 16px 0 28px;
+  font-variant-numeric: tabular-nums; }
+th, td { padding: 4px 18px 4px 0; text-align: right; white-space: nowrap; }
+th:first-child, td:first-child { text-align: left; }
+th { color: var(--muted); font-weight: 500; border-bottom: 1px solid var(--line); }
+a { color: inherit; }
+.better { color: var(--good); font-weight: 600; }
+.worse { color: var(--bad); font-weight: 600; }
+section { background: var(--card); border: 1px solid var(--line); border-radius: 8px;
+  padding: 12px 16px 16px; margin: 0 0 20px; }
+section h2 { font-size: 17px; margin: 0; display: inline; }
+section .meta { display: inline; margin-left: 10px; }
+.versions { display: grid; gap: 12px; margin-top: 10px;
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 240px), 1fr)); }
+figure { margin: 0; cursor: zoom-in; }
+figcaption { font-size: 13px; color: var(--muted); margin-top: 4px;
+  font-variant-numeric: tabular-nums; }
+figcaption b { color: var(--fg); font-weight: 600; margin-right: 6px; }
+.frame { position: relative; overflow: hidden; width: 100%;
+  aspect-ratio: var(--crop); background: var(--line); }
+.frame img { position: absolute; display: block; max-width: none; height: auto;
+  left: var(--left); top: var(--top); width: var(--width); }
+body.whole .frame { aspect-ratio: var(--full); }
+body.whole .frame img { left: 0; top: 0; width: 100%; }
+body.pixels img { image-rendering: pixelated; }
+#viewer { position: fixed; inset: 0; z-index: 10; display: flex;
+  flex-direction: column; align-items: center; justify-content: center; gap: 10px;
+  background: rgb(0 0 0 / 0.9); cursor: zoom-out; }
+#viewer[hidden] { display: none; }
+#viewer .frame { width: min(94vw, calc(86vh * var(--crop))); cursor: pointer; }
+body.whole #viewer .frame { width: min(94vw, calc(86vh * var(--full))); }
+#viewer p { color: #ddd; font-size: 14px; margin: 0; }
+"""
+
+SCRIPT = """
+const viewer = document.getElementById("viewer");
+let figures = [];
+let index = 0;
+function show(i) {
+  index = (i + figures.length) % figures.length;
+  const figure = figures[index];
+  viewer.querySelector(".slot").replaceChildren(
+    figure.querySelector(".frame").cloneNode(true));
+  viewer.querySelector("p").textContent = figure.dataset.title
+    + "  (" + (index + 1) + "/" + figures.length + ")";
+}
+for (const figure of document.querySelectorAll("figure")) {
+  figure.addEventListener("click", () => {
+    figures = Array.from(figure.parentElement.querySelectorAll("figure"));
+    viewer.hidden = false;
+    show(figures.indexOf(figure));
+  });
+}
+viewer.addEventListener("click", (event) => {
+  if (event.target.closest(".frame")) show(index + 1);
+  else viewer.hidden = true;
+});
+document.addEventListener("keydown", (event) => {
+  if (viewer.hidden) return;
+  if (event.key === "ArrowRight" || event.key === " ") show(index + 1);
+  else if (event.key === "ArrowLeft") show(index - 1);
+  else if (event.key === "Escape") viewer.hidden = true;
+  else return;
+  event.preventDefault();
+});
+for (const name of ["whole", "pixels"]) {
+  const box = document.getElementById(name);
+  const apply = () => document.body.classList.toggle(name, box.checked);
+  box.addEventListener("change", apply);
+  apply();  // browsers restore the checkboxes on reload
+}
+"""
+
+
+def png(image: np.ndarray) -> str:
+    buffer = io.BytesIO()
+    Image.fromarray(image).save(buffer, format="PNG")
+    return base64.b64encode(buffer.getvalue()).decode("ascii")
+
+
+def crop_box(holes: np.ndarray) -> tuple[int, int, int, int]:
+    """(x, y, width, height) around the holes, or the whole image if they fill most."""
+    height, width = holes.shape
+    if not holes.any():
+        return 0, 0, width, height
+    ys, xs = np.nonzero(holes)
+    margin = max(16, (max(np.ptp(ys), np.ptp(xs)) + 1) // 4)
+    x0, x1 = max(0, xs.min() - margin), min(width, xs.max() + 1 + margin)
+    y0, y1 = max(0, ys.min() - margin), min(height, ys.max() + 1 + margin)
+    if (x1 - x0) * (y1 - y0) > 0.6 * width * height:
+        return 0, 0, width, height
+    return int(x0), int(y0), int(x1 - x0), int(y1 - y0)
+
+
+def frame(image: np.ndarray, box: tuple[int, int, int, int]) -> str:
+    """The image, cut to ``box`` by CSS unless the whole images are shown."""
+    height, width = image.shape[:2]
+    x, y, w, h = box
+    style = (
+        f"--crop:{w / h:.5f};--full:{width / height:.5f};--width:{100 * width / w:.4f}%;"
+        f"--left:{-100 * x / w:.4f}%;--top:{-100 * y / h:.4f}%"
+    )
+    source = f"data:image/png;base64,{png(image)}"
+    return f'<div class="frame" style="{style}"><img alt="" src="{source}"></div>'
+
+
+def verdict(key: str, old: float, new: float) -> str:
+    """CSS class of ``new`` compared with ``old``: better, worse or none."""
+    if abs(new - old) <= (0.1 if key == "time" else 0.02) * abs(old):
+        return ""
+    if key in ("seam", "detail"):  # best at 1.0, as in the original images
+        old, new = abs(old - 1), abs(new - 1)
+    return "better" if new < old else "worse"
+
+
+def cell(key: str, results: list[Result]) -> str:
+    if key == "time":
+        values = [result.seconds for result in results]
+        text = [f"{value:.1f} s" for value in values]
+    else:
+        values = [result.values[key] for result in results if key in result.values]
+        text = [f"{value:.2f}" for value in values]
+    if not values:
+        return "<td></td>"
+    if len(values) == 1:
+        return f"<td>{text[0]}</td>"
+    css = verdict(key, values[0], values[1])
+    return f'<td>{text[0]} &rarr; <span class="{css}">{text[1]}</span></td>'
+
+
+def caption(label: str, result: Result | None) -> str:
+    parts = [f"<b>{label}</b>"]
+    if result is not None:
+        parts += [f"{key} {value:.2f}" for key, value in result.values.items()]
+    return " ".join(parts)
+
+
+def section(case: Case, results: list[Result], labels: list[str]) -> str:
+    box = crop_box(case.holes)
+    versions = [("holes", case.image, None)]
+    versions += [(label, r.fill, r) for label, r in zip(labels, results, strict=True)]
+    if case.truth is not None:
+        versions.append(("original", case.truth, None))
+    figures = "".join(
+        f'<figure data-title="{html.escape(case.name)}: {label}">'
+        f"{frame(image, box)}<figcaption>{caption(label, result)}</figcaption></figure>"
+        for label, image, result in versions
+    )
+    height, width = case.holes.shape
+    meta = f"{width}&times;{height}, holes {case.holes.mean():.1%}"
+    name = html.escape(case.name)
+    return (
+        f'<section id="{name}"><h2>{name}</h2><p class="meta">{meta}</p>'
+        f'<div class="versions">{figures}</div></section>'
+    )
+
+
+def write_report(
+    rows: list[tuple[Case, list[Result]]], labels: list[str], meta: str
+) -> None:
+    columns = [*COLUMNS, "time"]
+    head = "".join(f"<th>{key}</th>" for key in ["case", *columns])
+    body = "".join(
+        f'<tr><td><a href="#{html.escape(case.name)}">{html.escape(case.name)}</a></td>'
+        + "".join(cell(key, results) for key in columns)
+        + "</tr>"
+        for case, results in rows
+    )
+    sections = "".join(section(case, results, labels) for case, results in rows)
+    with REPORT.open("w", encoding="utf-8") as report:
+        report.write(
+            "<!doctype html>\n"
+            '<html lang="en"><head><meta charset="utf-8">'
+            '<meta name="viewport" content="width=device-width, initial-scale=1">'
+            f"<title>patchmatch evaluation</title><style>{STYLE}</style></head><body>"
+            f"<main><header><h1>patchmatch evaluation</h1>{meta}</header>"
+            '<div class="controls">'
+            '<label><input type="checkbox" id="whole"> whole images</label>'
+            '<label><input type="checkbox" id="pixels"> show pixels</label>'
+            '<p class="hint">Click an image to enlarge it; click it, &larr; or &rarr; '
+            "switches between the versions, Esc closes.</p></div>"
+            f"<table><thead><tr>{head}</tr></thead><tbody>{body}</tbody></table>"
+            f'{sections}</main><div id="viewer" hidden><div class="slot"></div><p></p>'
+            f"</div><script>{SCRIPT}</script></body></html>\n"
+        )
+
+
+def describe(args: argparse.Namespace, labels: list[str], paths: list[str]) -> str:
+    lines = [
+        f"{datetime.now():%Y-%m-%d %H:%M}, patch_size {args.patch_size}, "
+        f"{args.seeds} seed(s), fills of seed 0",
+        *(f"{label}: {path}" for label, path in zip(labels, paths, strict=True)),
+    ]
+    return "".join(f'<p class="meta">{html.escape(line)}</p>' for line in lines)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--library", type=Path, help="library file to load instead")
+    parser.add_argument("--baseline", type=Path, help="library file to compare with")
+    parser.add_argument("--patch-size", type=int, default=3)
+    parser.add_argument("--seeds", type=int, default=3)
+    parser.add_argument("--cases", help="comma-separated names, default: all")
+    args = parser.parse_args()
+    if args.seeds < 1:
+        parser.error("--seeds must be at least 1")
+
+    current = load_library(args.library.resolve()) if args.library else patch_match._lib
+    if current is None:
+        parser.error("the installed package has no native library, pass --library")
+    libraries, labels = [current], ["fill"]
+    if args.baseline:
+        libraries.insert(0, load_library(args.baseline.resolve()))
+        labels = ["baseline", "current"]
+    selected = set(args.cases.split(",")) if args.cases else None
+
+    print(f"patch_size={args.patch_size} seeds={args.seeds}")
+    print(f"{'case':10} {'seam':16}{'detail':16}{'error':16}time")
+    rows = []
+    for case in cases():
+        if selected and case.name not in selected:
+            continue
+        results = [
+            evaluate(lib, case, args.patch_size, args.seeds) for lib in libraries
+        ]
+        print_row(case.name, results)
+        rows.append((case, results))
+
+    meta = describe(args, labels, [lib._name for lib in libraries])
+    write_report(rows, labels, meta)
+    print(f"report: {REPORT}")
+
+
+if __name__ == "__main__":
+    main()

{pypatchmatch-2.0.0rc2 → pypatchmatch-2.0.0rc4}/tests/test_e2e.py

@@ -1,5 +1,6 @@
 """End-to-end tests of the user workflows shown in examples/ and the README."""
 
+import importlib.util
 from pathlib import Path
 
 import numpy as np
@@ -9,6 +10,7 @@ from PIL import Image, ImageFilter
 import patchmatch
 
 IMAGES = Path(__file__).parents[1] / "examples" / "images"
+SCRIPTS = Path(__file__).parents[1] / "scripts"
 
 pytestmark = pytest.mark.e2e
 
@@ -50,6 +52,18 @@ def assert_plausible_fill(
     assert color_diff.max() < 10, color_diff
 
 
+def load_evaluation():
+    """scripts/evaluate_inpainting.py, whose measures the quality tests share."""
+    path = SCRIPTS / "evaluate_inpainting.py"
+    spec = importlib.util.spec_from_file_location("evaluate_inpainting", path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+evaluation = load_evaluation()
+
+
 def coarse_error(image: np.ndarray, truth: np.ndarray, mask: np.ndarray) -> float:
     """Mean error inside ``mask`` on a downscaled image (texture, not pixels)."""
 
@@ -118,6 +132,30 @@ def test_global_mask_is_not_used_as_source(pruned_image):
     np.testing.assert_array_equal(result[excluded], source[excluded])
 
 
+def test_fill_is_as_detailed_as_its_surroundings(pruned_image):
+    """The weighted mean of all overlapping patches blurred the fill (detail 0.69)."""
+    source = np.array(pruned_image)
+    holes = white_pixels(source)
+
+    result = patchmatch.inpaint(source, patch_size=3)
+
+    assert evaluation.measure(result, holes)["detail"] > 0.8
+
+
+def test_no_seam_at_the_hole_border(pruned_image):
+    """Known pixels changed during the iterations and restored at the end left a seam.
+
+    The difference across the border of the holes was about twice the difference of
+    neighbors on either side of it (seam 2.03).
+    """
+    source = np.array(pruned_image)
+    holes = white_pixels(source)
+
+    result = patchmatch.inpaint(source, patch_size=3)
+
+    assert evaluation.measure(result, holes)["seam"] < 1.9
+
+
 @pytest.mark.parametrize("hole_value", [1, 255])
 def test_explicit_mask_matches_implicit_white_mask(pruned_image, hole_value):
     """README: an explicit mask behaves like the default mask of white pixels."""