PyPatchMatch 2.0.0rc3__tar.gz → 2.0.0rc4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPatchMatch
-Version: 2.0.0rc3
+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)

{pypatchmatch-2.0.0rc3 → 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)

{pypatchmatch-2.0.0rc3 → 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.0rc3'
-__version_tuple__ = version_tuple = (2, 0, 0, 'rc3')
+__version__ = version = '2.0.0rc4'
+__version_tuple__ = version_tuple = (2, 0, 0, 'rc4')
 
-__commit_id__ = commit_id = 'g70cf3a861'
+__commit_id__ = commit_id = 'g6f35e1d41'

{pypatchmatch-2.0.0rc3 → 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;
@@ -67,10 +68,10 @@ namespace
             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)
@@ -89,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);
@@ -99,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)
@@ -210,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
@@ -253,8 +256,8 @@ 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, bool best_only)
+    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();
@@ -262,8 +265,7 @@ void Inpainting::_expectation_step(
     const auto &kDistance2Similarity = distance2similarity();
 
     double w = 0;
-    auto copy = [&](int ys, int xs, int yt, int xt)
-    {
+    auto copy = [&](int ys, int xs, int yt, int xt) {
         if (best_only)
             _best_copy(source, ys, xs, vote, yt, xt, w);
         else
@@ -320,7 +322,8 @@ void Inpainting::_expectation_step(
 }
 
 // Maximization Step: maximum likelihood of target pixel.
-void Inpainting::_maximization_step(MaskedImage &target, const cv::Mat &vote, const MaskedImage &source, bool keep_known) const
+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)

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

@@ -15,7 +15,9 @@ 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, bool best_only);
+    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;

{pypatchmatch-2.0.0rc3 → 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.0rc3 → 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.0rc3 → 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)
 {
@@ -199,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();
@@ -218,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;
             }
@@ -275,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.0rc3 → 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.0rc3 → 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.0rc3 → 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.0rc3 → 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.0rc3 → pypatchmatch-2.0.0rc4}/scripts/evaluate_inpainting.py

@@ -382,25 +382,22 @@ def write_report(
         for case, results in rows
     )
     sections = "".join(section(case, results, labels) for case, results in rows)
-    # SonarCloud's path traversal rule for command line arguments (pythonsecurity:S8707)
-    # flags the patch size, the seeds and the library paths in the content. The path is
-    # fixed, and they only appear as escaped text, so the issue is suppressed.
-    REPORT.write_text(  # NOSONAR
-        "<!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",
-        encoding="utf-8",
-    )
+    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: