pyimagecuda 0.0.4__cp312-cp312-win_amd64.whl → 0.1.0__cp312-cp312-win_amd64.whl

pyimagecuda/io.py

@@ -1,9 +1,12 @@
 import pyvips
 
-from .pyimagecuda_internal import upload_to_buffer, convert_f32_to_u8, convert_u8_to_f32, download_from_buffer, copy_buffer  #type: ignore
+from .pyimagecuda_internal import upload_to_buffer, convert_f32_to_u8, convert_u8_to_f32, download_from_buffer, copy_buffer #type: ignore
 from .image import Image, ImageU8, ImageBase
-from .utils import ensure_capacity
 
+try:
+    import numpy as np
+except ImportError:
+    np = None
 
 def upload(image: ImageBase, data: bytes | bytearray | memoryview) -> None:
     """
@@ -36,7 +39,7 @@ def copy(dst: ImageBase, src: ImageBase) -> None:
 
     Docs & Examples: https://offerrall.github.io/pyimagecuda/io/#copy-between-buffers
     """
-    ensure_capacity(dst, src.width, src.height)
+    dst.resize(src.width, src.height)
     copy_buffer(dst._buffer._handle, src._buffer._handle, src.width, src.height)
 
 
@@ -46,7 +49,7 @@ def convert_float_to_u8(dst: ImageU8, src: Image) -> None:
 
     Docs & Examples: https://offerrall.github.io/pyimagecuda/io/#manual-conversions
     """
-    ensure_capacity(dst, src.width, src.height)
+    dst.resize(src.width, src.height)
     convert_f32_to_u8(dst._buffer._handle, src._buffer._handle, src.width, src.height)
 
 
@@ -56,7 +59,7 @@ def convert_u8_to_float(dst: Image, src: ImageU8) -> None:
 
     Docs & Examples: https://offerrall.github.io/pyimagecuda/io/#manual-conversions
     """
-    ensure_capacity(dst, src.width, src.height)
+    dst.resize(src.width, src.height)
     convert_u8_to_f32(dst._buffer._handle, src._buffer._handle, src.width, src.height)
 
 
@@ -94,14 +97,14 @@ def load(
         f32_buffer = Image(width, height)
         should_return = True
     else:
-        ensure_capacity(f32_buffer, width, height)
+        f32_buffer.resize(width, height)
         should_return = False
 
     if u8_buffer is None:
         u8_buffer = ImageU8(width, height)
         owns_u8 = True
     else:
-        ensure_capacity(u8_buffer, width, height)
+        u8_buffer.resize(width, height)
         owns_u8 = False
 
     vips_img = vips_img.cast('uchar')
@@ -117,26 +120,13 @@ def load(
     return f32_buffer if should_return else None
 
 
-def save(image: Image, filepath: str, u8_buffer: ImageU8 | None = None, quality: int | None = None) -> None:
-    """
-    Saves the floating-point image to a file (using an 8-bit buffer for conversion).
-
-    Docs & Examples: https://offerrall.github.io/pyimagecuda/io/#saving-images
-    """
-    if u8_buffer is None:
-        u8_buffer = ImageU8(image.width, image.height)
-        owns_buffer = True
-    else:
-        ensure_capacity(u8_buffer, image.width, image.height)
-        owns_buffer = False
-    
-    convert_float_to_u8(u8_buffer, image)
-    pixel_data = download(u8_buffer)
+def _save_internal(u8_image: ImageU8, filepath: str, quality: int | None = None) -> None:
+    pixel_data = download(u8_image)
     
     vips_img = pyvips.Image.new_from_memory(
         pixel_data,
-        image.width,
-        image.height,
+        u8_image.width,
+        u8_image.height,
         bands=4,
         format='uchar'
     )
@@ -153,6 +143,117 @@ def save(image: Image, filepath: str, u8_buffer: ImageU8 | None = None, quality:
             save_kwargs['Q'] = quality
     
     vips_img.write_to_file(filepath, **save_kwargs)
+
+
+def save(image: Image, filepath: str, u8_buffer: ImageU8 | None = None, quality: int | None = None) -> None:
+    """
+    Saves the floating-point image to a file (using an 8-bit buffer for conversion).
+
+    Docs & Examples: https://offerrall.github.io/pyimagecuda/io/#saving-images
+    """
+    if u8_buffer is None:
+        u8_buffer = ImageU8(image.width, image.height)
+        owns_buffer = True
+    else:
+        u8_buffer.resize(image.width, image.height)
+        owns_buffer = False
+    
+    convert_float_to_u8(u8_buffer, image)
+    _save_internal(u8_buffer, filepath, quality)
     
     if owns_buffer:
-        u8_buffer.free()
+        u8_buffer.free()
+
+
+def save_u8(image: ImageU8, filepath: str, quality: int | None = None) -> None:
+    """
+    Saves an 8-bit unsigned integer image directly to a file.
+
+    Docs & Examples: https://offerrall.github.io/pyimagecuda/io/#saving-images
+    """
+    _save_internal(image, filepath, quality)
+
+
+def from_numpy(array, f32_buffer: Image | None = None, u8_buffer: ImageU8 | None = None) -> Image:
+    """
+    Creates a PyImageCUDA Image from a NumPy array (e.g. from OpenCV, Pillow, Matplotlib).
+    
+    - Handles uint8 (0-255) -> float32 (0.0-1.0) conversion automatically on GPU.
+    - Handles Grayscale/RGB -> RGBA expansion automatically.
+    - Optimized: Uploads uint8 data (4x smaller) if possible, then converts on GPU.
+
+    Docs & Examples: https://offerrall.github.io/pyimagecuda/io/#numpy-integration
+    """
+    if np is None:
+        raise ImportError("NumPy is not installed. Run `pip install numpy` to use this feature.")
+
+    if not isinstance(array, np.ndarray):
+        raise TypeError(f"Expected numpy.ndarray, got {type(array)}")
+
+    target_dtype = array.dtype
+
+    if array.ndim == 2:
+        h, w = array.shape
+        alpha_val = 255 if target_dtype == np.uint8 else 1.0
+        alpha_channel = np.full((h, w), alpha_val, dtype=target_dtype)
+        array = np.dstack((array, array, array, alpha_channel))
+
+    elif array.ndim == 3:
+        h, w, c = array.shape
+        if c == 3:
+            alpha_val = 255 if target_dtype == np.uint8 else 1.0
+            alpha_channel = np.full((h, w), alpha_val, dtype=target_dtype)
+            array = np.dstack((array, alpha_channel))
+        elif c != 4:
+            raise ValueError(f"Unsupported channel count: {c}. PyImageCUDA requires 1, 3, or 4 channels.")
+    else:
+        raise ValueError(f"Unsupported array shape: {array.shape}. Expected (H, W), (H, W, 3) or (H, W, 4).")
+
+    if not array.flags['C_CONTIGUOUS']:
+        array = np.ascontiguousarray(array)
+
+    height, width = array.shape[:2]
+
+    should_return = False
+    if f32_buffer is None:
+        f32_buffer = Image(width, height)
+        should_return = True
+    else:
+        f32_buffer.resize(width, height)
+
+    if array.dtype == np.uint8:
+        owns_u8 = False
+        if u8_buffer is None:
+            u8_buffer = ImageU8(width, height)
+            owns_u8 = True
+        else:
+            u8_buffer.resize(width, height)
+
+        upload(u8_buffer, array.tobytes())
+        convert_u8_to_float(f32_buffer, u8_buffer)
+        
+        if owns_u8:
+            u8_buffer.free()
+
+    elif array.dtype == np.float32:
+        upload(f32_buffer, array.tobytes())
+    else:
+        array = array.astype(np.float32)
+        upload(f32_buffer, array.tobytes())
+
+    return f32_buffer if should_return else None
+
+
+def to_numpy(image: Image) -> 'np.ndarray': # type: ignore
+    """
+    Downloads a PyImageCUDA Image to a NumPy array.
+    
+    Docs & Examples: https://offerrall.github.io/pyimagecuda/io/#numpy-integration
+    """
+    if np is None:
+        raise ImportError("NumPy is not installed. Run `pip install numpy` to use this feature.")
+    
+    raw_bytes = download(image)
+    array = np.frombuffer(raw_bytes, dtype=np.float32)
+    
+    return array.reshape((image.height, image.width, 4))

pyimagecuda/resize.py

@@ -1,6 +1,6 @@
 from .image import Image
-from .utils import ensure_capacity
-from .pyimagecuda_internal import resize_f32  #type: ignore
+from .pyimagecuda_internal import resize_f32 #type: ignore
+from .io import copy
 
 
 def _resize_internal(
@@ -18,11 +18,22 @@ def _resize_internal(
     elif height is None:
         height = int(src.height * (width / src.width))
     
+    # No resize needed, just copy
+    if width == src.width and height == src.height:
+        if dst_buffer is None:
+            dst_buffer = Image(width, height)
+            copy(dst_buffer, src)
+            return dst_buffer
+        else:
+            copy(dst_buffer, src)
+            return None
+    
+    # Resize normal
     if dst_buffer is None:
         dst_buffer = Image(width, height)
         return_buffer = True
     else:
-        ensure_capacity(dst_buffer, width, height)
+        dst_buffer.resize(width, height)
         return_buffer = False
     
     resize_f32(

pyimagecuda/text.py

@@ -0,0 +1,106 @@
+from typing import Literal
+import pyvips
+
+from .image import Image, ImageU8
+from .io import upload, convert_u8_to_float
+
+class Text:
+    @staticmethod
+    def create(
+        text: str,
+        font: str = "Sans",
+        size: float = 12.0,
+        color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 1.0),
+        bg_color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+        align: Literal['left', 'centre', 'right'] = 'left',
+        justify: bool = False,
+        spacing: int = 0,
+        letter_spacing: float = 0.0,
+        dst_buffer: Image | None = None,
+        u8_buffer: ImageU8 | None = None
+    ) -> Image | None:
+        """
+        Renders text into an image with specified font, size, color, alignment, and spacing.
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/text/#text-rendering
+        """
+        full_font_string = f"{font} {size}"
+        
+        text_opts = {
+            'font': full_font_string,
+            'dpi': 72,
+            'align': 0 if align == 'left' else (1 if align == 'centre' else 2),
+            'justify': justify,
+            'spacing': spacing
+        }
+        
+        final_text = text
+        if letter_spacing != 0:
+            pango_spacing = int(letter_spacing * 1024)
+            final_text = f'<span letter_spacing="{pango_spacing}">{text}</span>'
+            text_opts['rgba'] = True
+        
+        if '<' in text and '>' in text:
+             text_opts['rgba'] = True
+
+        try:
+            if text_opts.get('rgba'):
+                mask_rgba = pyvips.Image.text(final_text, **text_opts)
+                if mask_rgba.bands == 4:
+                    mask = mask_rgba[3]
+                else:
+                    mask = mask_rgba.colourspace('b-w')[0]
+            else:
+                mask = pyvips.Image.text(final_text, **text_opts)
+                
+        except pyvips.Error as e:
+            raise RuntimeError(f"Failed to render text: {e}")
+
+        fg_r, fg_g, fg_b, fg_a = [int(c * 255) for c in color]
+        bg_r, bg_g, bg_b, bg_a = [int(c * 255) for c in bg_color]
+
+        fg_rgb = mask.new_from_image([fg_r, fg_g, fg_b])
+        
+        if fg_a < 255:
+            fg_alpha = (mask * (fg_a / 255.0)).cast('uchar')
+        else:
+            fg_alpha = mask
+
+        fg_layer = fg_rgb.bandjoin(fg_alpha)
+        fg_layer = fg_layer.copy(interpretation='srgb')
+
+        if bg_a > 0:
+            bg_layer = mask.new_from_image([bg_r, bg_g, bg_b, bg_a])
+            bg_layer = bg_layer.copy(interpretation='srgb')
+            final_vips = bg_layer.composite(fg_layer, 'over')
+        else:
+            final_vips = fg_layer
+
+        final_vips = final_vips.cast('uchar')
+
+        w, h = final_vips.width, final_vips.height
+        raw_bytes = final_vips.write_to_memory()
+
+        if dst_buffer is None:
+            result = Image(w, h)
+            return_result = True
+        else:
+            dst_buffer.resize(w, h)
+            result = dst_buffer
+            return_result = False
+
+        if u8_buffer is None:
+            u8_temp = ImageU8(w, h)
+            free_u8 = True
+        else:
+            u8_buffer.resize(w, h)
+            u8_temp = u8_buffer
+            free_u8 = False
+        
+        upload(u8_temp, raw_bytes)
+        convert_u8_to_float(result, u8_temp)
+        
+        if free_u8:
+            u8_temp.free()
+
+        return result if return_result else None

pyimagecuda/transform.py

@@ -1,11 +1,11 @@
 import math
 from typing import Literal
 from .image import Image
-from .utils import ensure_capacity
 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 
+    rotate_arbitrary_f32, copy_buffer, zoom_f32
 )
 
 
@@ -37,7 +37,7 @@ class Transform:
             dst_buffer = Image(image.width, image.height)
             return_buffer = True
         else:
-            ensure_capacity(dst_buffer, image.width, image.height)
+            dst_buffer.resize(image.width, image.height)
             return_buffer = False
             
         flip_f32(
@@ -55,6 +55,7 @@ class Transform:
         image: Image,
         angle: float,
         expand: bool = True,
+        interpolation: Literal['nearest', 'bilinear', 'bicubic', 'lanczos'] = 'bilinear',
         dst_buffer: Image | None = None
     ) -> Image | None:
         """
@@ -63,8 +64,20 @@ class Transform:
         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
+        if norm_angle < 0:
+            norm_angle += 360
         
         is_fixed = False
         fixed_mode = 0
@@ -74,21 +87,29 @@ class Transform:
                 dst_buffer = Image(image.width, image.height)
                 return_buffer = True
             else:
-                ensure_capacity(dst_buffer, image.width, image.height)
+                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
+        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
+                rot_w = image.width
+                rot_h = image.height
             else: 
-                rot_w, rot_h = image.height, image.width
+                rot_w = image.height
+                rot_h = image.width
         else:
             rads = math.radians(angle)
             sin_a = abs(math.sin(rads))
@@ -111,7 +132,7 @@ class Transform:
             dst_buffer = Image(final_w, final_h)
             return_buffer = True
         else:
-            ensure_capacity(dst_buffer, final_w, final_h)
+            dst_buffer.resize(final_w, final_h)
             return_buffer = False
 
         if is_fixed:
@@ -128,7 +149,8 @@ class Transform:
                 dst_buffer._buffer._handle,
                 image.width, image.height,
                 final_w, final_h,
-                float(angle)
+                float(angle),
+                interp_method
             )
         
         return dst_buffer if return_buffer else None
@@ -150,11 +172,20 @@ class Transform:
         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:
-            ensure_capacity(dst_buffer, width, height)
+            dst_buffer.resize(width, height)
             return_buffer = False
 
         Fill.color(dst_buffer, (0.0, 0.0, 0.0, 0.0))
@@ -163,7 +194,8 @@ class Transform:
         crop_top = y
         crop_right = x + width
         crop_bottom = y + height
-        img_right, img_bottom = image.width, image.height
+        img_right = image.width
+        img_bottom = image.height
         
         intersect_left = max(crop_left, 0)
         intersect_top = max(crop_top, 0)
@@ -183,4 +215,61 @@ class Transform:
                 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.0.4.dist-info → pyimagecuda-0.1.0.dist-info}/METADATA

@@ -1,21 +1,24 @@
 Metadata-Version: 2.2
 Name: pyimagecuda
-Version: 0.0.4
+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.0.4
+# 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 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.
+> 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
 
@@ -40,10 +43,11 @@ with Image(1024, 1024) as bg:
 
 ## Key Features
 
-* ✅ **Zero Dependencies:** No CUDA Toolkit, Visual Studio, or complex compilers needed. Is Plug & Play.
-* ✅ **Ultra-lightweight:** library weighs **<0.5 MB**.
+* ✅ **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
@@ -51,43 +55,94 @@ with Image(1024, 1024) as bg:
 * **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:** Automatically installs `pyvips` binary dependencies for robust image format support (JPG, PNG, WEBP, HEIC).
+**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
 
-**⚠️ 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)
+* [OpenGL Integration](https://offerrall.github.io/pyimagecuda/opengl/) (Real-time preview, zero-copy display)
 
 ### Operations
-* [Adjust](https://offerrall.github.io/pyimagecuda/adjust/) (Brightness, Contrast, Saturation, Gamma, Opacity)
-* [Transform](https://offerrall.github.io/pyimagecuda/transform/) (Flip, Rotate, Crop)
+* [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)
-* [Fill](https://offerrall.github.io/pyimagecuda/fill/) (Solid colors, Gradients, Checkerboard, Grid, Stripes, Dots, Circle, Ngon, Noise, Perlin)
+
+## 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 support coming soon.*
+* **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