patchmatch-cython 0.1.5__tar.gz → 0.2.0__tar.gz

{patchmatch_cython-0.1.5/src/patchmatch_cython.egg-info → patchmatch_cython-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchmatch-cython
-Version: 0.1.5
+Version: 0.2.0
 Summary: High-performance PatchMatch implementation for image inpainting using Cython
 Home-page: https://github.com/Teriks/patchmatch-cython
 Author: Teriks
@@ -70,16 +70,11 @@ Dynamic: requires-python
 
 # PatchMatch Cython
 
-High-performance PatchMatch implementation for pyramidical image inpainting in cython.
+High-performance PatchMatch implementation for pyramidical image inpainting in Cython.
 
-This package can function without `python-opencv` / `python-opencv-headless` with only slightly reduced quality.
+This package can function without OpenCV (`opencv-python` / `opencv-python-headless`) with only slightly reduced quality and speed in a few helpers. When OpenCV is installed it is used for resize (`INTER_LINEAR` / `INTER_AREA`), morphology for valid/query centers, and distance transforms for seam feathering.
 
-Installing OpenCV results in this packaging using it for upsampling (`INTER_LINEAR`).
-
-When OpenCV is not installed, an implementation of bilinear upscaling using numpy will be used.
-
-This package provides a pure python solver and a cython solver, the cython solver is 
-around 30 to 50 times faster than the python solver depending on patch size.
+The package provides a pure Python solver and a Cython solver; the Cython solver is typically about 30–50× faster depending on patch size.
 
 ## Installation
 
@@ -102,13 +97,10 @@ pip install .
 import cv2
 from patchmatch_cython import inpaint_pyramid
 
-# Load image and mask
 image = cv2.imread('image.jpg')
-mask = cv2.imread('mask.png', 0) > 128
+mask = cv2.imread('mask.png', 0) > 128  # True = hole to fill
 
-# Inpaint
 result = inpaint_pyramid(image, mask)
-
 cv2.imwrite('result.jpg', result)
 ```
 
@@ -119,27 +111,84 @@ import numpy as np
 from PIL import Image
 from patchmatch_cython import inpaint_pyramid
 
-# Load image and mask  
 image = np.array(Image.open('image.jpg'))
 mask = np.array(Image.open('mask.png').convert('L')) > 128
 
-# Inpaint (auto-selects fastest available solver)
-result = inpaint_pyramid(image, mask)
-
+result = inpaint_pyramid(image, mask)  # auto-selects fastest available solver
 Image.fromarray(result).save('result.jpg')
 ```
 
-### Explicit Solver Selection
+### Explicit solver selection
 
 ```python
 from patchmatch_cython import PythonSolver, CythonSolver, inpaint_pyramid
 
-# Force specific solver
 result = inpaint_pyramid(image, mask, solver_class=CythonSolver)  # Fast
 result = inpaint_pyramid(image, mask, solver_class=PythonSolver)  # Fallback
 ```
 
-## Package Extras
+### Quality / compose options
+
+Both `inpaint_pyramid` and `inpaint_single` accept the same optional knobs.
+Defaults preserve a sensible baseline; turn options on when you need more structure,
+completeness, or softer seams.
+
+```python
+from patchmatch_cython import inpaint_pyramid
+
+result = inpaint_pyramid(
+    image,
+    mask,
+    patch_size=5,          # odd int; square patch side
+    seed=0,                # reproducible RNG (optional)
+    em_loops=2,            # coarse match→vote→rematch loops (pyramid: coarse levels only)
+    edge_weighted=True,    # structure-aware distance (boosted gradients)
+    reverse_search=True,   # source→query completeness pass + stronger usage penalty
+    poisson_blend=True,    # harmonic seam soften (default ~8px band)
+    hole_refine=3,         # extra full-res PatchMatch iterations after the main solve
+    mask_feather=6.0,      # soft compose width in px from the hole boundary
+)
+```
+
+| Parameter | Default | Description |
+|---|---|---|
+| `patch_size` | `5` | Odd positive int; square patch size for matching / voting. |
+| `seed` | `None` | RNG seed for reproducible NNF init / search. |
+| `em_loops` | `1` | Outer match→paint→rematch loops. On pyramids, applied at coarse levels only (finest stays `1`). |
+| `edge_weighted` | `False` | `False` = color-only matching. `True` = color + boosted gradient channels. Hole-touching gradients are suppressed so zeroed holes do not create fake edges. |
+| `reverse_search` | `False` | After each EM loop, try assigning underused near-hole sources to better queries (completeness). |
+| `poisson_blend` | `True` | Soften seams by blending the PatchMatch fill with a harmonic membrane near the hole rim. Ignored when `mask_feather > 0` (feather supplies the band). |
+| `hole_refine` | `0` | Extra full-resolution PatchMatch iterations after the main solve (`0` disables). Only hole pixels are painted; the user mask is not modified. |
+| `mask_feather` | `0.0` | Soft compose width in pixels from the hole boundary. Uses a distance ramp toward a harmonic rim pull (not the original hole content). Does **not** change the mask used for matching. |
+
+`inpaint_single` is the same API plus `iterations` (PatchMatch passes at one scale):
+
+```python
+from patchmatch_cython import inpaint_single
+
+result = inpaint_single(
+    image,
+    mask,
+    iterations=7,
+    em_loops=2,
+    reverse_search=True,
+    hole_refine=2,
+    mask_feather=4.0,
+    poisson_blend=False,  # feather handles seams when mask_feather > 0
+)
+```
+
+**Masks:** accept `bool`, `{0,1}`, or `{0,255}`. `True` / non-zero = region to inpaint. Known (unmasked) pixels are preserved in the output. The library never dilates/erodes the user mask for matching; `mask_feather` only affects final compositing.
+
+**OpenCV runtime toggle** (optional):
+
+```python
+from patchmatch_cython.imageops import set_use_opencv, opencv_available
+
+set_use_opencv(False)  # force NumPy fallbacks even if OpenCV is installed
+```
+
+## Package extras
 
 **For examples:**
 
@@ -163,15 +212,13 @@ To build wheels locally for distribution or development:
 
 ### Prerequisites
 
-Install build dependencies:
-
 ```bash
 pip install cibuildwheel
 ```
 
-### Build Wheels
+### Build wheels
 
-Use the included `local_build.py` script to build locally:
+Use the included `local_build.py` script:
 
 ```bash
 # Build for all supported Python versions (3.10-3.14)
@@ -193,14 +240,13 @@ python local_build.py --no-clean
 python local_build.py --help
 ```
 
-### Build Options
+### Build options
 
 - `--python`: Specify Python versions to build for (e.g., `3.11 3.12`)
 - `--platform`: Target platform (`auto`, `linux`, `macos`, `windows`)
 - `--test`: Test wheel installation after building
 - `--no-clean`: Skip cleaning build artifacts before building
 
-
 ## Requirements
 
 - Python 3.10+

patchmatch_cython-0.2.0/README.md

@@ -0,0 +1,184 @@
+# PatchMatch Cython
+
+High-performance PatchMatch implementation for pyramidical image inpainting in Cython.
+
+This package can function without OpenCV (`opencv-python` / `opencv-python-headless`) with only slightly reduced quality and speed in a few helpers. When OpenCV is installed it is used for resize (`INTER_LINEAR` / `INTER_AREA`), morphology for valid/query centers, and distance transforms for seam feathering.
+
+The package provides a pure Python solver and a Cython solver; the Cython solver is typically about 30–50× faster depending on patch size.
+
+## Installation
+
+```bash
+pip install patchmatch-cython
+```
+
+**From source:**
+```bash
+git clone <repository-url>
+cd patchmatch-cython
+pip install .
+```
+
+## Usage
+
+### With OpenCV
+
+```python
+import cv2
+from patchmatch_cython import inpaint_pyramid
+
+image = cv2.imread('image.jpg')
+mask = cv2.imread('mask.png', 0) > 128  # True = hole to fill
+
+result = inpaint_pyramid(image, mask)
+cv2.imwrite('result.jpg', result)
+```
+
+### With Pillow
+
+```python
+import numpy as np
+from PIL import Image
+from patchmatch_cython import inpaint_pyramid
+
+image = np.array(Image.open('image.jpg'))
+mask = np.array(Image.open('mask.png').convert('L')) > 128
+
+result = inpaint_pyramid(image, mask)  # auto-selects fastest available solver
+Image.fromarray(result).save('result.jpg')
+```
+
+### Explicit solver selection
+
+```python
+from patchmatch_cython import PythonSolver, CythonSolver, inpaint_pyramid
+
+result = inpaint_pyramid(image, mask, solver_class=CythonSolver)  # Fast
+result = inpaint_pyramid(image, mask, solver_class=PythonSolver)  # Fallback
+```
+
+### Quality / compose options
+
+Both `inpaint_pyramid` and `inpaint_single` accept the same optional knobs.
+Defaults preserve a sensible baseline; turn options on when you need more structure,
+completeness, or softer seams.
+
+```python
+from patchmatch_cython import inpaint_pyramid
+
+result = inpaint_pyramid(
+    image,
+    mask,
+    patch_size=5,          # odd int; square patch side
+    seed=0,                # reproducible RNG (optional)
+    em_loops=2,            # coarse match→vote→rematch loops (pyramid: coarse levels only)
+    edge_weighted=True,    # structure-aware distance (boosted gradients)
+    reverse_search=True,   # source→query completeness pass + stronger usage penalty
+    poisson_blend=True,    # harmonic seam soften (default ~8px band)
+    hole_refine=3,         # extra full-res PatchMatch iterations after the main solve
+    mask_feather=6.0,      # soft compose width in px from the hole boundary
+)
+```
+
+| Parameter | Default | Description |
+|---|---|---|
+| `patch_size` | `5` | Odd positive int; square patch size for matching / voting. |
+| `seed` | `None` | RNG seed for reproducible NNF init / search. |
+| `em_loops` | `1` | Outer match→paint→rematch loops. On pyramids, applied at coarse levels only (finest stays `1`). |
+| `edge_weighted` | `False` | `False` = color-only matching. `True` = color + boosted gradient channels. Hole-touching gradients are suppressed so zeroed holes do not create fake edges. |
+| `reverse_search` | `False` | After each EM loop, try assigning underused near-hole sources to better queries (completeness). |
+| `poisson_blend` | `True` | Soften seams by blending the PatchMatch fill with a harmonic membrane near the hole rim. Ignored when `mask_feather > 0` (feather supplies the band). |
+| `hole_refine` | `0` | Extra full-resolution PatchMatch iterations after the main solve (`0` disables). Only hole pixels are painted; the user mask is not modified. |
+| `mask_feather` | `0.0` | Soft compose width in pixels from the hole boundary. Uses a distance ramp toward a harmonic rim pull (not the original hole content). Does **not** change the mask used for matching. |
+
+`inpaint_single` is the same API plus `iterations` (PatchMatch passes at one scale):
+
+```python
+from patchmatch_cython import inpaint_single
+
+result = inpaint_single(
+    image,
+    mask,
+    iterations=7,
+    em_loops=2,
+    reverse_search=True,
+    hole_refine=2,
+    mask_feather=4.0,
+    poisson_blend=False,  # feather handles seams when mask_feather > 0
+)
+```
+
+**Masks:** accept `bool`, `{0,1}`, or `{0,255}`. `True` / non-zero = region to inpaint. Known (unmasked) pixels are preserved in the output. The library never dilates/erodes the user mask for matching; `mask_feather` only affects final compositing.
+
+**OpenCV runtime toggle** (optional):
+
+```python
+from patchmatch_cython.imageops import set_use_opencv, opencv_available
+
+set_use_opencv(False)  # force NumPy fallbacks even if OpenCV is installed
+```
+
+## Package extras
+
+**For examples:**
+
+```bash
+pip install patchmatch-cython[visualization]
+```
+
+Adds: `matplotlib`, `Pillow`
+
+**For development:**
+
+```bash
+pip install patchmatch-cython[dev]
+```
+
+Adds: `pytest`, `build`, `cibuildwheel`, `setuptools`, `wheel`
+
+## Building
+
+To build wheels locally for distribution or development:
+
+### Prerequisites
+
+```bash
+pip install cibuildwheel
+```
+
+### Build wheels
+
+Use the included `local_build.py` script:
+
+```bash
+# Build for all supported Python versions (3.10-3.14)
+python local_build.py
+
+# Build for specific Python versions
+python local_build.py --python 3.11 3.12
+
+# Build for specific platform
+python local_build.py --platform linux
+
+# Build and test wheel installation
+python local_build.py --test
+
+# Build without cleaning previous artifacts
+python local_build.py --no-clean
+
+# View all options
+python local_build.py --help
+```
+
+### Build options
+
+- `--python`: Specify Python versions to build for (e.g., `3.11 3.12`)
+- `--platform`: Target platform (`auto`, `linux`, `macos`, `windows`)
+- `--test`: Test wheel installation after building
+- `--no-clean`: Skip cleaning build artifacts before building
+
+## Requirements
+
+- Python 3.10+
+- NumPy (auto-installed)
+- C++ compiler (for building from source)

{patchmatch_cython-0.1.5 → patchmatch_cython-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "patchmatch-cython"
-version = "0.1.5"
+version = "0.2.0"
 description = "High-performance PatchMatch implementation for image inpainting using Cython"
 readme = "README.md"
 authors = [

{patchmatch_cython-0.1.5 → patchmatch_cython-0.2.0}/setup.py

@@ -47,12 +47,13 @@ def get_compiler_args():
         # with "unsupported option '-mcpu='".
         if archs == ["arm64"]:
             return ["-O3", "-mcpu=apple-m1"]
-        # -march=native is only safe when actually compiling on Intel.
-        if archs == ["x86_64"] and platform.machine().lower() in ("x86_64", "amd64"):
-            return ["-O3", "-march=native"]
+        # Avoid -march=native so wheels remain portable across CPUs.
         return ["-O3"]
     else:  # Linux and other Unix-like
-        return ["-O3", "-march=native"]
+        # Portable default; set PATCHMATCH_NATIVE=1 for local native builds.
+        if os.environ.get("PATCHMATCH_NATIVE") == "1":
+            return ["-O3", "-march=native"]
+        return ["-O3"]
 
 # Build from Cython source only
 extensions = [
@@ -82,7 +83,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="patchmatch-cython",
-    version="0.1.5",
+    version="0.2.0",
     author="Teriks",
     author_email="Teriks999@gmail.com",
     description="High-performance PatchMatch implementation for image inpainting using Cython",

{patchmatch_cython-0.1.5 → patchmatch_cython-0.2.0}/src/patchmatch_cython/__init__.py

@@ -1,6 +1,6 @@
 import typing
 
-__version__: str = "0.1.5"
+__version__: str = "0.2.0"
 
 # Core algorithm imports (always available)
 from .python_solver import PythonSolver

{patchmatch_cython-0.1.5 → patchmatch_cython-0.2.0}/src/patchmatch_cython/cython_solver.py

@@ -41,14 +41,22 @@ class CythonSolver(Solver):
             self,
             image: np.ndarray,
             mask: np.ndarray,
-            patch_size: int
+            patch_size: int,
+            edge_weighted: bool = False,
     ) -> None:
-        super().__init__(image, mask, patch_size)
+        # Normalize mask to {0,1} uint8. Plain astype(uint8) leaves {0,255} masks
+        # unchanged; boolean indexing bugs are avoided by going through != 0.
+        image_f32 = np.ascontiguousarray(image, dtype=np.float32)
+        mask_u8 = (np.asarray(mask) != 0).astype(np.uint8)
+        super().__init__(
+            image_f32, mask_u8.astype(bool), patch_size, edge_weighted=edge_weighted
+        )
 
         self._solver: typing.Any = CythonSolverImpl(
-            image.astype(np.float32),
-            mask.astype(np.uint8),
-            patch_size
+            image_f32,
+            np.ascontiguousarray(mask_u8),
+            patch_size,
+            edge_weighted=bool(edge_weighted),
         )
 
     @property
@@ -64,7 +72,9 @@ class CythonSolver(Solver):
             iterations: int = 5,
             randomize_nnf: bool = True,
             nnf: typing.Optional[np.ndarray] = None,
-            seed: typing.Optional[int] = None
+            seed: typing.Optional[int] = None,
+            em_loops: int = 1,
+            reverse_search: bool = False,
     ) -> np.ndarray:
         """
         Run the PatchMatch algorithm using Cython acceleration.
@@ -85,8 +95,23 @@ class CythonSolver(Solver):
         :type nnf: numpy.ndarray or None
         :param seed: Random seed for this specific run (overrides instance seed)
         :type seed: int or None
-        :return: Inpainted image with masked regions filled, converted to uint8
+        :param em_loops: Outer match→vote→rematch loops (1 preserves prior behavior)
+        :type em_loops: int
+        :param reverse_search: Enable reverse/completeness search after each EM loop
+        :type reverse_search: bool
+        :return: Inpainted image with masked regions filled (float32)
         :rtype: numpy.ndarray
         """
 
-        return self._solver(iterations, randomize_nnf, nnf, seed).astype(np.uint8)
+        # Keep float32 here so callers (and inpaint_*) can round/saturate once.
+        return np.asarray(
+            self._solver(
+                iterations,
+                randomize_nnf,
+                nnf,
+                seed,
+                em_loops,
+                reverse_search,
+            ),
+            dtype=np.float32,
+        )