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

pyimagecuda/__init__.py

@@ -1,7 +1,7 @@
 import ctypes
 import sys
 
-__version__ = "0.0.4"
+__version__ = "0.1.0"
 
 def _check_nvidia_driver():
     try:
@@ -37,7 +37,7 @@ except ImportError as e:
 if _INTERNAL_LOADED:
     try:
         from .image import Image, ImageU8
-        from .io import upload, download, copy, save, load, convert_float_to_u8, convert_u8_to_float
+        from .io import upload, download, copy, save, load, convert_float_to_u8, convert_u8_to_float, from_numpy, to_numpy, save_u8
         from .fill import Fill
         from .resize import Resize
         from .blend import Blend
@@ -45,6 +45,9 @@ if _INTERNAL_LOADED:
         from .effect import Effect
         from .adjust import Adjust
         from .transform import Transform
+        from .text import Text
+        from .gl_interop import GLResource
+        from .pyimagecuda_internal import cuda_sync # type: ignore
     except ImportError as e:
         print(f"Warning: Error importing Python wrappers: {e}")
 

pyimagecuda/adjust.py

@@ -19,6 +19,9 @@ class Adjust:
         
         Docs & Examples: https://offerrall.github.io/pyimagecuda/adjust/#brightness
         """
+        if abs(factor) < 1e-6:
+            return
+        
         adjust_brightness_f32(
             image._buffer._handle,
             image.width,
@@ -36,6 +39,9 @@ class Adjust:
         
         Docs & Examples: https://offerrall.github.io/pyimagecuda/adjust/#contrast
         """
+        if abs(factor - 1.0) < 1e-6:
+            return
+        
         adjust_contrast_f32(
             image._buffer._handle,
             image.width,
@@ -54,6 +60,9 @@ class Adjust:
         
         Docs & Examples: https://offerrall.github.io/pyimagecuda/adjust/#saturation
         """
+        if abs(factor - 1.0) < 1e-6:
+            return
+        
         adjust_saturation_f32(
             image._buffer._handle,
             image.width,
@@ -75,6 +84,9 @@ class Adjust:
         """
         if gamma <= 0:
             raise ValueError("Gamma must be positive")
+        
+        if abs(gamma - 1.0) < 1e-6:
+            return
             
         adjust_gamma_f32(
             image._buffer._handle,
@@ -92,6 +104,8 @@ class Adjust:
 
         Docs & Examples: https://offerrall.github.io/pyimagecuda/adjust/#opacity
         """
+        if abs(factor - 1.0) < 1e-6:
+            return
 
         adjust_opacity_f32(
             image._buffer._handle,

pyimagecuda/blend.py

@@ -45,6 +45,9 @@ class Blend:
 
         Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#normal
         """
+        if abs(opacity) < 1e-6:
+            return
+        
         pos_x, pos_y = _calculate_position(
             base.width, base.height,
             overlay.width, overlay.height,
@@ -75,6 +78,9 @@ class Blend:
 
         Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#multiply
         """
+        if abs(opacity) < 1e-6:
+            return
+        
         pos_x, pos_y = _calculate_position(
             base.width, base.height,
             overlay.width, overlay.height,
@@ -105,6 +111,9 @@ class Blend:
 
         Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#screen
         """
+        if abs(opacity) < 1e-6:
+            return
+        
         pos_x, pos_y = _calculate_position(
             base.width, base.height,
             overlay.width, overlay.height,
@@ -135,6 +144,9 @@ class Blend:
 
         Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#add
         """
+        if abs(opacity) < 1e-6:
+            return
+        
         pos_x, pos_y = _calculate_position(
             base.width, base.height,
             overlay.width, overlay.height,
@@ -165,6 +177,9 @@ class Blend:
         
         Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#overlay
         """
+        if abs(opacity) < 1e-6:
+            return
+        
         pos_x, pos_y = _calculate_position(
             base.width, base.height,
             overlay.width, overlay.height,
@@ -195,6 +210,9 @@ class Blend:
         
         Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#soft-light
         """
+        if abs(opacity) < 1e-6:
+            return
+        
         pos_x, pos_y = _calculate_position(
             base.width, base.height,
             overlay.width, overlay.height,
@@ -225,6 +243,9 @@ class Blend:
         
         Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#hard-light
         """
+        if abs(opacity) < 1e-6:
+            return
+        
         pos_x, pos_y = _calculate_position(
             base.width, base.height,
             overlay.width, overlay.height,

pyimagecuda/effect.py

@@ -4,7 +4,6 @@ from .image import Image
 from .filter import Filter
 from .blend import Blend
 from .fill import Fill
-from .utils import ensure_capacity
 from .pyimagecuda_internal import ( #type: ignore
     rounded_corners_f32,
     extract_alpha_f32,
@@ -25,14 +24,19 @@ class Effect:
         Docs & Examples: https://offerrall.github.io/pyimagecuda/effect/#rounded_corners
         """
         max_radius = min(image.width, image.height) / 2.0
-        if radius < 0: raise ValueError("Radius must be non-negative")
-        if radius > max_radius: radius = max_radius
+        if radius < 0:
+            raise ValueError("Radius must be non-negative")
+        if radius == 0:
+            return
+        if radius > max_radius:
+            radius = max_radius
         
         rounded_corners_f32(image._buffer._handle, image.width, image.height, float(radius))
 
     @staticmethod
     def drop_shadow(
-        image: Image, offset_x: int = 10,
+        image: Image,
+        offset_x: int = 10,
         offset_y: int = 10,
         blur: int = 20,
         color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.5),
@@ -51,30 +55,46 @@ class Effect:
             pad_r = blur + max(0, offset_x)
             pad_t = blur + max(0, -offset_y)
             pad_b = blur + max(0, offset_y)
-            res_w, res_h = image.width + pad_l + pad_r, image.height + pad_t + pad_b
-            img_x, img_y = pad_l, pad_t
+            res_w = image.width + pad_l + pad_r
+            res_h = image.height + pad_t + pad_b
+            img_x = pad_l
+            img_y = pad_t
         else:
-            res_w, res_h = image.width, image.height
-            img_x, img_y = 0, 0
+            res_w = image.width
+            res_h = image.height
+            img_x = 0
+            img_y = 0
             
         if dst_buffer is None:
-            result = Image(res_w, res_h); ret = True
+            result = Image(res_w, res_h)
+            ret = True
         else:
-            ensure_capacity(dst_buffer, res_w, res_h); result = dst_buffer; ret = False
+            dst_buffer.resize(res_w, res_h)
+            result = dst_buffer
+            ret = False
 
         if shadow_buffer is None:
-            shadow = Image(res_w, res_h); own_shadow = True
+            shadow = Image(res_w, res_h)
+            own_shadow = True
         else:
-            ensure_capacity(shadow_buffer, res_w, res_h); shadow = shadow_buffer; own_shadow = False
+            shadow_buffer.resize(res_w, res_h)
+            shadow = shadow_buffer
+            own_shadow = False
 
         if expand:
-            if temp_buffer is None: temp = Image(res_w, res_h)
-            else: ensure_capacity(temp_buffer, res_w, res_h); temp = temp_buffer
-            Fill.color(shadow, (0,0,0,0))
-            temp.width, temp.height = image.width, image.height
+            if temp_buffer is None:
+                temp = Image(res_w, res_h)
+            else:
+                temp_buffer.resize(res_w, res_h)
+                temp = temp_buffer
+            
+            Fill.color(shadow, (0, 0, 0, 0))
+            temp.resize(image.width, image.height)
             extract_alpha_f32(image._buffer._handle, temp._buffer._handle, image.width, image.height)
             Blend.normal(shadow, temp, anchor='top-left', offset_x=pad_l, offset_y=pad_t)
-            if temp_buffer is None: temp.free()
+            
+            if temp_buffer is None:
+                temp.free()
         else:
             extract_alpha_f32(image._buffer._handle, shadow._buffer._handle, image.width, image.height)
         
@@ -82,11 +102,13 @@ class Effect:
             Filter.gaussian_blur(shadow, radius=blur, sigma=blur/3.0, dst_buffer=shadow)
         
         colorize_alpha_mask_f32(shadow._buffer._handle, shadow.width, shadow.height, color)
-        Fill.color(result, (0,0,0,0))
+        Fill.color(result, (0, 0, 0, 0))
         Blend.normal(result, shadow, anchor='top-left', offset_x=offset_x, offset_y=offset_y)
         Blend.normal(result, image, anchor='top-left', offset_x=img_x, offset_y=img_y)
         
-        if own_shadow: shadow.free()
+        if own_shadow:
+            shadow.free()
+        
         return result if ret else None
 
     @staticmethod
@@ -104,38 +126,66 @@ class Effect:
 
         Docs & Examples: https://offerrall.github.io/pyimagecuda/effect/#stroke
         """
-        if width < 1 or width > 1000: raise ValueError("Invalid stroke width")
-        if position not in ('outside', 'inside'): raise ValueError("Invalid position")
+        if width < 1 or width > 1000:
+            raise ValueError("Invalid stroke width")
+        if position not in ('outside', 'inside'):
+            raise ValueError("Invalid position")
 
         if position == 'outside' and expand:
-            res_w, res_h = image.width + width * 2, image.height + width * 2
-            off_x, off_y = width, width
+            res_w = image.width + width * 2
+            res_h = image.height + width * 2
+            off_x = width
+            off_y = width
         else:
-            res_w, res_h = image.width, image.height
-            off_x, off_y = 0, 0
+            res_w = image.width
+            res_h = image.height
+            off_x = 0
+            off_y = 0
         
         if dst_buffer is None:
-            result = Image(res_w, res_h); ret = True
+            result = Image(res_w, res_h)
+            ret = True
         else:
-            ensure_capacity(dst_buffer, res_w, res_h); result = dst_buffer; ret = False
+            dst_buffer.resize(res_w, res_h)
+            result = dst_buffer
+            ret = False
         
         if distance_buffer is None:
-            distance = Image(res_w, res_h); own_dist = True
+            distance = Image(res_w, res_h)
+            own_dist = True
         else:
-            ensure_capacity(distance_buffer, res_w, res_h); distance = distance_buffer; own_dist = False
+            distance_buffer.resize(res_w, res_h)
+            distance = distance_buffer
+            own_dist = False
 
         compute_distance_field_f32(
-            image._buffer._handle, distance._buffer._handle,
-            image.width, image.height, res_w, res_h, off_x, off_y
+            image._buffer._handle,
+            distance._buffer._handle,
+            image.width,
+            image.height,
+            res_w,
+            res_h,
+            off_x,
+            off_y
         )
 
         generate_stroke_composite_f32(
-            image._buffer._handle, distance._buffer._handle, result._buffer._handle,
-            image.width, image.height, res_w, res_h, off_x, off_y,
-            float(width), color, 0 if position == 'outside' else 1
+            image._buffer._handle,
+            distance._buffer._handle,
+            result._buffer._handle,
+            image.width,
+            image.height,
+            res_w,
+            res_h,
+            off_x,
+            off_y,
+            float(width),
+            color,
+            0 if position == 'outside' else 1
         )
         
-        if own_dist: distance.free()
+        if own_dist:
+            distance.free()
         
         return result if ret else None
 
@@ -151,8 +201,10 @@ class Effect:
         
         Docs & Examples: https://offerrall.github.io/pyimagecuda/effect/#vignette
         """
-        if radius < 0: radius = 0.0
-        if softness < 0: softness = 0.0
+        if radius < 0:
+            radius = 0.0
+        if softness < 0:
+            softness = 0.0
         
         effect_vignette_f32(
             image._buffer._handle,

pyimagecuda/filter.py

@@ -1,13 +1,15 @@
 from .image import Image
-from .utils import ensure_capacity
-from .pyimagecuda_internal import (gaussian_blur_separable_f32, #type: ignore
-                                   sharpen_f32,
-                                   sepia_f32,
-                                   invert_f32,
-                                   threshold_f32,
-                                   solarize_f32,
-                                   filter_sobel_f32,
-                                   filter_emboss_f32)
+from .io import copy
+from .pyimagecuda_internal import ( #type: ignore
+    gaussian_blur_separable_f32,
+    sharpen_f32,
+    sepia_f32,
+    invert_f32,
+    threshold_f32,
+    solarize_f32,
+    filter_sobel_f32,
+    filter_emboss_f32
+)
 
 
 class Filter:
@@ -26,6 +28,15 @@ class Filter:
         Docs & Examples: https://offerrall.github.io/pyimagecuda/filter/#gaussian-blur
         """
 
+        if radius == 0 or (sigma is not None and sigma <= 0.001):
+            if dst_buffer is None:
+                dst_buffer = Image(src.width, src.height)
+                copy(dst_buffer, src)
+                return dst_buffer
+            else:
+                copy(dst_buffer, src)
+                return None
+
         if sigma is None:
             sigma = radius / 3.0
         
@@ -33,14 +44,14 @@ class Filter:
             dst_buffer = Image(src.width, src.height)
             return_dst = True
         else:
-            ensure_capacity(dst_buffer, src.width, src.height)
+            dst_buffer.resize(src.width, src.height)
             return_dst = False
 
         if temp_buffer is None:
             temp_buffer = Image(src.width, src.height)
             owns_temp = True
         else:
-            ensure_capacity(temp_buffer, src.width, src.height)
+            temp_buffer.resize(src.width, src.height)
             owns_temp = False
 
         gaussian_blur_separable_f32(
@@ -70,11 +81,20 @@ class Filter:
         Docs & Examples: https://offerrall.github.io/pyimagecuda/filter/#sharpen
         """
 
+        if abs(strength) < 1e-6:
+            if dst_buffer is None:
+                dst_buffer = Image(src.width, src.height)
+                copy(dst_buffer, src)
+                return dst_buffer
+            else:
+                copy(dst_buffer, src)
+                return None
+
         if dst_buffer is None:
             dst_buffer = Image(src.width, src.height)
             return_buffer = True
         else:
-            ensure_capacity(dst_buffer, src.width, src.height)
+            dst_buffer.resize(src.width, src.height)
             return_buffer = False
         
         sharpen_f32(
@@ -94,6 +114,8 @@ class Filter:
         
         Docs & Examples: https://offerrall.github.io/pyimagecuda/filter/#sepia
         """
+        if abs(intensity) < 1e-6:
+            return
         
         sepia_f32(image._buffer._handle, image.width, image.height, float(intensity))
 
@@ -136,7 +158,7 @@ class Filter:
             dst_buffer = Image(src.width, src.height)
             return_buffer = True
         else:
-            ensure_capacity(dst_buffer, src.width, src.height)
+            dst_buffer.resize(src.width, src.height)
             return_buffer = False
 
         filter_sobel_f32(
@@ -153,11 +175,20 @@ class Filter:
 
         Docs & Examples: https://offerrall.github.io/pyimagecuda/filter/#emboss
         """
+        if abs(strength) < 1e-6:
+            if dst_buffer is None:
+                dst_buffer = Image(src.width, src.height)
+                copy(dst_buffer, src)
+                return dst_buffer
+            else:
+                copy(dst_buffer, src)
+                return None
+
         if dst_buffer is None:
             dst_buffer = Image(src.width, src.height)
             return_buffer = True
         else:
-            ensure_capacity(dst_buffer, src.width, src.height)
+            dst_buffer.resize(src.width, src.height)
             return_buffer = False
         
         filter_emboss_f32(

pyimagecuda/gl_interop.py

@@ -0,0 +1,84 @@
+from .pyimagecuda_internal import (  # type: ignore
+    register_gl_pbo,
+    unregister_gl_resource,
+    copy_to_gl_pbo
+)
+from .image import ImageU8
+
+
+class GLResource:
+    """
+    CUDA-OpenGL interop resource for direct GPU-to-GPU transfers.
+    
+    Represents a registered OpenGL PBO that can receive ImageU8 data
+    directly without CPU roundtrips.
+    
+    Docs & Examples: https://offerrall.github.io/pyimagecuda/opengl/
+    """
+    
+    def __init__(self, pbo_id: int):
+        """
+        Parameters:
+            pbo_id: Valid OpenGL PBO ID. The PBO must exist and remain 
+                    valid for the lifetime of this GLResource.
+        
+        Raises:
+            ValueError: If pbo_id is invalid
+            RuntimeError: If CUDA registration fails
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/opengl/
+        """
+        if not isinstance(pbo_id, int) or pbo_id <= 0:
+            raise ValueError(f"Invalid PBO ID: {pbo_id}")
+        
+        self._handle = None
+        self.pbo_id = pbo_id
+        self._handle = register_gl_pbo(pbo_id)
+    
+    def copy_from(self, image: ImageU8, sync: bool = True) -> None:
+        """
+        Copies ImageU8 data directly to the registered PBO (GPU→GPU).
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/opengl/
+        """
+        if not isinstance(image, ImageU8):
+            raise TypeError(f"Expected ImageU8, got {type(image).__name__}")
+        
+        if self._handle is None:
+            raise RuntimeError("GLResource has been freed")
+        
+        copy_to_gl_pbo(
+            image._buffer._handle,
+            self._handle,
+            image.width,
+            image.height,
+            sync
+        )
+    
+    def free(self) -> None:
+        """
+        Unregisters the OpenGL resource from CUDA.
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/opengl/
+        """
+        if self._handle is not None:
+            unregister_gl_resource(self._handle)
+            self._handle = None
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.free()
+        return False
+    
+    def __del__(self):
+        if hasattr(self, '_handle') and self._handle is not None:
+            try:
+                self.free()
+            except Exception:
+                pass
+    
+    def __repr__(self) -> str:
+        status = "active" if getattr(self, '_handle', None) is not None else "freed"
+        return f"GLResource(pbo_id={self.pbo_id}, status={status})"

pyimagecuda/image.py

@@ -1,13 +1,11 @@
 from .pyimagecuda_internal import create_buffer_f32, free_buffer, create_buffer_u8  #type: ignore
 
-
 class Buffer:
     
     def __init__(self, width: int, height: int, is_u8: bool = False):
         create_func = create_buffer_u8 if is_u8 else create_buffer_f32
         self._handle = create_func(width, height)
-        self.capacity_width = width
-        self.capacity_height = height
+        self.capacity_pixels = width * height
     
     def free(self) -> None:
         free_buffer(self._handle)
@@ -29,11 +27,11 @@ class ImageBase:
         value = int(value)
         if value <= 0:
             raise ValueError(f"Width must be positive, got {value}")
-        
-        if value > self._buffer.capacity_width:
+
+        if value * self._height > self._buffer.capacity_pixels:
             raise ValueError(
-                f"Width {value} exceeds buffer capacity "
-                f"{self._buffer.capacity_width}"
+                f"Dimensions {value}×{self._height} exceed buffer capacity "
+                f"({self._buffer.capacity_pixels:,} pixels)"
             )
         
         self._width = value
@@ -48,14 +46,46 @@ class ImageBase:
         if value <= 0:
             raise ValueError(f"Height must be positive, got {value}")
         
-        if value > self._buffer.capacity_height:
+        if self._width * value > self._buffer.capacity_pixels:
             raise ValueError(
-                f"Height {value} exceeds buffer capacity "
-                f"{self._buffer.capacity_height}"
+                f"Dimensions {self._width}×{value} exceed buffer capacity "
+                f"({self._buffer.capacity_pixels:,} pixels)"
             )
         
         self._height = value
 
+    def resize(self, width: int, height: int) -> None:
+        """
+        Sets both width and height atomically with proper validation.
+        
+        Recommended when changing aspect ratio to avoid temporary invalid states.
+        
+        Example:
+            img = Image(1920, 1080)
+            img.resize(3840, 540)  # Changes aspect ratio safely
+        
+        Note: This not change image data, only dimensions.
+        """
+        width = int(width)
+        height = int(height)
+        
+        if width <= 0 or height <= 0:
+            raise ValueError(f"Dimensions must be positive, got {width}×{height}")
+        
+        total_pixels = width * height
+        if total_pixels > self._buffer.capacity_pixels:
+            raise ValueError(
+                f"Dimensions {width}×{height} ({total_pixels:,} pixels) "
+                f"exceed buffer capacity ({self._buffer.capacity_pixels:,} pixels)"
+            )
+        
+        self._width = width
+        self._height = height
+
+    def get_max_capacity(self) -> int:
+        """Returns the total pixel capacity of the buffer."""
+        return self._buffer.capacity_pixels
+
     def free(self) -> None:
         self._buffer.free()
 
@@ -66,13 +96,9 @@ class ImageBase:
         self.free()
         return False
 
-    def get_max_capacity(self) -> tuple[int, int]:
-        return (self._buffer.capacity_width, self._buffer.capacity_height)
-
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self.width}×{self.height})"
 
-
 class Image(ImageBase):
     
     def __init__(self, width: int, height: int):