PyPatchMatch 2.2.0b3__tar.gz → 2.2.0rc2__tar.gz

{pypatchmatch-2.2.0b3 → pypatchmatch-2.2.0rc2}/CLAUDE.md

@@ -102,8 +102,10 @@ CMake installs the shared library into the package directory.
   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
+  `examples`, `patchmatch`, `scripts` and `tests` in strict mode (`[tool.mypy]`); the
+  tests have to use the API correctly but need no annotations of their own. Only the
+  examples annotate their locals and pass arguments by keyword, for readers who copy
+  them. 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).
@@ -134,4 +136,6 @@ CMake installs the shared library into the package directory.
   `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.
+  pre-releases) builds the wheels and publishes them to PyPI. The workflow `Fill
+  quality` compares the release with the last stable one; read its summary before
+  approving the job `publish`.

{pypatchmatch-2.2.0b3 → pypatchmatch-2.2.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPatchMatch
-Version: 2.2.0b3
+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>
@@ -30,13 +30,18 @@ Description-Content-Type: text/markdown
 
 # PatchMatch based Inpainting
 
-[![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)
+[![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)
-[![caveman](https://img.shields.io/badge/agent-caveman-F0A63C)](https://github.com/JuliusBrussee/caveman)
 
 This library implements the PatchMatch based inpainting algorithm. It provides both C++
 and Python interfaces. This implementation is heavily based on the implementation by
@@ -46,7 +51,7 @@ with some bug fixes, and updates. This repository continues
 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.0b3/examples/images/readme_example.jpg)
+![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)
@@ -59,9 +64,9 @@ 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
+(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

{pypatchmatch-2.2.0b3 → pypatchmatch-2.2.0rc2}/README.md

@@ -1,12 +1,17 @@
 # PatchMatch based Inpainting
 
-[![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)
+[![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)
-[![caveman](https://img.shields.io/badge/agent-caveman-F0A63C)](https://github.com/JuliusBrussee/caveman)
 
 This library implements the PatchMatch based inpainting algorithm. It provides both C++
 and Python interfaces. This implementation is heavily based on the implementation by
@@ -29,9 +34,9 @@ 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
+(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

{pypatchmatch-2.2.0b3 → pypatchmatch-2.2.0rc2}/patchmatch/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.2.0b3'
-__version_tuple__ = version_tuple = (2, 2, 0, 'b3')
+__version__ = version = '2.2.0rc2'
+__version_tuple__ = version_tuple = (2, 2, 0, 'rc2')
 
-__commit_id__ = commit_id = 'gc0f3bbfe6'
+__commit_id__ = commit_id = 'gd6affc5f5'

{pypatchmatch-2.2.0b3 → pypatchmatch-2.2.0rc2}/patchmatch/csrc/inpaint.cpp

@@ -369,18 +369,15 @@ namespace
 
     // Replaces the vote of the pixel if the new one weighs more. It is stored like the
     // sums of _weighted_copy, so the maximization step divides it by its weight.
-    inline void _best_copy(const MaskedImage &source, int ys, int xs, cv::Mat &target, int yt, int xt, double weight)
+    inline void _best_copy(
+        const unsigned char *color, const cv::Vec3d &shift, cv::Mat &target, int yt, int xt, double weight)
     {
-        if (source.is_masked(ys, xs))
-            return;
-
-        auto source_ptr = source.get_image(ys, xs);
         auto target_ptr = target.ptr<double>(yt, xt);
         if (weight <= target_ptr[3])
             return;
 
         for (int c = 0; c < 3; ++c)
-            target_ptr[c] = static_cast<double>(source_ptr[c]) * weight;
+            target_ptr[c] = (static_cast<double>(color[c]) + shift[c]) * weight;
         target_ptr[3] = weight;
     }
 
@@ -451,6 +448,7 @@ namespace
             const int xp = m_nnf->at(i, j, 1);
             if (m_holes && !votes_for_hole(m_source2target ? yp : i, m_source2target ? xp : j, patch_size))
                 return;
+            const cv::Vec3d shift = m_holes ? color_shift(i, j, yp, xp, patch_size) : cv::Vec3d();
             for (int di = -patch_size; di <= patch_size; ++di)
             {
                 for (int dj = -patch_size; dj <= patch_size; ++dj)
@@ -467,12 +465,47 @@ namespace
                         continue;
                     // Near ties go to the patch centered closest, not the first cast, which made blocks.
                     const double offset2 = static_cast<double>(di) * di + static_cast<double>(dj) * dj;
-                    cast_pair(ys, xs, yt, xt, weight, weight * (1 - 1e-5 * offset2));
+                    cast_pair(ys, xs, yt, xt, weight, weight * (1 - 1e-5 * offset2), shift);
                 }
             }
         }
 
     private:
+        // The mean color difference of the voted image to the voting source over the pixels known in both patches.
+        // The votes of the finest levels add it: their sources lie elsewhere in the image, and with their colors
+        // the fill of a vignetted photo came out lighter than the colors the coarser levels had laid out.
+        cv::Vec3d color_shift(int i, int j, int yp, int xp, int patch_size) const
+        {
+            const MaskedImage &source = m_nnf->source();
+            const MaskedImage &target = m_nnf->target();
+            cv::Vec3d sum;
+            int count = 0;
+            for (int di = -patch_size; di <= patch_size; ++di)
+            {
+                for (int dj = -patch_size; dj <= patch_size; ++dj)
+                {
+                    const int ys = i + di;
+                    const int xs = j + dj;
+                    const int yt = yp + di;
+                    const int xt = xp + dj;
+                    if (ys < 0 || ys >= m_source_size.height || xs < 0 || xs >= m_source_size.width || yt < 0 ||
+                        yt >= m_target_size.height || xt < 0 || xt >= m_target_size.width)
+                        continue;
+                    if (!is_known(source, ys, xs) || !is_known(target, yt, xt))
+                        continue;
+                    const auto *s = source.get_image(ys, xs);
+                    const auto *t = target.get_image(yt, xt);
+                    for (int c = 0; c < 3; ++c)
+                        sum[c] += s[c] - t[c];
+                    ++count;
+                }
+            }
+            if (count == 0)
+                return {};
+            // The voted image is the source of the coherence field and the target of the completeness field.
+            return sum * ((m_source2target ? -1.0 : 1.0) / count);
+        }
+
         // Whether the patch around (y, x) of the voted image, scaled like the votes, has a hole.
         bool votes_for_hole(int y, int x, int patch_size) const
         {
@@ -482,7 +515,7 @@ namespace
                 scale * (std::int64_t{y} + patch_size + 1) - 1, scale * (std::int64_t{x} + patch_size + 1) - 1);
         }
 
-        void cast_pair(int ys, int xs, int yt, int xt, double weight, double best_weight) const
+        void cast_pair(int ys, int xs, int yt, int xt, double weight, double best_weight, const cv::Vec3d &shift) const
         {
             if (!m_source2target)
             {
@@ -491,27 +524,30 @@ namespace
             }
             if (!m_upscaled)
             {
-                copy(ys, xs, yt, xt, weight, best_weight);
+                copy(ys, xs, yt, xt, weight, best_weight, shift);
                 return;
             }
             for (int uy = 0; uy < 2; ++uy)
                 for (int ux = 0; ux < 2; ++ux)
-                    copy(2 * ys + uy, 2 * xs + ux, 2 * yt + uy, 2 * xt + ux, weight, best_weight);
+                    copy(2 * ys + uy, 2 * xs + ux, 2 * yt + uy, 2 * xt + ux, weight, best_weight, shift);
         }
 
-        void copy(int ys, int xs, int yt, int xt, double weight, double best_weight) const
+        void copy(int ys, int xs, int yt, int xt, double weight, double best_weight, const cv::Vec3d &shift) const
         {
             if (m_best_only)
-                _best_copy(*m_source, ys, xs, *m_vote, yt, xt, best_weight);
+            {
+                if (!m_source->is_masked(ys, xs))
+                    _best_copy(m_source->get_image(ys, xs), shift, *m_vote, yt, xt, best_weight);
+            }
             else if (m_split)
-                split_copy(ys, xs, yt, xt, weight, best_weight);
+                split_copy(ys, xs, yt, xt, weight, best_weight, shift);
             else
                 _weighted_copy(*m_source, ys, xs, *m_vote, yt, xt, weight);
         }
 
-        // Adds the low frequencies and the texture of the source pixel to the sums, and keeps the rest if the
-        // vote weighs most.
-        void split_copy(int ys, int xs, int yt, int xt, double weight, double best_weight) const
+        // Adds the shifted low frequencies and the texture of the source pixel to the sums, and keeps the rest if
+        // the vote weighs most.
+        void split_copy(int ys, int xs, int yt, int xt, double weight, double best_weight, const cv::Vec3d &shift) const
         {
             if (!is_known(*m_source, ys, xs))
                 return;
@@ -520,7 +556,7 @@ namespace
             const auto *low = m_low.ptr<unsigned char>(ys, xs);
             auto *vote = m_vote->ptr<double>(yt, xt);
             for (int c = 0; c < 3; ++c)
-                vote[c] += low[c] * weight;
+                vote[c] += (low[c] + shift[c]) * weight;
             vote[3] += weight;
             vote[8] += m_source->texture().at<unsigned char>(ys, xs) * weight;
             if (best_weight <= vote[7])

{pypatchmatch-2.2.0b3 → pypatchmatch-2.2.0rc2}/pyproject.toml

@@ -60,6 +60,7 @@ metadata.readme.provider = "scikit_build_core.metadata.fancy_pypi_readme"
 # The release wheels are built from the sdist, so it has to contain the tests
 # and their input images; _version.py is generated and therefore git-ignored.
 sdist.include = [
+    "examples/images/camera_aged.png",
     "examples/images/camera_damaged.png",
     "examples/images/camera_damaged_mask.png",
     "examples/images/chelsea.png",
@@ -119,6 +120,8 @@ environment = { OpenCV_ROOT = "/tmp/opencv", MACOSX_DEPLOYMENT_TARGET = "11.0" }
 environment = { OpenCV_ROOT = "C:/opencv" }
 
 [tool.uv]
+# the cooldown of dependabot.yml for uv lock --upgrade
+exclude-newer = "7 days"
 # Rebuild the package whenever the native sources or the git version change.
 cache-keys = [
     { file = "CMakeLists.txt" },
@@ -130,7 +133,6 @@ cache-keys = [
 [tool.ruff]
 extend-exclude = ["patchmatch/csrc"]
 line-length = 88
-target-version = "py311"
 
 [tool.ruff.lint]
 select = ["B", "C4", "E", "F", "I", "RUF", "SIM", "UP", "W"]
@@ -143,7 +145,7 @@ patch = ["subprocess"]
 fail_under = 95
 
 [tool.mypy]
-files = ["patchmatch", "tests"]
+files = ["examples", "patchmatch", "scripts", "tests"]
 strict = true
 
 [[tool.mypy.overrides]]
@@ -162,6 +164,7 @@ warn_return_any = false
 addopts = ["--cov-branch", "--cov-report=term:skip-covered", "--cov=patchmatch"]
 # shows which test hangs before the job timeout kills the run
 faulthandler_timeout = 300
+filterwarnings = ["error"]
 markers = ["e2e: end-to-end tests of the user workflows (deselect with -m 'not e2e')"]
 minversion = "9.0"
 python_files = ["test_*.py"]

{pypatchmatch-2.2.0b3 → pypatchmatch-2.2.0rc2}/scripts/evaluate_inpainting.py

@@ -19,6 +19,9 @@ Usage:
     uv run python scripts/evaluate_inpainting.py --baseline main/libpatchmatch.dylib
     uv run python scripts/evaluate_inpainting.py --patch-size 15 --seeds 1 --cases brick
 
+The inpaintings run in parallel processes, one per CPU unless --jobs says otherwise.
+They slow each other down, so time a speed-up with --jobs 1.
+
 --markdown prints the table as Markdown and moves the plain one to stderr; the CI
 workflow "Fill quality" redirects it to the job summary.
 
@@ -39,6 +42,10 @@ Columns, means over the seeds:
     edges   difference of the gradient directions from the original, in histograms
             weighted by magnitude per 32x32 cell of the holes; lowest for the right
             texture, also when shifted, highest for a flat fill
+    variety difference of the 8x8 patches of the holes, without their mean color, to
+            the closest one that does not overlap them, relative to the original;
+            lower where the fill repeats its sources or blurs (the tiles of
+            grass-large: about 0.25), higher for fragments
     fills   with --baseline: whether the fills of all seeds are byte-identical to the
             baseline's, as they have to be after a change that only makes it faster
 """
@@ -47,18 +54,20 @@ from __future__ import annotations
 
 import argparse
 import base64
-import ctypes
+import functools
 import hashlib
 import html
 import io
 import sys
 import time
 from collections.abc import Iterator
+from concurrent.futures import Future, ProcessPoolExecutor
 from datetime import datetime
 from pathlib import Path
 from typing import NamedTuple, TextIO
 
 import numpy as np
+from numpy.lib.stride_tricks import sliding_window_view
 from PIL import Image
 
 import patchmatch
@@ -77,7 +86,7 @@ HOLES = {
     "chelsea": (52, 215, 24, 40),
     "pattern": (320, 320, 40, 40),
 }
-COLUMNS = ("seam", "detail", "error", "edges")
+COLUMNS = ("seam", "detail", "error", "edges", "variety")
 
 
 class Case(NamedTuple):
@@ -100,12 +109,12 @@ def load(path: Path) -> np.ndarray:
 
 
 def white(image: np.ndarray) -> np.ndarray:
-    return (image == 255).all(axis=2)
+    return np.all(image == 255, axis=2)
 
 
 def ellipse(shape: tuple[int, ...], cy: int, cx: int, ry: int, rx: int) -> np.ndarray:
     yy, xx = np.mgrid[: shape[0], : shape[1]]
-    return ((yy - cy) / ry) ** 2 + ((xx - cx) / rx) ** 2 < 1
+    return np.asarray(((yy - cy) / ry) ** 2 + ((xx - cx) / rx) ** 2 < 1)
 
 
 def cut(
@@ -205,6 +214,36 @@ def edge_error(image: np.ndarray, truth: np.ndarray, holes: np.ndarray) -> float
     return float(np.abs(histograms(image) - histograms(truth)).sum() / len(ys))
 
 
+PATCH = 8
+
+
+def patches(image: np.ndarray, mask: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """The PATCHxPATCH patches inside ``mask`` on a grid, flattened, and their corners."""
+    grid = (slice(None, None, PATCH // 2),) * 2
+    windows = sliding_window_view(image, (PATCH, PATCH), axis=(0, 1))[grid]
+    inside = sliding_window_view(mask, (PATCH, PATCH))[grid].all(axis=(2, 3))
+    flat = windows[inside].reshape(int(inside.sum()), 3, -1).astype(np.float32)
+    # without their mean color, which the votes shift for repeated sources too
+    flat -= flat.mean(axis=2, keepdims=True)
+    return flat.reshape(len(flat), -1), np.argwhere(inside) * (PATCH // 2)
+
+
+def variety(image: np.ndarray, truth: np.ndarray, holes: np.ndarray) -> float:
+    def mean(array: np.ndarray) -> float:
+        """Mean distance of the patches to the closest one that does not overlap them."""
+        found, corners = patches(array, holes)
+        norms = (found**2).sum(axis=1)
+        closest = []
+        for start in range(0, len(found), 512):  # bounds the memory of the distances
+            chunk, where = found[start : start + 512], corners[start : start + 512]
+            distances = norms[start : start + 512, None] + norms - 2 * chunk @ found.T
+            distances[np.abs(where[:, None] - corners).max(axis=2) < PATCH] = np.inf
+            closest.append(distances.min(axis=1))
+        return float(np.sqrt(np.maximum(np.concatenate(closest), 0)).mean())
+
+    return mean(image) / mean(truth)
+
+
 def measure(
     result: np.ndarray, holes: np.ndarray, truth: np.ndarray | None = None
 ) -> dict[str, float]:
@@ -226,26 +265,39 @@ def measure(
     if truth is not None:
         values["error"] = coarse_error(result, truth, holes)
         values["edges"] = edge_error(result, truth, holes)
+        # holes thinner than a patch, such as scratches, have none to compare
+        if sliding_window_view(holes, (PATCH, PATCH)).all(axis=(2, 3)).any():
+            values["variety"] = variety(result, truth, holes)
     return values
 
 
-def evaluate(library: ctypes.CDLL, case: Case, patch_size: int, seeds: int) -> Result:
-    patch_match._lib = library
-    mask = case.holes.astype(np.uint8)
-    rows, fills = [], []
+Seed = tuple[np.ndarray, dict[str, float], float]  # fill, measures, seconds
+
+library = functools.cache(_lib.load_library)
+
+
+def fill_seed(path: str, case: Case, patch_size: int, seed: int) -> Seed:
+    """One inpainting, in a worker process."""
+    # processes, not threads: the seed and patch_match._lib are global
+    patch_match._lib = library(Path(path))
+    patchmatch.set_random_seed(seed)
     start = time.perf_counter()
-    for seed in range(seeds):
-        patchmatch.set_random_seed(seed)
-        fills.append(
-            patchmatch.inpaint(
-                case.image, mask, global_mask=case.global_mask, patch_size=patch_size
-            )
-        )
-        rows.append(measure(fills[-1], case.holes, case.truth))
-    seconds = (time.perf_counter() - start) / seeds
+    fill = patchmatch.inpaint(
+        case.image,
+        case.holes.astype(np.uint8),
+        global_mask=case.global_mask,
+        patch_size=patch_size,
+    )
+    seconds = time.perf_counter() - start
+    return fill, measure(fill, case.holes, case.truth), seconds
+
+
+def evaluate(jobs: list[Future[Seed]]) -> Result:
+    """The result of one case and library from the jobs of all seeds, in order."""
+    fills, rows, seconds = zip(*(job.result() for job in jobs), strict=True)
     values = {key: float(np.mean([row[key] for row in rows])) for key in rows[0]}
     digest = hashlib.sha256(b"".join(fill.tobytes() for fill in fills)).hexdigest()
-    return Result(values, seconds, fills[0], digest)
+    return Result(values, float(np.mean(seconds)), fills[0], digest)
 
 
 def identical(results: list[Result]) -> str:
@@ -382,7 +434,7 @@ def verdict(key: str, old: float, new: float) -> str:
     """CSS class of ``new`` compared with ``old``: better, worse or none."""
     if abs(new - old) <= (0.1 if key == "time" else 0.02) * abs(old):
         return ""
-    if key in ("seam", "detail"):  # best at 1.0, as in the original images
+    if key in ("seam", "detail", "variety"):  # best at 1.0, as in the original images
         old, new = abs(old - 1), abs(new - 1)
     return "better" if new < old else "worse"
 
@@ -420,7 +472,7 @@ def section(case: Case, results: list[Result], labels: list[str]) -> str:
     shown = case.image.copy()
     if case.global_mask is not None:
         shown[case.global_mask] //= 2
-    versions = [("holes", shown, None)]
+    versions: list[tuple[str, np.ndarray, Result | None]] = [("holes", shown, None)]
     versions += [(label, r.fill, r) for label, r in zip(labels, results, strict=True)]
     if case.truth is not None:
         versions.append(("original", case.truth, None))
@@ -502,9 +554,9 @@ def markdown(rows: list[tuple[Case, list[Result]]], title: str) -> str:
         ]
     lines += [
         "",
-        "Means over the seeds. seam and detail are best at 1.0, as in the original "
-        "images, error and edges at 0. With a baseline: baseline → current, 🟢 better "
-        "and 🔴 worse by more than 2 % (time: 10 %).",
+        "Means over the seeds. seam, detail and variety are best at 1.0, as in the "
+        "original images, error and edges at 0. With a baseline: baseline → current, "
+        "🟢 better and 🔴 worse by more than 2 % (time: 10 %).",
     ]
     return "\n".join(lines)
 
@@ -525,6 +577,7 @@ def main() -> None:
     parser.add_argument("--patch-size", type=int, default=3)
     parser.add_argument("--seeds", type=int, default=3)
     parser.add_argument("--cases", help="comma-separated names, default: all")
+    parser.add_argument("--jobs", type=int, help="processes, default: one per CPU")
     parser.add_argument(
         "--markdown", action="store_true", help="print the table as Markdown"
     )
@@ -541,7 +594,9 @@ def main() -> None:
     if args.baseline:
         libraries.insert(0, _lib.load_library(args.baseline.resolve()))
         labels = ["baseline", "current"]
+    paths = [lib._name for lib in libraries]
     selected = set(args.cases.split(",")) if args.cases else None
+    chosen = [case for case in cases() if not selected or case.name in selected]
 
     out = sys.stderr if args.markdown else sys.stdout
     print(f"patch_size={args.patch_size} seeds={args.seeds}", file=out)
@@ -549,16 +604,28 @@ def main() -> None:
     header = f"{'case':14} {''.join(f'{key:16}' for key in COLUMNS)}{'time':16}{fills}"
     print(header.rstrip(), file=out)
     rows = []
-    for case in cases():
-        if selected and case.name not in selected:
-            continue
-        results = [
-            evaluate(lib, case, args.patch_size, args.seeds) for lib in libraries
+    pool = ProcessPoolExecutor(args.jobs)
+    try:
+        # all at once, the seeds outside, so that the libraries run under equal load
+        jobs = [
+            {
+                (index, seed): pool.submit(fill_seed, path, case, args.patch_size, seed)
+                for seed in range(args.seeds)
+                for index, path in enumerate(paths)
+            }
+            for case in chosen
         ]
-        print_row(case.name, results, out)
-        rows.append((case, results))
-
-    meta = describe(args, labels, [lib._name for lib in libraries])
+        for case, futures in zip(chosen, jobs, strict=True):
+            results = [
+                evaluate([futures[index, seed] for seed in range(args.seeds)])
+                for index in range(len(paths))
+            ]
+            print_row(case.name, results, out)
+            rows.append((case, results))
+    finally:
+        pool.shutdown(cancel_futures=True)  # Ctrl+C stops after the running jobs
+
+    meta = describe(args, labels, paths)
     write_report(rows, labels, meta)
     print(f"report: {REPORT}", file=out)
     if args.markdown:

{pypatchmatch-2.2.0b3 → pypatchmatch-2.2.0rc2}/tests/test_e2e.py

@@ -137,13 +137,21 @@ def test_global_mask_is_not_used_as_source(pruned_image):
 
 
 def test_restore_aged_photo():
-    """Scratches, holes and a torn corner, light but not white, given as a mask."""
+    """Scratches, holes and a torn corner, light but not white, given as a mask.
+
+    The finest levels averaged the colors of sources from elsewhere in the vignetted
+    photo, so the torn corner came out lighter (error 4.6 to 6.1 with ten seeds).
+    """
     source = Image.open(IMAGES / "camera_damaged.png")
     mask = Image.open(IMAGES / "camera_damaged_mask.png")
+    holes = np.array(mask) > 0
 
     result = patchmatch.inpaint(source, mask, patch_size=3)
 
-    assert_plausible_fill(np.array(source), result, holes=np.array(mask) > 0)
+    assert_plausible_fill(np.array(source), result, holes=holes)
+    truth = evaluation.load(IMAGES / "camera_aged.png")
+    error = evaluation.coarse_error(result, truth, holes)
+    assert error < 4.2, error
 
 
 @pytest.mark.parametrize(