pyimagecuda 0.0.4__cp312-cp312-win_amd64.whl

pyimagecuda/resize.py

@@ -0,0 +1,97 @@
+from .image import Image
+from .utils import ensure_capacity
+from .pyimagecuda_internal import resize_f32  #type: ignore
+
+
+def _resize_internal(
+    src: Image,
+    width: int | None,
+    height: int | None,
+    method: int,
+    dst_buffer: Image | None = None
+) -> Image | None:
+    
+    if width is None and height is None:
+        raise ValueError("At least one of width or height must be specified")
+    elif width is None:
+        width = int(src.width * (height / src.height))
+    elif height is None:
+        height = int(src.height * (width / src.width))
+    
+    if dst_buffer is None:
+        dst_buffer = Image(width, height)
+        return_buffer = True
+    else:
+        ensure_capacity(dst_buffer, width, height)
+        return_buffer = False
+    
+    resize_f32(
+        src._buffer._handle,
+        dst_buffer._buffer._handle,
+        src.width,
+        src.height,
+        width,
+        height,
+        method
+    )
+    
+    return dst_buffer if return_buffer else None
+
+
+class Resize:
+    @staticmethod
+    def nearest(
+        src: Image,
+        width: int | None = None,
+        height: int | None = None,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        """
+        Resizes the image using nearest neighbor interpolation (returns new image or writes to buffer).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/resize/#nearest
+        """
+        return _resize_internal(src, width, height, 0, dst_buffer)
+
+    @staticmethod
+    def bilinear(
+        src: Image,
+        width: int | None = None,
+        height: int | None = None,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        """
+        Resizes the image using bilinear interpolation (returns new image or writes to buffer).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/resize/#bilinear
+        """
+
+        return _resize_internal(src, width, height, 1, dst_buffer)
+
+    @staticmethod
+    def bicubic(
+        src: Image,
+        width: int | None = None,
+        height: int | None = None,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        """
+        Resizes the image using bicubic interpolation (returns new image or writes to buffer).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/resize/#bicubic
+        """
+        return _resize_internal(src, width, height, 2, dst_buffer)
+
+    @staticmethod
+    def lanczos(
+        src: Image,
+        width: int | None = None,
+        height: int | None = None,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        """
+        Resizes the image using Lanczos interpolation (returns new image or writes to buffer).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/resize/#lanczos
+        """
+        return _resize_internal(src, width, height, 3, dst_buffer)

pyimagecuda/transform.py

@@ -0,0 +1,186 @@
+import math
+from typing import Literal
+from .image import Image
+from .utils import ensure_capacity
+from .fill import Fill
+from .pyimagecuda_internal import ( #type: ignore
+    flip_f32, crop_f32, rotate_fixed_f32, 
+    rotate_arbitrary_f32, copy_buffer 
+)
+
+
+class Transform:
+    
+    @staticmethod
+    def flip(
+        image: Image, 
+        direction: Literal['horizontal', 'vertical', 'both'] = 'horizontal',
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        """
+        Flips the image across the specified axis (returns new image or writes to buffer).
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/transform/#flip
+        """
+        
+        direction_map = {
+            'horizontal': 0,
+            'vertical': 1,
+            'both': 2
+        }
+        
+        mode = direction_map.get(direction)
+        if mode is None:
+            raise ValueError(f"Invalid direction: {direction}. Must be {list(direction_map.keys())}")
+            
+        if dst_buffer is None:
+            dst_buffer = Image(image.width, image.height)
+            return_buffer = True
+        else:
+            ensure_capacity(dst_buffer, image.width, image.height)
+            return_buffer = False
+            
+        flip_f32(
+            image._buffer._handle,
+            dst_buffer._buffer._handle,
+            image.width,
+            image.height,
+            mode
+        )
+        
+        return dst_buffer if return_buffer else None
+
+    @staticmethod
+    def rotate(
+        image: Image,
+        angle: float,
+        expand: bool = True,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        """
+        Rotates the image by any angle in degrees (Clockwise).
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/transform/#rotate
+        """
+        
+        norm_angle = angle % 360
+        if norm_angle < 0: norm_angle += 360
+        
+        is_fixed = False
+        fixed_mode = 0
+        
+        if abs(norm_angle - 0) < 0.01: 
+            if dst_buffer is None:
+                dst_buffer = Image(image.width, image.height)
+                return_buffer = True
+            else:
+                ensure_capacity(dst_buffer, image.width, image.height)
+                return_buffer = False
+            
+            copy_buffer(dst_buffer._buffer._handle, image._buffer._handle, image.width, image.height)
+            return dst_buffer if return_buffer else None
+
+        elif abs(norm_angle - 90) < 0.01: is_fixed = True; fixed_mode = 0
+        elif abs(norm_angle - 180) < 0.01: is_fixed = True; fixed_mode = 1
+        elif abs(norm_angle - 270) < 0.01: is_fixed = True; fixed_mode = 2
+        
+        if is_fixed:
+            if fixed_mode == 1:
+                rot_w, rot_h = image.width, image.height
+            else: 
+                rot_w, rot_h = image.height, image.width
+        else:
+            rads = math.radians(angle)
+            sin_a = abs(math.sin(rads))
+            cos_a = abs(math.cos(rads))
+            rot_w = int(image.width * cos_a + image.height * sin_a)
+            rot_h = int(image.width * sin_a + image.height * cos_a)
+
+        if expand:
+            final_w = rot_w
+            final_h = rot_h
+            offset_x = 0
+            offset_y = 0
+        else:
+            final_w = image.width
+            final_h = image.height
+            offset_x = (final_w - rot_w) // 2
+            offset_y = (final_h - rot_h) // 2
+
+        if dst_buffer is None:
+            dst_buffer = Image(final_w, final_h)
+            return_buffer = True
+        else:
+            ensure_capacity(dst_buffer, final_w, final_h)
+            return_buffer = False
+
+        if is_fixed:
+            rotate_fixed_f32(
+                image._buffer._handle,
+                dst_buffer._buffer._handle,
+                image.width, image.height,
+                final_w, final_h,
+                fixed_mode, offset_x, offset_y
+            )
+        else:
+            rotate_arbitrary_f32(
+                image._buffer._handle,
+                dst_buffer._buffer._handle,
+                image.width, image.height,
+                final_w, final_h,
+                float(angle)
+            )
+        
+        return dst_buffer if return_buffer else None
+
+    @staticmethod
+    def crop(
+        image: Image,
+        x: int,
+        y: int,
+        width: int,
+        height: int,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        """
+        Crops a rectangular region (returns new image or writes to buffer).
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/transform/#crop
+        """
+        if width <= 0 or height <= 0:
+            raise ValueError("Crop dimensions must be positive")
+
+        if dst_buffer is None:
+            dst_buffer = Image(width, height)
+            return_buffer = True
+        else:
+            ensure_capacity(dst_buffer, width, height)
+            return_buffer = False
+
+        Fill.color(dst_buffer, (0.0, 0.0, 0.0, 0.0))
+
+        crop_left = x
+        crop_top = y
+        crop_right = x + width
+        crop_bottom = y + height
+        img_right, img_bottom = image.width, image.height
+        
+        intersect_left = max(crop_left, 0)
+        intersect_top = max(crop_top, 0)
+        intersect_right = min(crop_right, img_right)
+        intersect_bottom = min(crop_bottom, img_bottom)
+        
+        copy_w = intersect_right - intersect_left
+        copy_h = intersect_bottom - intersect_top
+        
+        if copy_w > 0 and copy_h > 0:
+            crop_f32(
+                image._buffer._handle,
+                dst_buffer._buffer._handle,
+                image.width, dst_buffer.width,
+                intersect_left, intersect_top,
+                intersect_left - crop_left, intersect_top - crop_top,
+                copy_w, copy_h
+            )
+            
+        return dst_buffer if return_buffer else None

pyimagecuda/utils.py

@@ -0,0 +1,17 @@
+from .image import ImageBase
+
+def ensure_capacity(buffer: ImageBase, required_width: int, required_height: int) -> None:
+    """
+    Checks if the buffer has enough capacity and updates its logical dimensions.
+    Raises ValueError if capacity is insufficient.
+    """
+    max_w, max_h = buffer.get_max_capacity()
+    
+    if required_width > max_w or required_height > max_h:
+        raise ValueError(
+            f"Buffer capacity too small: need {required_width}×{required_height}, "
+            f"got capacity {max_w}×{max_h}"
+        )
+    
+    buffer.width = required_width
+    buffer.height = required_height

pyimagecuda-0.0.4.dist-info/METADATA

@@ -0,0 +1,95 @@
+Metadata-Version: 2.2
+Name: pyimagecuda
+Version: 0.0.4
+Summary: GPU-accelerated image processing library for Python
+Author: Beltrán Offerrall
+Requires-Python: >=3.10
+Requires-Dist: pyvips[binary]
+Description-Content-Type: text/markdown
+
+# PyImageCUDA 0.0.4
+
+[![PyPI version](https://img.shields.io/pypi/v/pyimagecuda.svg)](https://pypi.org/project/pyimagecuda/)
+[![Build Status](https://github.com/offerrall/pyimagecuda/actions/workflows/build.yml/badge.svg)](https://github.com/offerrall/pyimagecuda/actions)
+![Python](https://img.shields.io/badge/python-3.10%20|%203.11%20|%203.12%20|%203.13-blue)
+
+**GPU-accelerated image compositing for Python.**
+
+> PyImageCUDA focuses on creative image generation rather than computer vision. Expect GPU-accelerated effects for design workflows—blending modes, shadows, gradients, filters... not edge detection or object recognition.
+
+## Quick Example
+
+<img src="https://offerrall.github.io/pyimagecuda/images/quick.png" alt="Demo" width="400">
+
+```python
+from pyimagecuda import Image, Fill, Effect, Blend, Transform, save
+
+with Image(1024, 1024) as bg:
+    Fill.color(bg, (0, 1, 0.8, 1))
+    with Image(512, 512) as card:
+        Fill.gradient(card, (1, 0, 0, 1), (0, 0, 1, 1), 'radial')
+        Effect.rounded_corners(card, 50)
+
+        with Effect.stroke(card, 10, (1, 1, 1, 1)) as stroked:
+            with Effect.drop_shadow(stroked, blur=50, color=(0, 0, 0, 1)) as shadowed:
+                with Transform.rotate(shadowed, 45) as rotated:
+                    Blend.normal(bg, rotated, anchor='center')
+
+    save(bg, 'output.png')
+```
+
+## Key Features
+
+* ✅ **Zero Dependencies:** No CUDA Toolkit, Visual Studio, or complex compilers needed. Is Plug & Play.
+* ✅ **Ultra-lightweight:** library weighs **<0.5 MB**.
+* ✅ **Studio Quality:** 32-bit floating-point precision (float32) to prevent color banding.
+* ✅ **Advanced Memory Control:** Reuse GPU buffers across operations and resize without reallocation—critical for video processing and batch workflows.
+* ✅ **API Simplicity:** Intuitive, Pythonic API designed for ease of use.
+
+## Use Cases
+
+* **Generative Art:** Create thousands of unique variations in seconds.
+* **Motion Graphics:** Process video frames or generate effects in real-time.
+* **Image Compositing:** Complex multi-layer designs with GPU-accelerated effects.
+* **Game Development:** Procedural UI assets, icons, and sprite generation.
+* **Marketing Automation:** Mass-produce personalized graphics from templates.
+* **Data Augmentation:** High-speed batch transformations for ML datasets.
+
+## Installation
+```bash
+pip install pyimagecuda
+```
+
+**Note:** Automatically installs `pyvips` binary dependencies for robust image format support (JPG, PNG, WEBP, HEIC).
+
+## Documentation
+
+**⚠️ Alpha Release:** Many more features are planned and under development. If you have specific needs or bug reports, please open an issue on GitHub.
+
+### Core Concepts
+* [Getting Started Guide](https://offerrall.github.io/pyimagecuda/)
+* [Image & Memory](https://offerrall.github.io/pyimagecuda/image/) (Buffer management)
+* [IO](https://offerrall.github.io/pyimagecuda/io/) (Loading and Saving)
+
+### Operations
+* [Adjust](https://offerrall.github.io/pyimagecuda/adjust/) (Brightness, Contrast, Saturation, Gamma, Opacity)
+* [Transform](https://offerrall.github.io/pyimagecuda/transform/) (Flip, Rotate, Crop)
+* [Blend](https://offerrall.github.io/pyimagecuda/blend/) (Normal, Multiply, Screen, Add, Overlay, Soft Light, Hard Light, Mask)
+* [Resize](https://offerrall.github.io/pyimagecuda/resize/) (Nearest, Bilinear, Bicubic, Lanczos)
+* [Filter](https://offerrall.github.io/pyimagecuda/filter/) (Gaussian Blur, Sharpen, Sepia, Invert, Threshold, Solarize, Sobel, Emboss)
+* [Effect](https://offerrall.github.io/pyimagecuda/effect/) (Drop Shadow, Rounded Corners, Stroke, Vignette)
+* [Fill](https://offerrall.github.io/pyimagecuda/fill/) (Solid colors, Gradients, Checkerboard, Grid, Stripes, Dots, Circle, Ngon, Noise, Perlin)
+
+## Requirements
+
+* **OS:** Windows 10 or 11 (64-bit). *Linux support coming soon.*
+* **GPU:** NVIDIA GPU (Maxwell architecture / GTX 900 series or newer).
+* **Drivers:** Standard NVIDIA Drivers installed.
+
+**NOT REQUIRED:** Visual Studio, CUDA Toolkit, or Conda.
+
+## Contributing
+Contributions welcome! Open issues or submit PRs
+
+## License
+MIT License. See [LICENSE](LICENSE) for details.

pyimagecuda-0.0.4.dist-info/RECORD

@@ -0,0 +1,16 @@
+pyimagecuda/__init__.py,sha256=NUbXSns16c8fs0VqqeuMQ19zNMK9deU7Hd7eCZia1gA,2044
+pyimagecuda/adjust.py,sha256=d2R7LFKqGQVNFwq6KXToDuOfRafvx3qiAXCPKB_Sp7A,2908
+pyimagecuda/blend.py,sha256=EQgUz7dqfJbjUof1mMRy8OUX84D_eOuzh4n2y-comJY,8691
+pyimagecuda/effect.py,sha256=W861V0xkzIMuJk6rZxfRtlK_H78IIPIvxHaXRZ5qduQ,6199
+pyimagecuda/fill.py,sha256=7ybr-wkyr5_ziLL_6bvrLAW_Ixe1nMz36Lrj6jJAiOI,8934
+pyimagecuda/filter.py,sha256=puUsGBaaWhPnByHytqeaH5Uu1PPVBzhW-sQVQIxtq2Y,5615
+pyimagecuda/image.py,sha256=VRDHUOF2VClwdj3Q5YSQsmy9lpirwQvbC1P8avE3PdI,2864
+pyimagecuda/io.py,sha256=aee7rAeMesONzafQcF28QwQ9FqfKFSqAvEPN7zKY2i0,5182
+pyimagecuda/pyimagecuda_internal.cp312-win_amd64.pyd,sha256=zqfxoT2QjPIYvVTQnBqvM4AUSzUazi0FTdqpjsXdKRk,582656
+pyimagecuda/resize.py,sha256=-I4dqMu0-5OBHh_qMkBdOxrHXqfkrpvYaULsDOqproo,2934
+pyimagecuda/transform.py,sha256=n_fftpugw2SJscvwS4JzFjZ2m-lITAlHK0delnCScq8,6091
+pyimagecuda/utils.py,sha256=8IZ35y783AVJVuoQmcStPVAyx5WK_PDhkWqLo51PbTo,633
+pyimagecuda-0.0.4.dist-info/METADATA,sha256=sILv6k_PrXlJIFRexbNiNrniErLqBODvjm9nhSUieYg,4383
+pyimagecuda-0.0.4.dist-info/WHEEL,sha256=chqeLhPBtPdrOoreR34YMcofSk3yWDQhkrsDJ2n48LU,106
+pyimagecuda-0.0.4.dist-info/licenses/LICENSE,sha256=xfNh_pr4FPV8klv9rbs9GFflEfqf7vSFzcXK6BetRN0,1114
+pyimagecuda-0.0.4.dist-info/RECORD,,

pyimagecuda-0.0.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.11.6
+Root-Is-Purelib: false
+Tag: cp312-cp312-win_amd64
+

pyimagecuda-0.0.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2011-2025 The Bootstrap Authors
+
+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.