pyimagecuda 0.1.0__cp311-cp311-win_amd64.whl

pyimagecuda/transform.py

@@ -0,0 +1,275 @@
+import math
+from typing import Literal
+from .image import Image
+from .fill import Fill
+from .io import copy
+from .pyimagecuda_internal import ( #type: ignore
+    flip_f32, crop_f32, rotate_fixed_f32, 
+    rotate_arbitrary_f32, copy_buffer, zoom_f32
+)
+
+
+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:
+            dst_buffer.resize(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,
+        interpolation: Literal['nearest', 'bilinear', 'bicubic', 'lanczos'] = 'bilinear',
+        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
+        """
+        
+        interp_map = {
+            'nearest': 0,
+            'bilinear': 1,
+            'bicubic': 2,
+            'lanczos': 3
+        }
+        
+        interp_method = interp_map.get(interpolation)
+        if interp_method is None:
+            raise ValueError(f"Invalid interpolation: {interpolation}. Must be {list(interp_map.keys())}")
+        
+        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:
+                dst_buffer.resize(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 = image.width
+                rot_h = image.height
+            else: 
+                rot_w = image.height
+                rot_h = 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:
+            dst_buffer.resize(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),
+                interp_method
+            )
+        
+        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 x == 0 and y == 0 and width == image.width and height == image.height:
+            if dst_buffer is None:
+                dst_buffer = Image(width, height)
+                copy(dst_buffer, image)
+                return dst_buffer
+            else:
+                copy(dst_buffer, image)
+                return None
+
+        if dst_buffer is None:
+            dst_buffer = Image(width, height)
+            return_buffer = True
+        else:
+            dst_buffer.resize(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 = image.width
+        img_bottom = 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
+
+    @staticmethod
+    def zoom(
+        image: Image,
+        zoom_factor: float = 2.0,
+        center_x: float | None = None,
+        center_y: float | None = None,
+        interpolation: Literal['nearest', 'bilinear', 'bicubic', 'lanczos'] = 'bilinear',
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        """
+        Zoom into an image by a specified factor, centered at (center_x, center_y).
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/transform/#zoom
+        """
+        if zoom_factor <= 0:
+            raise ValueError("Zoom factor must be positive")
+        
+        if center_x is None:
+            center_x = image.width / 2.0
+        if center_y is None:
+            center_y = image.height / 2.0
+        
+        center_x = max(0.0, min(float(image.width - 1), float(center_x)))
+        center_y = max(0.0, min(float(image.height - 1), float(center_y)))
+        
+        interp_map = {
+            'nearest': 0,
+            'bilinear': 1,
+            'bicubic': 2,
+            'lanczos': 3
+        }
+        
+        interp_method = interp_map.get(interpolation)
+        if interp_method is None:
+            raise ValueError(f"Invalid interpolation: {interpolation}. Must be {list(interp_map.keys())}")
+        
+        if dst_buffer is None:
+            dst_buffer = Image(image.width, image.height)
+            return_buffer = True
+        else:
+            return_buffer = False
+        
+        zoom_f32(
+            image._buffer._handle,
+            dst_buffer._buffer._handle,
+            image.width,
+            image.height,
+            dst_buffer.width,
+            dst_buffer.height,
+            float(zoom_factor),
+            float(center_x),
+            float(center_y),
+            interp_method
+        )
+        
+        return dst_buffer if return_buffer else None

pyimagecuda-0.1.0.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.2
+Name: pyimagecuda
+Version: 0.1.0
+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.1.0
+
+[![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)
+![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux-brightgreen)
+![Tests](https://img.shields.io/badge/tests-85%20passed-brightgreen)
+[![NVIDIA](https://img.shields.io/badge/NVIDIA-CUDA-76B900?style=flat&logo=nvidia&logoColor=white)](https://developer.nvidia.com/cuda-zone)
+
+**GPU-accelerated image compositing for Python.**
+
+> PyImageCUDA is built for image composition, not computer vision. It provides GPU tools to create, modify, and blend images, rather than analyze or recognize objects within them.
+
+## 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 on both Windows and Linux.
+* ✅ **Ultra-lightweight:** library weighs **~1 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.
+* ✅ **OpenGL Integration:** Direct GPU-to-GPU display for real-time preview widgets.
+* ✅ **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.
+* **Node Editors & Real-time Tools:** Build responsive image editors with instant preview.
+* **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.
+
+## PyImageCUDA Ecosystem
+
+This library is the foundation. For visual workflows:
+
+**[PyImageCUDA Studio](https://github.com/offerrall/pyimagecuda-studio)**
+- Node-based image compositor with real-time preview
+- Design templates visually, automate with Python
+- 40+ nodes: generators, effects, filters, transforms
+- Headless batch processing API
+```bash
+pip install pyimagecuda-studio
+```
+
+---
+
+## Installation
+
+## Installation
+```bash
+pip install pyimagecuda
+```
+
+**Note:** `pyvips` is the only mandatory dependency (installed automatically). It is used strictly for robust file I/O (JPG, PNG, WEBP...) and high-quality Text rendering on the CPU.
+
+## Documentation
+
+### 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)
+* [OpenGL Integration](https://offerrall.github.io/pyimagecuda/opengl/) (Real-time preview, zero-copy display)
+
+### Operations
+* [Fill](https://offerrall.github.io/pyimagecuda/fill/) (Solid colors, Gradients, Checkerboard, Grid, Stripes, Dots, Circle, Ngon, Noise, Perlin)
+* [Text](https://offerrall.github.io/pyimagecuda/text/) (Rich typography, system fonts, HTML-like markup, letter spacing...)
+* [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)
+* [Adjust](https://offerrall.github.io/pyimagecuda/adjust/) (Brightness, Contrast, Saturation, Gamma, Opacity)
+* [Transform](https://offerrall.github.io/pyimagecuda/transform/) (Flip, Rotate, Crop, Zoom)
+* [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)
+
+## Performance
+
+PyImageCUDA shows significant speedups for GPU-friendly operations like blending, filtering, and transformations. Performance varies by operation complexity and workflow:
+
+- Complex operations (blur, blend, rotate) see **10-260x improvements**
+- Simple operations (flip, crop) see **3-20x improvements**  
+- Real-world pipelines with file I/O typically see **1.5-2.5x speedups**
+
+Results depend on your hardware, batch size, and whether you reuse GPU buffers.
+
+**[→ View Detailed Benchmarks](https://offerrall.github.io/pyimagecuda/benchmarks/)**
+
+## Requirements
+
+* **OS:** 
+    - Windows 10 or 11 (64-bit).
+    - Linux: Any modern distribution (Ubuntu, Fedora, Debian, Arch, WSL2, etc.).
+* **GPU:** NVIDIA GPU (Maxwell architecture / GTX 900 series or newer).
+* **Drivers:** Standard NVIDIA Drivers installed.
+
+**NOT REQUIRED:** Visual Studio, CUDA Toolkit, or Conda.
+
+## Linux Compatibility & Troubleshooting
+
+PyImageCUDA is currently tested primarily on **Ubuntu LTS** releases with up-to-date NVIDIA drivers.
+
+If you encounter the following error on Linux:
+
+```text
+RuntimeError: Kernel launch failed: the provided PTX was compiled with an unsupported toolchain.
+```
+
+Solution: This indicates your installed NVIDIA drivers are too old to execute the kernels included in the library. Please update your NVIDIA drivers to the latest version available for your distribution (Proprietary drivers recommended).
+
+We are actively investigating ways to broaden compatibility for older drivers and legacy Linux distributions in future releases.
+
+## Tests
+```bash
+pytest tests/tests.py
+```
+
+## Contributing
+Contributions welcome! Open issues or submit PRs
+
+## License
+MIT License. See [LICENSE](LICENSE) for details.

pyimagecuda-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+pyimagecuda/__init__.py,sha256=A94o-xcZCZAKunZEK_z8pXSlwsNuLX00AcLBOrcAsZM,2219
+pyimagecuda/adjust.py,sha256=xGSgifVWaFkaXyL718PUcYqwtZJAlnvMHNLQHiUS40M,3231
+pyimagecuda/blend.py,sha256=sPupoAh9Mnz16dAsv6C3ynZvDHmV-0MR-A32KpEcE6Q,9132
+pyimagecuda/effect.py,sha256=XTt7q7xr9T6TMqGkF00G8PgO04f70MMQuMxCl2hB2yM,6812
+pyimagecuda/fill.py,sha256=7ybr-wkyr5_ziLL_6bvrLAW_Ixe1nMz36Lrj6jJAiOI,8934
+pyimagecuda/filter.py,sha256=wOGh791djvkzPiwAz3kUABldaPOWVEO6Rqetgkw--N0,6306
+pyimagecuda/gl_interop.py,sha256=x3P9MbjOSgwEMIdhkTE4lshAjn7YqXBM0JsKv2NsFUI,2654
+pyimagecuda/image.py,sha256=UJaaxWctNSZ1lX45vzDhLXHjbhBlSPT54bB4MLyH3JE,3958
+pyimagecuda/io.py,sha256=d8ODBO50bx43yNYUH5IjXxvrDW991W5-qJ2ex8DlNok,8616
+pyimagecuda/pyimagecuda_internal.cp311-win_amd64.pyd,sha256=XW2cG1iUYGXUQkrs2I1zFkGTcPOD87NyK46pF8vdqMw,1309184
+pyimagecuda/resize.py,sha256=iw3wRiOfQYHJygkbUvDEiC-gtnX9gX6gpXAsAdjduOc,3244
+pyimagecuda/text.py,sha256=QTiecJkpLb7RyIpl8D7aEj3yGaLWW4uQ-J82UKBMCjY,3502
+pyimagecuda/transform.py,sha256=fp5_9tlA5TKZWSroViyK48u9yNGDr0ujBLyXckqgvRk,8902
+pyimagecuda-0.1.0.dist-info/METADATA,sha256=2ojkw061PrlE6lY-4Ji2dxoSZP1_ZaIRbt-rzUiNBIY,6737
+pyimagecuda-0.1.0.dist-info/WHEEL,sha256=oXhHG6ewLm-FNdEna2zwgy-K0KEl4claZ1ztR4VTx0I,106
+pyimagecuda-0.1.0.dist-info/licenses/LICENSE,sha256=xfNh_pr4FPV8klv9rbs9GFflEfqf7vSFzcXK6BetRN0,1114
+pyimagecuda-0.1.0.dist-info/RECORD,,

pyimagecuda-0.1.0.dist-info/WHEEL

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

pyimagecuda-0.1.0.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.