patchmatch-cython 0.1.0__tar.gz

patchmatch_cython-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Teriks
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

patchmatch_cython-0.1.0/MANIFEST.in

@@ -0,0 +1,13 @@
+include *.py
+include README.md
+include LICENSE
+recursive-include src *.py *.pyx
+global-exclude *.pyc
+global-exclude *.pyo
+global-exclude *~
+global-exclude .DS_Store
+global-exclude __pycache__
+prune build
+prune dist
+prune .git
+prune .pytest_cache 

patchmatch_cython-0.1.0/PKG-INFO

@@ -0,0 +1,207 @@
+Metadata-Version: 2.4
+Name: patchmatch-cython
+Version: 0.1.0
+Summary: High-performance PatchMatch implementation for image inpainting using Cython
+Home-page: https://github.com/Teriks/patchmatch-cython
+Author: Teriks
+Author-email: Teriks <Teriks999@gmail.com>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2025, Teriks
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Project-URL: Homepage, https://github.com/Teriks/patchmatch-cython
+Project-URL: Repository, https://github.com/Teriks/patchmatch-cython
+Project-URL: Issues, https://github.com/Teriks/patchmatch-cython/issues
+Keywords: image-processing,inpainting,patchmatch,cython,computer-vision
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Cython
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Provides-Extra: visualization
+Requires-Dist: matplotlib>=3.5.0; extra == "visualization"
+Requires-Dist: Pillow>=8.0.0; extra == "visualization"
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0.0; extra == "dev"
+Requires-Dist: build>=0.8.0; extra == "dev"
+Requires-Dist: setuptools>=61.0; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: Cython>=0.29.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# PatchMatch 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.
+
+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.
+
+## 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
+
+# Load image and mask
+image = cv2.imread('image.jpg')
+mask = cv2.imread('mask.png', 0) > 128
+
+# Inpaint
+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
+
+# 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)
+
+Image.fromarray(result).save('result.jpg')
+```
+
+### 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
+
+**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
+
+Install build dependencies:
+
+```bash
+pip install cibuildwheel
+```
+
+### Build Wheels
+
+Use the included `local_build.py` script to build locally:
+
+```bash
+# Build for all supported Python versions (3.10-3.13)
+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.0/README.md

@@ -0,0 +1,138 @@
+# PatchMatch 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.
+
+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.
+
+## 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
+
+# Load image and mask
+image = cv2.imread('image.jpg')
+mask = cv2.imread('mask.png', 0) > 128
+
+# Inpaint
+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
+
+# 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)
+
+Image.fromarray(result).save('result.jpg')
+```
+
+### 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
+
+**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
+
+Install build dependencies:
+
+```bash
+pip install cibuildwheel
+```
+
+### Build Wheels
+
+Use the included `local_build.py` script to build locally:
+
+```bash
+# Build for all supported Python versions (3.10-3.13)
+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.0/local_build.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""
+Local wheel building script
+
+This script builds wheels for all supported Python versions using cibuildwheel.
+"""
+
+import os
+import sys
+import subprocess
+import shutil
+import argparse
+from pathlib import Path
+
+def run_command(cmd, env=None):
+    """Run command and return success status"""
+    print(f"RUNNING: {cmd}")
+    try:
+        result = subprocess.run(cmd, shell=True, check=True, env=env)
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"ERROR: Command failed with exit code {e.returncode}")
+        return False
+
+def clean_build_artifacts():
+    """Clean previous build artifacts"""
+    artifacts_to_clean = [
+        "wheelhouse",
+        "build",
+        "dist",
+        "*.egg-info",
+        "src/**/*.cpp",
+        "src/**/*.c",
+        "src/**/*.so",
+        "src/**/*.pyd",
+    ]
+    
+    print("Cleaning previous build artifacts...")
+    for pattern in artifacts_to_clean:
+        if '*' in pattern:
+            # Handle glob patterns
+            import glob
+            for path in glob.glob(pattern, recursive=True):
+                if os.path.isdir(path):
+                    print(f"  Removing directory: {path}")
+                    shutil.rmtree(path, ignore_errors=True)
+                else:
+                    print(f"  Removing file: {path}")
+                    os.remove(path)
+        else:
+            path = Path(pattern)
+            if path.exists():
+                if path.is_dir():
+                    print(f"  Removing directory: {path}")
+                    shutil.rmtree(path)
+                else:
+                    print(f"  Removing file: {path}")
+                    path.unlink()
+
+def build_wheels(python_versions=None, platforms=None, clean=True):
+    """Build wheels using cibuildwheel"""
+    
+    if clean:
+        clean_build_artifacts()
+    
+    # Create custom environment
+    env = os.environ.copy()
+    
+    # Set build configuration
+    if python_versions:
+        # Build specific Python versions
+        if isinstance(python_versions, list):
+            build_pattern = " ".join([f"cp{v.replace('.', '')}-*" for v in python_versions])
+        else:
+            build_pattern = f"cp{python_versions.replace('.', '')}-*"
+        env["CIBW_BUILD"] = build_pattern
+        print(f"Building for Python versions: {python_versions}")
+    else:
+        # Build all supported versions (default)
+        env["CIBW_BUILD"] = "cp310-* cp311-* cp312-* cp313-*"
+        print("Building for all supported Python versions (3.10-3.13)")
+    
+
+    
+    # Set platform-specific configurations
+    if platforms:
+        if isinstance(platforms, list):
+            platform_arg = f"--platform {' '.join(platforms)}"
+        else:
+            platform_arg = f"--platform {platforms}"
+    else:
+        platform_arg = ""  # Build for current platform
+    
+    # Configure test command
+    env["CIBW_TEST_COMMAND"] = "python -c \"import patchmatch_cython; print('Import successful')\""
+    
+    print(f"\n{'='*70}")
+    print("BUILDING WHEELS")
+    print(f"{'='*70}")
+    
+    # Run cibuildwheel
+    cmd = f"cibuildwheel --output-dir wheelhouse {platform_arg}".strip()
+    success = run_command(cmd, env)
+    
+    if not success:
+        # Try as Python module
+        cmd = f"{sys.executable} -m cibuildwheel --output-dir wheelhouse {platform_arg}".strip()
+        success = run_command(cmd, env)
+    
+    if success:
+        print(f"\n{'='*70}")
+        print("BUILD SUCCESSFUL")
+        print(f"{'='*70}")
+        
+        # List built wheels
+        wheelhouse = Path("wheelhouse")
+        if wheelhouse.exists():
+            wheels = list(wheelhouse.glob("*.whl"))
+            print(f"\nBuilt {len(wheels)} wheels:")
+            for wheel in wheels:
+                size_mb = wheel.stat().st_size / (1024 * 1024)
+                print(f"  WHEEL: {wheel.name} ({size_mb:.1f} MB)")
+        
+        return True
+    else:
+        print(f"\n{'='*70}")
+        print("BUILD FAILED")
+        print(f"{'='*70}")
+        return False
+
+def validate_wheel_installation():
+    """Test installing and importing built wheels"""
+    wheelhouse = Path("wheelhouse")
+    wheels = list(wheelhouse.glob("*.whl"))
+    
+    if not wheels:
+        print("ERROR: No wheels found to test")
+        return False
+    
+    print(f"\n{'='*70}")
+    print("TESTING WHEEL INSTALLATION")
+    print(f"{'='*70}")
+    
+    # Test the first wheel
+    wheel = wheels[0]
+    print(f"Testing wheel: {wheel.name}")
+    
+    # Install wheel in a temporary way
+    test_cmd = f"pip install {wheel} --force-reinstall --no-deps"
+    if run_command(test_cmd):
+        # Test import
+        test_import = "python -c \"import patchmatch_cython; print('SUCCESS: Import successful')\""
+        if run_command(test_import):
+            print("SUCCESS: Wheel installation and import test passed")
+            return True
+    
+    print("ERROR: Wheel installation test failed")
+    return False
+
+def main():
+    """Main function"""
+    parser = argparse.ArgumentParser(description="Build wheels for patchmatch-cython")
+    parser.add_argument("--python", nargs="*", 
+                       help="Python versions to build for (e.g., 3.11 3.12). Default: all supported versions")
+    parser.add_argument("--platform", choices=["auto", "linux", "macos", "windows"], 
+                       help="Platform to build for. Default: current platform")
+    parser.add_argument("--no-clean", action="store_true", 
+                       help="Don't clean build artifacts before building")
+    parser.add_argument("--test", action="store_true", 
+                       help="Test wheel installation after building")
+    
+    args = parser.parse_args()
+    
+    print("PatchMatch Cython - Local Wheel Builder")
+    print("=" * 70)
+    
+    # Check if cibuildwheel is installed
+    print("Checking for cibuildwheel...")
+    cibw_found = False
+    
+    # Try importing cibuildwheel as a Python module first (most reliable)
+    try:
+        import cibuildwheel
+        print(f"SUCCESS: Found cibuildwheel module version: {cibuildwheel.__version__}")
+        cibw_found = True
+    except ImportError:
+        print("cibuildwheel module not importable, trying command line...")
+        
+        # Try as a direct command with --help
+        try:
+            result = subprocess.run(["cibuildwheel", "--help"], check=True, capture_output=True, text=True)
+            print("SUCCESS: Found cibuildwheel (direct command)")
+            cibw_found = True
+        except subprocess.CalledProcessError as e:
+            print(f"Direct command failed with exit code {e.returncode}")
+        except FileNotFoundError:
+            print("Direct command not found")
+        
+        # Try as a Python module with --help
+        if not cibw_found:
+            try:
+                result = subprocess.run([sys.executable, "-m", "cibuildwheel", "--help"], check=True, capture_output=True, text=True)
+                print("SUCCESS: Found cibuildwheel (Python module)")
+                cibw_found = True
+            except subprocess.CalledProcessError as e:
+                print(f"Python module failed with exit code {e.returncode}")
+            except FileNotFoundError:
+                print("Python module not found")
+    
+    if not cibw_found:
+        print("ERROR: cibuildwheel not found. Install with: pip install cibuildwheel")
+        return 1
+    
+    # Check if we're in the right directory
+    if not Path("src/patchmatch_cython/cython_solver_impl.pyx").exists():
+        print("ERROR: cython_solver_impl.pyx not found in src/patchmatch_cython/. Run from the project root.")
+        print("Current directory:", os.getcwd())
+        print("Looking for:", Path("src/patchmatch_cython/cython_solver_impl.pyx").absolute())
+        return 1
+    
+    print("SUCCESS: Environment checks passed")
+    
+    # Configure build parameters
+    python_versions = args.python
+    platforms = args.platform
+    
+    # Build wheels
+    success = build_wheels(
+        python_versions=python_versions, 
+        platforms=platforms, 
+        clean=not args.no_clean
+    )
+    
+    if not success:
+        return 1
+    
+    # Test wheel installation if requested
+    if args.test:
+        validate_wheel_installation()
+    
+    print(f"\n{'='*70}")
+    print("WHEEL BUILDING COMPLETE")
+    print(f"{'='*70}")
+    print("INFO: Check the 'wheelhouse' directory for built wheels")
+    
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())