PyPatchMatch 1.0.1__tar.gz → 2.0.0__tar.gz

pypatchmatch-2.0.0/CLAUDE.md

@@ -0,0 +1,155 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in
+this repository. The details of the native code, the C interface, packaging and CI are
+path-scoped rules in `.claude/rules/`, which load when a matching file is read or
+edited; read the rule before changing such a file through Bash. The sanitizer, C++
+coverage and fill-quality runs are skills in `.claude/skills/`.
+
+## Project
+
+PyPatchMatch implements PatchMatch based image inpainting (Barnes et al., SIGGRAPH 2009):
+a C++17 library on top of OpenCV core, and a thin Python package that loads it through
+`ctypes`. It is published on PyPI as `PyPatchMatch` (import name `patchmatch`) and used
+by InvokeAI. This repository (`mauwii/PyPatchMatch`) is the maintained fork of
+`invoke-ai/PyPatchMatch`, which derives from `vacancy/PyPatchMatch` and
+`younesse-cv/PatchMatch`.
+
+## Commands
+
+The project is managed with uv (`.python-version` pins 3.12 for the local venv). Building
+needs a C++17 compiler, CMake >= 3.21 and an OpenCV that `find_package(OpenCV)` finds:
+Homebrew `opencv`, `libopencv-dev`, or an installation prefix in `OpenCV_ROOT`.
+
+```sh
+uv sync                                    # .venv, editable install, compiles the library
+uv run pre-commit install
+uv run pytest                              # all tests, with the coverage gate
+uv run pytest -m "not e2e"                 # fast unit tests only
+uv run pytest -m e2e --no-cov              # end-to-end tests only
+uv run pytest tests/test_patch_match.py::test_inpaint_global_mask --no-cov
+uv run pytest -k regularity --no-cov
+uv run mypy                                # strict, also a pre-commit hook
+uv run pre-commit run --all-files          # what the CI lint job runs
+uv run ruff check --fix . && uv run ruff format .
+uv build                                   # sdist and wheel into dist/
+```
+
+- Pass `--no-cov` for any partial run: `addopts` always enables coverage, and
+  `fail_under = 95` (branch coverage, subprocesses included through
+  `patch = ["subprocess"]`) fails the run otherwise.
+- Use `uv run pytest`, not `python -m pytest`. The latter puts the repository root on
+  `sys.path`, which imports the source tree `patchmatch/` without the compiled library;
+  the symptoms are the warning `patchmatch failed to load: libpatchmatch.* not found`
+  and `RuntimeError: the patchmatch native library is not available` in every test.
+- `--cov=patchmatch` measures the source tree, so coverage only works with the editable
+  install that `uv sync` creates. With a non-editable install (`uv sync --no-editable`,
+  `uv pip install .`) it reports 0 % and the gate fails.
+- `uv sync` rebuilds the library only when a `tool.uv.cache-keys` entry changes
+  (`CMakeLists.txt`, `patchmatch/csrc/*`, `pyproject.toml`, git commit or tags). Force it
+  with `uv sync --reinstall-package pypatchmatch`.
+- CI builds the library with warnings as errors. Locally:
+  `SKBUILD_CMAKE_DEFINE=CMAKE_COMPILE_WARNING_AS_ERROR=ON uv sync --reinstall-package pypatchmatch`.
+
+Build against the same static, core-only OpenCV as the release wheels:
+
+```sh
+export OpenCV_ROOT=/tmp/opencv
+uv run --no-project python scripts/build_opencv.py   # pinned version and SHA-256
+uv sync --reinstall-package pypatchmatch
+```
+
+Other entry points:
+
+- `examples/cpp_example_run.sh` builds the library and `examples/cpp_example.cpp` with
+  CMake into `build/cpp` and runs it. It needs OpenCV `imgcodecs`, so a full OpenCV, not
+  the core-only build of the script.
+- `uv run python examples/py_example.py` (and `py_example_global_mask.py`) write
+  `examples/images/forest_recovered.bmp`, which is git-ignored.
+- `uv run python scripts/render_readme_example.py` runs `py_example.py` and renders the
+  picture at the top of the README, `examples/images/readme_example.jpg`; rerun it and
+  commit the picture after changes that affect the fills.
+- CMake options: `PATCHMATCH_BUILD_EXAMPLES` (OFF), `PATCHMATCH_FAST_MATH` (ON,
+  `-ffast-math` or `/fp:fast`), `PATCHMATCH_SANITIZE` (OFF, ASan and UBSan with
+  `float-cast-overflow`, every finding aborts; turns off fast math, which lets the
+  compiler drop checks; GCC and Clang only), `PATCHMATCH_COVERAGE` (OFF, gcov counters
+  at `-Og`; GCC and Clang only).
+
+## Architecture
+
+### Layers, in the call order of `patchmatch.inpaint`
+
+1. `patchmatch/__init__.py` re-exports the public API of `patch_match.py` and
+   `__version__` from the generated `_version.py`. `test_top_level_exports` checks that
+   every name in `patch_match.__all__` is re-exported.
+2. `patchmatch/patch_match.py` is the public API. It validates and canonicalizes the
+   inputs (`_prepare_inputs`, `_check_patch_size`, the `ijmap` and `guide_weight`
+   checks), picks the entry point (`PM_inpaint`, `PM_inpaint2` with a global mask, and
+   their `_regularity` variants) and runs it through `_call`. It loads the library at
+   import time; on `OSError` it logs a warning and sets `patchmatch_available = False`,
+   and every function then raises `RuntimeError` through `_get_lib()`.
+3. `patchmatch/_lib.py` is the ctypes layer: the `CShapeT`/`CMatT` structures, the dtype
+   table, `np_to_pymat`/`pymat_to_np`, `find_library` (looks for `libpatchmatch.so`,
+   `libpatchmatch.dylib` or `patchmatch.dll` in every directory of `patchmatch.__path__`)
+   and `load_library` (argtypes and restype of every `PM_*` function).
+4. `patchmatch/csrc/pyinterface.{h,cpp}` is the `extern "C"` API: the `PM_*` functions,
+   the conversion between `PM_mat_t` and `cv::Mat`, the global settings and the error
+   reporting.
+5. `csrc/inpaint.{h,cpp}`: `Inpainting`, the image pyramid and the EM loop.
+6. `csrc/nnf.{h,cpp}`: `NearestNeighborField` (propagation and random search) and the
+   distance metrics `PatchSSDDistanceMetric` and `RegularityGuidedPatchDistanceMetricV2`.
+7. `csrc/masked_image.{h,cpp}`: `MaskedImage`, an image with its hole mask and optional
+   global mask, down- and upsampling, gradients.
+
+The C++ headers double as the C++ API: `examples/cpp_example.cpp` uses `Inpainting` and
+`PatchSSDDistanceMetric` directly.
+
+### ctypes instead of a CPython extension
+
+The library does not use the CPython ABI, so the wheels are tagged
+`py3-none-<platform>` (`wheel.py-api = "py3"`): one wheel per platform serves all Python
+versions, and cibuildwheel only builds `cp311-*`. Keep `csrc` free of `Python.h`,
+pybind11 or nanobind. The C++ sources are excluded from the wheel (`wheel.exclude`);
+CMake installs the shared library into the package directory.
+
+## Conventions
+
+- Python >= 3.11: keep `from __future__ import annotations`. Ruff targets py311 with the
+  rules B, C4, E, F, I, RUF, SIM, UP and W, and formats at 88 columns. `patchmatch/csrc`
+  is excluded from ruff. C++ is formatted by clang-format (Microsoft style, 120 columns,
+  includes grouped as own header, `<...>`, `"..."`); naming is not checked: `m_`
+  members, `k` constants. Commit a reformat separately and add its hash to
+  `.git-blame-ignore-revs`.
+- The package ships `py.typed`; public functions are fully annotated. mypy checks
+  `patchmatch` and `tests` in strict mode (`[tool.mypy]`); the tests have to use the
+  API correctly but need no annotations of their own. A deliberately wrong argument
+  goes through a test parameter instead of a `# type: ignore`.
+- Backwards compatibility: `from patchmatch import patch_match` and
+  `patch_match.CShapeT`/`CMatT` keep working (tested).
+- Comments explain why: which crash a check prevents, why a construct is avoided.
+- No `NOSONAR` markers: change the code so that the SonarCloud rule is satisfied, and ask
+  when that seems impossible. The only exception is `nnf.cpp`: cpp:S2245 flags every
+  declaration of `std::mt19937`, which only drives the randomized search.
+- Tests check invariants instead of golden images: holes filled, all other pixels
+  unchanged, determinism with `set_random_seed`, fills that blend in with their
+  surroundings. `test_patch_match.py` and `test_e2e.py` seed through an autouse fixture.
+  Unit tests use a small synthetic image; the `e2e` tests use
+  `examples/images/forest_pruned.bmp` and mirror the workflows of the README and the
+  examples. `test_properties.py` checks the invariants on random inputs with Hypothesis
+  (in the `test` group, so the wheel tests run it too); it seeds inside the tests,
+  because Hypothesis rejects function-scoped fixtures, and has no deadline, because
+  the sanitizer and coverage builds are much slower.
+- The README documents the behavior (mask semantics, `patch_size` as a radius, the
+  fallback installation); update it together with API or installation changes.
+- Commit messages: imperative subject in sentence case without a prefix (e.g. "Reject
+  invalid patch sizes and empty regularity maps"), and a body that explains the reason,
+  with measurements where relevant. Changes go through PRs from branches such as
+  `fix/<topic>`.
+
+## Git and GitHub
+
+- `origin` is `mauwii/PyPatchMatch`, where PRs and releases go; `upstream` is
+  `invoke-ai/PyPatchMatch`. `gh` resolves the default repository to upstream, so pass
+  `-R mauwii/PyPatchMatch`.
+- Releases: creating a GitHub release with a tag like `v2.0.0` (or `v2.0.0rc2` for
+  pre-releases) builds the wheels and publishes them to PyPI.

pypatchmatch-2.0.0/CMakeLists.txt

@@ -0,0 +1,104 @@
+cmake_minimum_required(VERSION 3.21)
+project(patchmatch LANGUAGES CXX)
+
+option(PATCHMATCH_BUILD_EXAMPLES "Build the C++ example (requires OpenCV imgcodecs)" 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)
+option(PATCHMATCH_COVERAGE "Build with gcov coverage counters at -Og (GCC, Clang)" OFF)
+
+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_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)
+
+# 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 AND NOT PATCHMATCH_SANITIZE)
+  if(MSVC)
+    target_compile_options(patchmatch PRIVATE /fp:fast)
+  else()
+    target_compile_options(patchmatch PRIVATE -ffast-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_COVERAGE)
+  if(MSVC)
+    message(FATAL_ERROR "PATCHMATCH_COVERAGE needs GCC or Clang")
+  endif()
+  # atomic counters, since a test inpaints in parallel; -O0 would triple the test time
+  target_compile_options(patchmatch PRIVATE --coverage -fprofile-update=atomic -Og)
+  target_link_options(patchmatch PRIVATE --coverage)
+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 and
+# an SBOM (PEP 770), which scripts/build_opencv.py writes to <prefix>/licenses and
+# <prefix>/sboms.
+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()
+  set(PATCHMATCH_OPENCV_SBOM "${OpenCV_INSTALL_PATH}/sboms/opencv.cdx.json")
+  if(EXISTS "${PATCHMATCH_OPENCV_SBOM}")
+    install(FILES "${PATCHMATCH_OPENCV_SBOM}" DESTINATION "${SKBUILD_METADATA_DIR}/sboms")
+  else()
+    message(WARNING "No OpenCV SBOM at ${PATCHMATCH_OPENCV_SBOM}, "
+      "the wheel will not include it")
+  endif()
+endif()

pypatchmatch-2.0.0/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: PyPatchMatch
+Version: 2.0.0
+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.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+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.11
+Requires-Dist: numpy>=1.23.2
+Requires-Dist: pillow>=9.2.0
+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)
+[![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.
+
+![Birdhouses removed from a photo by patchmatch.inpaint](https://raw.githubusercontent.com/mauwii/PyPatchMatch/v2.0.0/examples/images/readme_example.jpg)
+
+From left to right: the photo, the input of
+[examples/py_example.py](https://github.com/mauwii/PyPatchMatch/blob/main/examples/py_example.py)
+with the birdhouses painted out in white, and its result.
+
+## 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`).
+
+If that build fails, PyPatchMatch is installed without the native library instead of
+blocking the installation: `patchmatch.patchmatch_available` is `False` and the
+inpainting functions raise `RuntimeError`. After installing the missing tools, reinstall
+it without the cached build:
+
+```sh
+pip install --force-reinstall --no-deps --no-cache-dir PyPatchMatch
+```
+
+## Usage
+
+Python (see
+[examples/py_example.py](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. Only the holes are filled; all other pixels keep
+their values, and the colors under the holes have no influence on the fill. 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, and their colors have no influence on
+the fill (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.
+
+`patch_size` is the radius of the compared patches, which span `2 * patch_size + 1`
+pixels in each direction. Larger patches follow larger structures but are much slower;
+the default of 15 compares 31x31 patches, the examples use 3.
+
+`patchmatch.set_random_seed(seed)` sets the seed of the randomized search and
+`patchmatch.set_verbose(True)` prints the progress of the native code to stderr.
+`patchmatch.inpaint_regularity(image, mask, ijmap)` additionally guides the search with
+a regularity map, an HxWx3 float32 array with the regularity coordinates of each pixel
+in its first two channels. Its `guide_weight` must be at least 0.
+
+C++ (see
+[examples/cpp_example.cpp](https://github.com/mauwii/PyPatchMatch/blob/main/examples/cpp_example.cpp),
+build and run it with
+[examples/cpp_example_run.sh](https://github.com/mauwii/PyPatchMatch/blob/main/examples/cpp_example_run.sh)):
+
+```cpp
+#include "inpaint.h"
+
+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.
+
+## 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
+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.
+Pull requests that change the C++ code get this comparison with their base commit in the
+summary of the workflow "Fill quality", and the HTML report as its artifact.
+
+Releases are published to PyPI by creating a GitHub release; the version is taken from
+its tag (e.g. `v2.0.0`). Every released wheel and sdist carries a build provenance
+attestation: `gh attestation verify <file> -R mauwii/PyPatchMatch`.
+
+## 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`, and a CycloneDX SBOM of OpenCV (PEP 770) in
+`sboms/opencv.cdx.json`, so that vulnerability scanners can find it.
+
+## 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.0/README.md

@@ -0,0 +1,146 @@
+# 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)
+[![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.
+
+![Birdhouses removed from a photo by patchmatch.inpaint](examples/images/readme_example.jpg)
+
+From left to right: the photo, the input of
+[examples/py_example.py](https://github.com/mauwii/PyPatchMatch/blob/main/examples/py_example.py)
+with the birdhouses painted out in white, and its result.
+
+## 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`).
+
+If that build fails, PyPatchMatch is installed without the native library instead of
+blocking the installation: `patchmatch.patchmatch_available` is `False` and the
+inpainting functions raise `RuntimeError`. After installing the missing tools, reinstall
+it without the cached build:
+
+```sh
+pip install --force-reinstall --no-deps --no-cache-dir PyPatchMatch
+```
+
+## Usage
+
+Python (see
+[examples/py_example.py](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. Only the holes are filled; all other pixels keep
+their values, and the colors under the holes have no influence on the fill. 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, and their colors have no influence on
+the fill (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.
+
+`patch_size` is the radius of the compared patches, which span `2 * patch_size + 1`
+pixels in each direction. Larger patches follow larger structures but are much slower;
+the default of 15 compares 31x31 patches, the examples use 3.
+
+`patchmatch.set_random_seed(seed)` sets the seed of the randomized search and
+`patchmatch.set_verbose(True)` prints the progress of the native code to stderr.
+`patchmatch.inpaint_regularity(image, mask, ijmap)` additionally guides the search with
+a regularity map, an HxWx3 float32 array with the regularity coordinates of each pixel
+in its first two channels. Its `guide_weight` must be at least 0.
+
+C++ (see
+[examples/cpp_example.cpp](https://github.com/mauwii/PyPatchMatch/blob/main/examples/cpp_example.cpp),
+build and run it with
+[examples/cpp_example_run.sh](https://github.com/mauwii/PyPatchMatch/blob/main/examples/cpp_example_run.sh)):
+
+```cpp
+#include "inpaint.h"
+
+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.
+
+## 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
+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.
+Pull requests that change the C++ code get this comparison with their base commit in the
+summary of the workflow "Fill quality", and the HTML report as its artifact.
+
+Releases are published to PyPI by creating a GitHub release; the version is taken from
+its tag (e.g. `v2.0.0`). Every released wheel and sdist carries a build provenance
+attestation: `gh attestation verify <file> -R mauwii/PyPatchMatch`.
+
+## 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`, and a CycloneDX SBOM of OpenCV (PEP 770) in
+`sboms/opencv.cdx.json`, so that vulnerability scanners can find it.
+
+## 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.0/SECURITY.md

@@ -0,0 +1,20 @@
+# Security Policy
+
+## Supported Versions
+
+Security fixes are released as a new version of PyPatchMatch on PyPI. Only the latest
+release is supported; older versions are not updated.
+
+## Reporting a Vulnerability
+
+Please report vulnerabilities privately through GitHub's
+[vulnerability reporting](https://github.com/mauwii/PyPatchMatch/security/advisories/new),
+not in a public issue.
+
+## OpenCV
+
+The wheels on PyPI contain a statically linked, core-only build of OpenCV; its version
+is listed in the CycloneDX SBOM in `sboms/opencv.cdx.json` of each wheel's
+`.dist-info`. A vulnerability in OpenCV core is fixed by a new PyPatchMatch release
+with an updated OpenCV. Installations built from the source distribution link the
+OpenCV of the system and get its fixes from there.

pypatchmatch-2.0.0/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",
+]