PyPatchMatch 1.0.2__tar.gz → 2.0.0b2__tar.gz

pypatchmatch-2.0.0b2/CMakeLists.txt

@@ -0,0 +1,76 @@
+cmake_minimum_required(VERSION 3.21)
+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)
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+endif()
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+
+set(PATCHMATCH_OPENCV_COMPONENTS core)
+if(PATCHMATCH_WITH_HIGHGUI)
+  list(APPEND PATCHMATCH_OPENCV_COMPONENTS imgproc highgui)
+endif()
+if(PATCHMATCH_BUILD_EXAMPLES)
+  list(APPEND PATCHMATCH_OPENCV_COMPONENTS imgcodecs)
+endif()
+find_package(OpenCV REQUIRED COMPONENTS ${PATCHMATCH_OPENCV_COMPONENTS})
+
+add_library(patchmatch SHARED
+  patchmatch/csrc/inpaint.cpp
+  patchmatch/csrc/masked_image.cpp
+  patchmatch/csrc/nnf.cpp
+  patchmatch/csrc/pyinterface.cpp
+)
+target_include_directories(patchmatch PUBLIC patchmatch/csrc)
+target_link_libraries(patchmatch PUBLIC opencv_core)
+
+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(MSVC)
+    target_compile_options(patchmatch PRIVATE /fp:fast)
+  else()
+    target_compile_options(patchmatch PRIVATE -ffast-math)
+  endif()
+endif()
+
+if(PATCHMATCH_WITH_HIGHGUI)
+  target_compile_definitions(patchmatch PRIVATE PATCHMATCH_WITH_HIGHGUI)
+  target_link_libraries(patchmatch PRIVATE opencv_imgproc opencv_highgui)
+endif()
+
+if(PATCHMATCH_BUILD_EXAMPLES)
+  add_executable(cpp_example examples/cpp_example.cpp)
+  target_link_libraries(cpp_example PRIVATE patchmatch opencv_imgcodecs)
+endif()
+
+# The Python package loads the library via ctypes from its own directory.
+install(TARGETS patchmatch
+  LIBRARY DESTINATION patchmatch
+  RUNTIME DESTINATION patchmatch
+)
+
+# A static OpenCV becomes part of the library, so a wheel has to ship its licenses,
+# which scripts/build_opencv.py collects in <prefix>/licenses.
+if(DEFINED SKBUILD_METADATA_DIR AND NOT OpenCV_SHARED)
+  set(PATCHMATCH_OPENCV_LICENSES "${OpenCV_INSTALL_PATH}/licenses")
+  if(EXISTS "${PATCHMATCH_OPENCV_LICENSES}/opencv-LICENSE")
+    install(DIRECTORY "${PATCHMATCH_OPENCV_LICENSES}/"
+      DESTINATION "${SKBUILD_METADATA_DIR}/licenses/opencv")
+  else()
+    message(WARNING "No OpenCV licenses in ${PATCHMATCH_OPENCV_LICENSES}, "
+      "the wheel will not include them")
+  endif()
+endif()

pypatchmatch-2.0.0b2/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: PyPatchMatch
+Version: 2.0.0b2
+Summary: This library implements the PatchMatch based inpainting algorithm.
+Keywords: inpainting,patchmatch,image-processing,opencv
+Author-Email: The InvokeAI Project <lincoln.stein@gmail.com>, Jiayuan Mao <maojiayuan@gmail.com>, Kyle Schouviller <kyle0654@hotmail.com>, Matthias Wild <mauwii@outlook.de>, Younesse ANDAM <younesse.andam@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Typing :: Typed
+Project-URL: Source Code, https://github.com/mauwii/PyPatchMatch
+Project-URL: Issues, https://github.com/mauwii/PyPatchMatch/issues
+Project-URL: Release Notes, https://github.com/mauwii/PyPatchMatch/releases
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Requires-Dist: pillow
+Description-Content-Type: text/markdown
+
+# PatchMatch based Inpainting
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blueviolet.svg)](https://github.com/mauwii/PyPatchMatch/blob/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/PyPatchMatch)](https://pypi.org/project/PyPatchMatch/)
+[![Downloads](https://static.pepy.tech/badge/pypatchmatch)](https://pepy.tech/projects/pypatchmatch)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+This library implements the PatchMatch based inpainting algorithm. It provides both C++
+and Python interfaces. This implementation is heavily based on the implementation by
+Younesse ANDAM: [younesse-cv/PatchMatch](https://github.com/younesse-cv/PatchMatch),
+with some bug fixes, and updates.
+
+## Installation
+
+```sh
+pip install PyPatchMatch
+```
+
+Wheels for Linux (glibc, x86_64 and aarch64), macOS 11+ (arm64 and x86_64) and Windows
+(x64) ship the compiled library with a statically linked OpenCV, so no compiler or
+OpenCV installation is needed. On other platforms, e.g. Alpine Linux or Windows on ARM,
+pip builds from the source distribution, which requires a C++17 compiler, CMake and the
+OpenCV development files (e.g. `apt install libopencv-dev` or `brew install opencv`).
+
+## Usage
+
+Python (see
+[examples/py_example.py](https://github.com/mauwii/PyPatchMatch/blob/main/examples/py_example.py)):
+
+```python
+import patchmatch
+
+image = ...  # HxWx3 uint8 numpy array or PIL image
+mask = ...  # HxW uint8 or bool numpy array or PIL image, non-zero marks the holes
+result = patchmatch.inpaint(image, mask, patch_size=3)
+```
+
+The mask must have the same height and width as the image. If `mask` is omitted, all
+pure white pixels are treated as holes. The optional keyword argument `global_mask`, in
+the same format, marks pixels that are neither filled nor used as a source; they keep
+their values (see
+[examples/py_example_global_mask.py](https://github.com/mauwii/PyPatchMatch/blob/main/examples/py_example_global_mask.py)).
+`patchmatch.patchmatch_available` tells whether the native library could be loaded.
+The previous import path `from patchmatch import patch_match` keeps working.
+
+`patchmatch.set_random_seed(seed)` sets the seed of the randomized search and
+`patchmatch.set_verbose(True)` prints the progress of the native code to stderr.
+`patchmatch.inpaint_regularity(image, mask, ijmap)` additionally guides the search with
+a regularity map, an HxWx3 float32 array with the regularity coordinates of each pixel.
+
+C++ (see
+[examples/cpp_example.cpp](https://github.com/mauwii/PyPatchMatch/blob/main/examples/cpp_example.cpp),
+build and run it with
+[examples/cpp_example_run.sh](https://github.com/mauwii/PyPatchMatch/blob/main/examples/cpp_example_run.sh)):
+
+```cpp
+#include "inpaint.h"
+
+int main() {
+    cv::Mat image = ...;
+    cv::Mat mask = ...;
+
+    auto metric = PatchSSDDistanceMetric(5);
+    cv::Mat result = Inpainting(image, mask, &metric).run();
+}
+```
+
+The library is built with CMake; `PATCHMATCH_BUILD_EXAMPLES` builds the example and
+`PATCHMATCH_WITH_HIGHGUI` enables the debug visualization of `Inpainting::run`.
+
+## Development
+
+The project is managed with [uv](https://docs.astral.sh/uv/):
+
+```sh
+uv sync                        # create .venv, build the library, install dev deps
+uv run pre-commit install      # enable ruff and the other hooks on commit
+uv run pytest                  # run the test suite
+uv run pytest -m "not e2e"     # only the fast unit tests
+```
+
+Releases are published to PyPI by creating a GitHub release; the version is taken from
+its tag (e.g. `v2.0.0`).
+
+## License
+
+PyPatchMatch is released under the
+[MIT License](https://github.com/mauwii/PyPatchMatch/blob/main/LICENSE). The wheels
+contain a statically linked build of OpenCV core (Apache-2.0) and its bundled
+third-party code; their licenses are included in the `licenses/opencv` directory of the
+wheel's `.dist-info`.
+
+## README and COPYRIGHT by Younesse ANDAM
+
+@Author: Younesse ANDAM
+
+@Contact: <younesse.andam@gmail.com>
+
+Description:
+
+This project is a personal implementation of an algorithm called PATCHMATCH
+that restores missing areas in an image. The algorithm is presented in the following
+paper PatchMatch A Randomized Correspondence Algorithm for Structural Image Editing by
+C.Barnes, E.Shechtman, A.Finkelstein and Dan B.Goldman ACM Transactions on Graphics
+(Proc. SIGGRAPH), vol.28, aug-2009
+
+For more information please refer to
+<https://gfx.cs.princeton.edu/pubs/Barnes_2009_PAR/>
+
+Copyright (c) 2010-2011

pypatchmatch-2.0.0b2/README.md

@@ -0,0 +1,110 @@
+# PatchMatch based Inpainting
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blueviolet.svg)](https://github.com/mauwii/PyPatchMatch/blob/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/PyPatchMatch)](https://pypi.org/project/PyPatchMatch/)
+[![Downloads](https://static.pepy.tech/badge/pypatchmatch)](https://pepy.tech/projects/pypatchmatch)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+This library implements the PatchMatch based inpainting algorithm. It provides both C++
+and Python interfaces. This implementation is heavily based on the implementation by
+Younesse ANDAM: [younesse-cv/PatchMatch](https://github.com/younesse-cv/PatchMatch),
+with some bug fixes, and updates.
+
+## Installation
+
+```sh
+pip install PyPatchMatch
+```
+
+Wheels for Linux (glibc, x86_64 and aarch64), macOS 11+ (arm64 and x86_64) and Windows
+(x64) ship the compiled library with a statically linked OpenCV, so no compiler or
+OpenCV installation is needed. On other platforms, e.g. Alpine Linux or Windows on ARM,
+pip builds from the source distribution, which requires a C++17 compiler, CMake and the
+OpenCV development files (e.g. `apt install libopencv-dev` or `brew install opencv`).
+
+## Usage
+
+Python (see
+[examples/py_example.py](https://github.com/mauwii/PyPatchMatch/blob/main/examples/py_example.py)):
+
+```python
+import patchmatch
+
+image = ...  # HxWx3 uint8 numpy array or PIL image
+mask = ...  # HxW uint8 or bool numpy array or PIL image, non-zero marks the holes
+result = patchmatch.inpaint(image, mask, patch_size=3)
+```
+
+The mask must have the same height and width as the image. If `mask` is omitted, all
+pure white pixels are treated as holes. The optional keyword argument `global_mask`, in
+the same format, marks pixels that are neither filled nor used as a source; they keep
+their values (see
+[examples/py_example_global_mask.py](https://github.com/mauwii/PyPatchMatch/blob/main/examples/py_example_global_mask.py)).
+`patchmatch.patchmatch_available` tells whether the native library could be loaded.
+The previous import path `from patchmatch import patch_match` keeps working.
+
+`patchmatch.set_random_seed(seed)` sets the seed of the randomized search and
+`patchmatch.set_verbose(True)` prints the progress of the native code to stderr.
+`patchmatch.inpaint_regularity(image, mask, ijmap)` additionally guides the search with
+a regularity map, an HxWx3 float32 array with the regularity coordinates of each pixel.
+
+C++ (see
+[examples/cpp_example.cpp](https://github.com/mauwii/PyPatchMatch/blob/main/examples/cpp_example.cpp),
+build and run it with
+[examples/cpp_example_run.sh](https://github.com/mauwii/PyPatchMatch/blob/main/examples/cpp_example_run.sh)):
+
+```cpp
+#include "inpaint.h"
+
+int main() {
+    cv::Mat image = ...;
+    cv::Mat mask = ...;
+
+    auto metric = PatchSSDDistanceMetric(5);
+    cv::Mat result = Inpainting(image, mask, &metric).run();
+}
+```
+
+The library is built with CMake; `PATCHMATCH_BUILD_EXAMPLES` builds the example and
+`PATCHMATCH_WITH_HIGHGUI` enables the debug visualization of `Inpainting::run`.
+
+## Development
+
+The project is managed with [uv](https://docs.astral.sh/uv/):
+
+```sh
+uv sync                        # create .venv, build the library, install dev deps
+uv run pre-commit install      # enable ruff and the other hooks on commit
+uv run pytest                  # run the test suite
+uv run pytest -m "not e2e"     # only the fast unit tests
+```
+
+Releases are published to PyPI by creating a GitHub release; the version is taken from
+its tag (e.g. `v2.0.0`).
+
+## License
+
+PyPatchMatch is released under the
+[MIT License](https://github.com/mauwii/PyPatchMatch/blob/main/LICENSE). The wheels
+contain a statically linked build of OpenCV core (Apache-2.0) and its bundled
+third-party code; their licenses are included in the `licenses/opencv` directory of the
+wheel's `.dist-info`.
+
+## README and COPYRIGHT by Younesse ANDAM
+
+@Author: Younesse ANDAM
+
+@Contact: <younesse.andam@gmail.com>
+
+Description:
+
+This project is a personal implementation of an algorithm called PATCHMATCH
+that restores missing areas in an image. The algorithm is presented in the following
+paper PatchMatch A Randomized Correspondence Algorithm for Structural Image Editing by
+C.Barnes, E.Shechtman, A.Finkelstein and Dan B.Goldman ACM Transactions on Graphics
+(Proc. SIGGRAPH), vol.28, aug-2009
+
+For more information please refer to
+<https://gfx.cs.princeton.edu/pubs/Barnes_2009_PAR/>
+
+Copyright (c) 2010-2011

pypatchmatch-2.0.0b2/patchmatch/__init__.py

@@ -0,0 +1,19 @@
+"""PatchMatch based inpainting."""
+
+from ._version import __version__
+from .patch_match import (
+    inpaint,
+    inpaint_regularity,
+    patchmatch_available,
+    set_random_seed,
+    set_verbose,
+)
+
+__all__ = [
+    "__version__",
+    "inpaint",
+    "inpaint_regularity",
+    "patchmatch_available",
+    "set_random_seed",
+    "set_verbose",
+]

pypatchmatch-2.0.0b2/patchmatch/_lib.py

@@ -0,0 +1,124 @@
+"""ctypes bindings for the native patchmatch library."""
+
+from __future__ import annotations
+
+import ctypes
+import sys
+from pathlib import Path
+
+import numpy as np
+
+if sys.platform == "win32":
+    LIBRARY_NAME = "patchmatch.dll"
+elif sys.platform == "darwin":
+    LIBRARY_NAME = "libpatchmatch.dylib"
+else:
+    LIBRARY_NAME = "libpatchmatch.so"
+
+
+class CShapeT(ctypes.Structure):
+    _fields_ = [
+        ("width", ctypes.c_int),
+        ("height", ctypes.c_int),
+        ("channels", ctypes.c_int),
+    ]
+
+
+class CMatT(ctypes.Structure):
+    _fields_ = [
+        ("data_ptr", ctypes.c_void_p),
+        ("shape", CShapeT),
+        ("dtype", ctypes.c_int),
+    ]
+
+
+# Order matches the PM_dtype_e enum in csrc/pyinterface.h.
+_PYMAT_DTYPES = [
+    np.dtype(np.uint8),
+    np.dtype(np.int8),
+    np.dtype(np.uint16),
+    np.dtype(np.int16),
+    np.dtype(np.int32),
+    np.dtype(np.float32),
+    np.dtype(np.float64),
+]
+_PYMAT_DTYPE_IDS = {dtype: i for i, dtype in enumerate(_PYMAT_DTYPES)}
+
+
+def np_to_pymat(npmat: np.ndarray) -> CMatT:
+    """Wrap a contiguous HxWxC array without copying it."""
+    if npmat.ndim != 3:
+        raise ValueError(f"expected a 3-dimensional array, got {npmat.ndim} dims")
+    if not npmat.flags.c_contiguous:
+        raise ValueError("expected a C-contiguous array")
+    try:
+        dtype_id = _PYMAT_DTYPE_IDS[npmat.dtype]
+    except KeyError:
+        raise TypeError(f"unsupported dtype {npmat.dtype}") from None
+    height, width, channels = npmat.shape
+    return CMatT(
+        ctypes.c_void_p(npmat.ctypes.data),
+        CShapeT(width, height, channels),
+        dtype_id,
+    )
+
+
+def pymat_to_np(pymat: CMatT) -> np.ndarray:
+    """Copy the data referenced by ``pymat`` into a new numpy array."""
+    dtype = _PYMAT_DTYPES[pymat.dtype]
+    shape = (pymat.shape.height, pymat.shape.width, pymat.shape.channels)
+    buffer = (ctypes.c_byte * (int(np.prod(shape)) * dtype.itemsize)).from_address(
+        pymat.data_ptr
+    )
+    return np.frombuffer(buffer, dtype=dtype).reshape(shape).copy()
+
+
+def find_library() -> Path:
+    """Locate the shared library that is installed next to this package."""
+    package = sys.modules[__package__]
+    for directory in package.__path__:
+        candidate = Path(directory) / LIBRARY_NAME
+        if candidate.is_file():
+            return candidate
+    raise OSError(
+        f"{LIBRARY_NAME} not found in {list(package.__path__)}; "
+        "reinstall PyPatchMatch or build it from source with OpenCV available"
+    )
+
+
+def load_library() -> ctypes.CDLL:
+    lib = ctypes.CDLL(str(find_library()))
+
+    lib.PM_set_random_seed.argtypes = [ctypes.c_uint]
+    lib.PM_set_random_seed.restype = None
+    lib.PM_set_verbose.argtypes = [ctypes.c_int]
+    lib.PM_set_verbose.restype = None
+    lib.PM_free_pymat.argtypes = [CMatT]
+    lib.PM_free_pymat.restype = None
+
+    lib.PM_inpaint.argtypes = [CMatT, CMatT, ctypes.c_int]
+    lib.PM_inpaint2.argtypes = [CMatT, CMatT, CMatT, ctypes.c_int]
+    lib.PM_inpaint_regularity.argtypes = [
+        CMatT,
+        CMatT,
+        CMatT,
+        ctypes.c_int,
+        ctypes.c_float,
+    ]
+    lib.PM_inpaint2_regularity.argtypes = [
+        CMatT,
+        CMatT,
+        CMatT,
+        CMatT,
+        ctypes.c_int,
+        ctypes.c_float,
+    ]
+    for func in (
+        lib.PM_inpaint,
+        lib.PM_inpaint2,
+        lib.PM_inpaint_regularity,
+        lib.PM_inpaint2_regularity,
+    ):
+        func.restype = CMatT
+
+    return lib

pypatchmatch-2.0.0b2/patchmatch/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '2.0.0b2'
+__version_tuple__ = version_tuple = (2, 0, 0, 'b2')
+
+__commit_id__ = commit_id = 'gd8a13321b'

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

@@ -1,20 +1,19 @@
 #include <algorithm>
 #include <iostream>
-#include <opencv2/imgcodecs.hpp>
+#ifdef PATCHMATCH_WITH_HIGHGUI
 #include <opencv2/imgproc.hpp>
 #include <opencv2/highgui.hpp>
+#endif
 
 #include "inpaint.h"
 
 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;
@@ -22,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)
@@ -48,13 +56,13 @@ namespace
  */
 
 Inpainting::Inpainting(cv::Mat image, cv::Mat mask, const PatchDistanceMetric *metric)
-    : m_initial(image, mask), m_distance_metric(metric), m_pyramid(), m_source2target(), m_target2source()
+    : m_initial(image, mask), m_pyramid(), m_source2target(), m_target2source(), m_distance_metric(metric)
 {
     _initialize_pyramid();
 }
 
 Inpainting::Inpainting(cv::Mat image, cv::Mat mask, cv::Mat global_mask, const PatchDistanceMetric *metric)
-    : m_initial(image, mask, global_mask), m_distance_metric(metric), m_pyramid(), m_source2target(), m_target2source()
+    : m_initial(image, mask, global_mask), m_pyramid(), m_source2target(), m_target2source(), m_distance_metric(metric)
 {
     _initialize_pyramid();
 }
@@ -68,16 +76,11 @@ void Inpainting::_initialize_pyramid()
         source = source.downsample();
         m_pyramid.push_back(source);
     }
-
-    if (kDistance2Similarity.size() == 0)
-    {
-        init_kDistance2Similarity();
-    }
 }
 
 cv::Mat Inpainting::run(bool verbose, bool verbose_visualize, unsigned int random_seed)
 {
-    srand(random_seed);
+    NearestNeighborField::seed_random(random_seed);
     const int nr_levels = m_pyramid.size();
 
     MaskedImage source, target;
@@ -104,6 +107,7 @@ cv::Mat Inpainting::run(bool verbose, bool verbose_visualize, unsigned int rando
         if (verbose)
             std::cerr << "Initialization done." << std::endl;
 
+#ifdef PATCHMATCH_WITH_HIGHGUI
         if (verbose_visualize)
         {
             auto visualize_size = m_initial.size();
@@ -115,11 +119,19 @@ cv::Mat Inpainting::run(bool verbose, bool verbose_visualize, unsigned int rando
             cv::imshow("Target", target_visualize);
             cv::waitKey(0);
         }
+#else
+        (void)verbose_visualize;
+#endif
 
         target = _expectation_maximization(source, target, level, verbose);
     }
 
-    return target.image();
+    // Globally masked pixels are neither filled nor used as a source, so the pyramid
+    // leaves them black. Keep their input values instead.
+    cv::Mat result = target.image();
+    if (!m_initial.global_mask().empty())
+        m_initial.image().copyTo(result, m_initial.global_mask());
+    return result;
 }
 
 // EM-Like algorithm (see "PatchMatch" - page 6).
@@ -206,6 +218,7 @@ void Inpainting::_expectation_step(
     auto source_size = nnf.source_size();
     auto target_size = nnf.target_size();
     const int patch_size = m_distance_metric->patch_size();
+    const auto &kDistance2Similarity = distance2similarity();
 
     for (int i = 0; i < source_size.height; ++i)
     {

{PyPatchMatch-1.0.2 → pypatchmatch-2.0.0b2}/patchmatch/csrc/masked_image.cpp

@@ -150,7 +150,6 @@ void MaskedImage::compute_image_gradients()
 
     for (int i = 1; i < size.height - 1; ++i)
     {
-        const auto *ptr = m_image.ptr<unsigned char>(i, 0);
         const auto *ptry1 = m_image.ptr<unsigned char>(i + 1, 0);
         const auto *ptry2 = m_image.ptr<unsigned char>(i - 1, 0);
         const auto *ptrx1 = m_image.ptr<unsigned char>(i, 0) + 3;

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

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