PyPatchMatch 2.2.0rc2__py3-none-win_arm64.whl

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

patchmatch/_lib.py

@@ -0,0 +1,123 @@
+"""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.float32)]
+_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
+    # Without a wheel for the platform, a failed build from the sdist installs the
+    # package without the library, see the overrides in pyproject.toml.
+    raise OSError(
+        f"{LIBRARY_NAME} not found in {list(package.__path__)}. Without a wheel for "
+        "this platform, PyPatchMatch is built from source, which needs a C++ "
+        "compiler, CMake and OpenCV. Install them and reinstall it without the "
+        "cache: pip install --force-reinstall --no-deps --no-cache-dir pypatchmatch"
+    )
+
+
+def load_library(path: Path | None = None) -> ctypes.CDLL:
+    """Load the installed library, or the build at ``path``."""
+    lib = ctypes.CDLL(str(path or 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_last_error.argtypes = []
+    lib.PM_last_error.restype = ctypes.c_char_p
+
+    lib.PM_inpaint.argtypes = [CMatT, CMatT, ctypes.c_int]
+    lib.PM_inpaint2.argtypes = [CMatT, CMatT, CMatT, ctypes.c_int]
+    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

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.2.0rc2'
+__version_tuple__ = version_tuple = (2, 2, 0, 'rc2')
+
+__commit_id__ = commit_id = None

patchmatch/patch_match.py

@@ -0,0 +1,263 @@
+# File   : patch_match.py
+# Author : Jiayuan Mao
+# Email  : maojiayuan@gmail.com
+# Date   : 01/09/2020
+#
+# Distributed under terms of the MIT license.
+#
+# Additional modifications by Kyle Schouviller and Matthias Wild
+
+"""PatchMatch based inpainting.
+
+PatchMatch: A Randomized Correspondence Algorithm for Structural Image Editing.
+C. Barnes, E. Shechtman, A. Finkelstein and Dan B. Goldman. SIGGRAPH 2009.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import logging
+import operator
+from collections.abc import Callable
+from typing import SupportsIndex, TypeAlias
+
+import numpy as np
+from PIL import Image
+
+# CMatT and CShapeT are re-exported for backwards compatibility
+from ._lib import CMatT as CMatT
+from ._lib import CShapeT as CShapeT
+from ._lib import load_library, np_to_pymat, pymat_to_np
+
+__all__ = [
+    "inpaint",
+    "inpaint_regularity",
+    "patchmatch_available",
+    "set_random_seed",
+    "set_verbose",
+]
+
+logger = logging.getLogger(__name__)
+
+ImageLike: TypeAlias = np.ndarray | Image.Image
+
+try:
+    _lib: ctypes.CDLL | None = load_library()
+except (OSError, AttributeError) as e:
+    # AttributeError: a library without the PM_* functions, e.g. one that 1.x
+    # compiled into the package directory and that pip does not remove on upgrade
+    _lib = None
+    logger.warning("patchmatch failed to load: %s", e)
+
+# True if the native library was loaded successfully.
+patchmatch_available = _lib is not None
+
+# The native code computes 2 * patch_size + 1 as a C int.
+_MAX_PATCH_SIZE = (2**31 - 2) // 2
+
+# The native code takes a C float, which turns larger weights into infinity.
+_MAX_GUIDE_WEIGHT = float(np.finfo(np.float32).max)
+
+
+def _get_lib() -> ctypes.CDLL:
+    if _lib is None:
+        raise RuntimeError("the patchmatch native library is not available")
+    return _lib
+
+
+def set_random_seed(seed: int) -> None:
+    """Set the seed of the randomized search of all following inpaintings.
+
+    Every inpainting starts from this seed, so equal inputs give equal results. The
+    native code keeps it as a 32-bit unsigned int, so ``seed`` is taken modulo
+    ``2**32``: ``2**32`` behaves like 0 and -1 like ``2**32 - 1``.
+    """
+    _get_lib().PM_set_random_seed(ctypes.c_uint(seed))
+
+
+def set_verbose(verbose: bool) -> None:
+    """Print the progress of all following inpaintings to stderr if ``verbose``."""
+    _get_lib().PM_set_verbose(ctypes.c_int(verbose))
+
+
+def inpaint(
+    image: ImageLike,
+    mask: ImageLike | None = None,
+    *,
+    global_mask: ImageLike | None = None,
+    patch_size: SupportsIndex = 15,
+) -> np.ndarray:
+    """Fill the masked regions of ``image`` using PatchMatch.
+
+    Args:
+        image: 3-channel uint8 RGB/BGR image.
+        mask: 1-channel uint8 or bool mask of the hole(s) to fill (non-zero = hole),
+            with the same height and width as ``image``. If ``None``, all pure
+            white pixels (255, 255, 255) are treated as holes.
+        global_mask: mask like ``mask`` of pixels that are neither filled nor used as
+            a source; they keep their values from ``image``.
+        patch_size: radius of the compared patches, which span
+            ``(2 * patch_size + 1) ** 2`` pixels. Larger patches follow larger
+            structures but are much slower; the examples use 3.
+
+    Returns:
+        The repaired image, with the same shape as ``image``. Only the holes are
+        filled; all other pixels keep their values from ``image``.
+    """
+    lib = _get_lib()
+    patch_size = _check_patch_size(patch_size)
+    image, mask, global_mask = _prepare_inputs(image, mask, global_mask)
+    if not _has_holes(mask, global_mask):
+        return image.copy()
+
+    if global_mask is None:
+        return _call(lib.PM_inpaint, image, mask, ctypes.c_int(patch_size))
+    return _call(lib.PM_inpaint2, image, mask, global_mask, ctypes.c_int(patch_size))
+
+
+def inpaint_regularity(
+    image: ImageLike,
+    mask: ImageLike | None,
+    ijmap: np.ndarray,
+    *,
+    global_mask: ImageLike | None = None,
+    patch_size: SupportsIndex = 15,
+    guide_weight: float = 0.25,
+) -> np.ndarray:
+    """Like :func:`inpaint`, additionally guided by a regularity map.
+
+    Args:
+        ijmap: HxWx3 float32 array of finite values with the regularity coordinates
+            of each pixel in the first two channels; the third channel is unused.
+            A map of a different size is scaled to the image.
+        guide_weight: non-negative weight of the regularity term relative to the
+            patch distance.
+    """
+    lib = _get_lib()
+    patch_size = _check_patch_size(patch_size)
+    image, mask, global_mask = _prepare_inputs(image, mask, global_mask)
+
+    if not (
+        isinstance(ijmap, np.ndarray)
+        and ijmap.ndim == 3
+        and ijmap.shape[2] == 3
+        and ijmap.dtype == np.float32
+        and ijmap.size > 0
+    ):
+        raise ValueError("ijmap must be a non-empty HxWx3 float32 array")
+    # NaN and infinity turn into out-of-range patch distances in the native code
+    if not np.isfinite(ijmap).all():
+        raise ValueError("ijmap must only contain finite values")
+    ijmap = np.ascontiguousarray(ijmap)
+
+    # the native code divides by 1 + guide_weight and indexes a table with the result;
+    # the comparison also rejects NaN
+    guide_weight = float(guide_weight)
+    if not 0 <= guide_weight <= _MAX_GUIDE_WEIGHT:
+        raise ValueError(
+            f"guide_weight must be between 0 and {_MAX_GUIDE_WEIGHT:g}, "
+            f"got {guide_weight}"
+        )
+
+    if not _has_holes(mask, global_mask):
+        return image.copy()
+
+    args = (ijmap, ctypes.c_int(patch_size), ctypes.c_float(guide_weight))
+    if global_mask is None:
+        return _call(lib.PM_inpaint_regularity, image, mask, *args)
+    return _call(lib.PM_inpaint2_regularity, image, mask, global_mask, *args)
+
+
+def _check_patch_size(patch_size: SupportsIndex) -> int:
+    try:
+        patch_size = operator.index(patch_size)
+    except TypeError:
+        raise TypeError(
+            f"patch_size must be an integer, got {type(patch_size).__name__}"
+        ) from None
+    # The native code crashes for 0 and never terminates for negative sizes. ctypes
+    # silently wraps larger values into the C int range, e.g. 2**31 to a negative size.
+    if not 1 <= patch_size <= _MAX_PATCH_SIZE:
+        raise ValueError(
+            f"patch_size must be between 1 and {_MAX_PATCH_SIZE}, got {patch_size}"
+        )
+    return patch_size
+
+
+def _prepare_inputs(
+    image: ImageLike,
+    mask: ImageLike | None,
+    global_mask: ImageLike | None,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray | None]:
+    """Validate the inputs and convert them to contiguous arrays."""
+    image = _canonize_image_array(image)
+    mask = _default_mask(image) if mask is None else _canonize_mask_array(mask)
+    if global_mask is not None:
+        global_mask = _canonize_mask_array(global_mask)
+
+    # the native code indexes the masks with the image coordinates
+    for name, m in (("mask", mask), ("global_mask", global_mask)):
+        if m is not None and m.shape[:2] != image.shape[:2]:
+            raise ValueError(
+                f"{name} must have the same height and width as the image, "
+                f"got {m.shape[:2]} for an image of {image.shape[:2]}"
+            )
+    return image, mask, global_mask
+
+
+def _has_holes(mask: np.ndarray, global_mask: np.ndarray | None) -> bool:
+    """Whether a hole lies outside the global mask.
+
+    Otherwise the result equals the input, but the native code still runs every
+    level of the pyramid. This also covers empty images, which OpenCV 4.6 would
+    return with the shape (0, 0, 1).
+    """
+    holes = mask != 0
+    if global_mask is not None:
+        holes &= global_mask == 0
+    return bool(holes.any())
+
+
+def _call(func: Callable[..., CMatT], *args: object) -> np.ndarray:
+    """Call ``func`` with arrays converted to pymats and copy the result."""
+    lib = _get_lib()
+    c_args = [np_to_pymat(a) if isinstance(a, np.ndarray) else a for a in args]
+    ret = func(*c_args)
+    if not ret.data_ptr:
+        # the error message is kept per thread, like the call itself
+        message = lib.PM_last_error().decode(errors="replace").strip()
+        raise RuntimeError(f"patchmatch failed: {message}")
+    try:
+        return pymat_to_np(ret)
+    finally:
+        lib.PM_free_pymat(ret)
+
+
+def _canonize_image_array(image: ImageLike) -> np.ndarray:
+    image = np.asarray(image)
+    if not (image.ndim == 3 and image.shape[2] == 3 and image.dtype == np.uint8):
+        raise ValueError(
+            "image must be an HxWx3 uint8 array, "
+            f"got shape {image.shape} and dtype {image.dtype}"
+        )
+    return np.ascontiguousarray(image)
+
+
+def _canonize_mask_array(mask: ImageLike) -> np.ndarray:
+    mask = np.asarray(mask)
+    if mask.dtype == np.bool_:  # e.g. boolean arrays or PIL images in mode "1"
+        mask = mask.astype(np.uint8)
+    if mask.ndim == 2:
+        mask = mask[..., np.newaxis]
+    if not (mask.ndim == 3 and mask.shape[2] == 1 and mask.dtype == np.uint8):
+        raise ValueError(
+            "mask must be an HxW or HxWx1 uint8 array, "
+            f"got shape {mask.shape} and dtype {mask.dtype}"
+        )
+    return np.ascontiguousarray(mask)
+
+
+def _default_mask(image: np.ndarray) -> np.ndarray:
+    """Treat all pure white pixels as holes."""
+    mask: np.ndarray = (image == 255).all(axis=2, keepdims=True)
+    return mask.astype(np.uint8)

pypatchmatch-2.2.0rc2.dist-info/METADATA

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: PyPatchMatch
+Version: 2.2.0rc2
+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
+
+[![PyPI](https://img.shields.io/pypi/v/PyPatchMatch)](https://pypi.org/project/PyPatchMatch/)
+[![Python](https://img.shields.io/pypi/pyversions/PyPatchMatch)](https://pypi.org/project/PyPatchMatch/)
+[![Downloads](https://img.shields.io/pepy/dt/pypatchmatch)](https://pepy.tech/projects/pypatchmatch)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blueviolet.svg)](https://github.com/mauwii/PyPatchMatch/blob/main/LICENSE)
+
+[![Tests](https://img.shields.io/github/actions/workflow/status/mauwii/PyPatchMatch/ci.yml?branch=main&label=tests)](https://github.com/mauwii/PyPatchMatch/actions/workflows/ci.yml?query=branch%3Amain)
+[![Coverage](https://img.shields.io/sonar/coverage/mauwii_PyPatchMatch?server=https%3A%2F%2Fsonarcloud.io)](https://sonarcloud.io/component_measures?id=mauwii_PyPatchMatch&metric=coverage)
+[![Quality Gate](https://img.shields.io/sonar/quality_gate/mauwii_PyPatchMatch?server=https%3A%2F%2Fsonarcloud.io)](https://sonarcloud.io/summary/new_code?id=mauwii_PyPatchMatch)
+
+[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+[![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)
+[![ponytail](https://img.shields.io/badge/over--engineering-ponytail_audited-111111)](https://github.com/DietrichGebert/ponytail)
+
+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. This repository continues
+[vacancy/PyPatchMatch](https://github.com/vacancy/PyPatchMatch) by Jiayuan Mao, through
+the forks [lkwq007/PyPatchMatch](https://github.com/lkwq007/PyPatchMatch) and
+[invoke-ai/PyPatchMatch](https://github.com/invoke-ai/PyPatchMatch).
+
+![Birdhouses removed from a photo by patchmatch.inpaint](https://raw.githubusercontent.com/mauwii/PyPatchMatch/v2.2.0rc2/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 and ARM64) ship the compiled library with a statically linked OpenCV, so no
+compiler or OpenCV installation is needed. On other platforms, e.g. Alpine Linux, 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. Below 5, the coarse levels
+that lay out the fill are also tried with a radius of 5, which is kept where it fits
+the surroundings better, so that repeating patterns continue across larger holes. Above
+7, coarse levels narrower than six patches use the largest radius that fits, but at
+least 7: larger patches found no sources there and left the fill flat.
+
+`patchmatch.set_random_seed(seed)` sets the seed of the randomized search, modulo
+`2**32`, 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 between 0 and the
+largest float32, about 3.4e38.
+
+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
+uv run --group gui gui/app.py  # draw masks in the browser, http://127.0.0.1:7860
+```
+
+The GUI tries new images quickly, without writing a script for each one, e.g. to pick
+new examples or to verify edge cases: load an image, paint the holes (every painted
+pixel is one) and compare the original with the fill. Its test runs with
+`uv run --group gui pytest gui --no-cov`.
+
+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.2.0rc2.dist-info/RECORD

@@ -0,0 +1,16 @@
+patchmatch/__init__.py,sha256=Xg_AyDjCY9obrk95tzu6h0ox1fttEczi_OKu3ycsSvM,345
+patchmatch/_lib.py,sha256=IpCdxc_mG2rT8RzPBTMcZgWV_JSkfwFa_JL8o6F-qls,3836
+patchmatch/_version.py,sha256=4gRpHk6EKJHIovSB1EqnjgsNLMsqQ7EFFDDUPxPRz-A,554
+patchmatch/patch_match.py,sha256=TlmBMxgqk5vdepAoZgduy2axJJBHHYLFuMENc3DnIv4,9424
+patchmatch/patchmatch.dll,sha256=mkA3BrRO6x0g9VemPX9Nk8NFInWunLTNDRIIoDzrqvU,1342464
+patchmatch/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypatchmatch-2.2.0rc2.dist-info/METADATA,sha256=JEOUhVW09izw50vsQTly3w4fJcCC-x1DwaU-0aJNSyc,10165
+pypatchmatch-2.2.0rc2.dist-info/WHEEL,sha256=D69HPxC3SlbabnD-f_ROoJhjrQemtxP7K3VXxdgu2k4,102
+pypatchmatch-2.2.0rc2.dist-info/licenses/LICENSE,sha256=6VGSBzoFC-2RWaUpfSom3IlBW3AZfOwDuZrVzOmfN_E,1101
+pypatchmatch-2.2.0rc2.dist-info/licenses/opencv/dlpack-LICENSE,sha256=Po9rw5J2pYbWDIxars4v-YkmIYHPKz0qEo21j5epMAw,11345
+pypatchmatch-2.2.0rc2.dist-info/licenses/opencv/flatbuffers-LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+pypatchmatch-2.2.0rc2.dist-info/licenses/opencv/opencv-LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+pypatchmatch-2.2.0rc2.dist-info/licenses/opencv/SoftFloat-COPYING.txt,sha256=DFsINlE22lJjnXd_Hr_AOYiwFp2AZVyQxZ8bP6PlJqI,1732
+pypatchmatch-2.2.0rc2.dist-info/licenses/opencv/zlib-LICENSE,sha256=4y_04A2dlJMFN2NSkdo55-YScDM0v2_ejH8Whv6KRaI,1002
+pypatchmatch-2.2.0rc2.dist-info/sboms/opencv.cdx.json,sha256=ATex-BysD8SgsmzwbF8T3jwHedHA_RBYyqgJlC-Amew,866
+pypatchmatch-2.2.0rc2.dist-info/RECORD,,

pypatchmatch-2.2.0rc2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 1.1.1
+Root-Is-Purelib: false
+Tag: py3-none-win_arm64
+

pypatchmatch-2.2.0rc2.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2023 Matthias Wild
+Copyright (c) 2020 Jiayuan Mao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.