0.0.10

Author: offerrall

README.md

@@ -1,4 +1,4 @@
-# PyImageCUDA 0.0.9
+# PyImageCUDA 0.0.10
 
 [![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)

docs/image.md

@@ -144,24 +144,14 @@ from pyimagecuda import Image
 img = Image(1920, 1080)
 
 # Can logically resize within capacity
-img.width = 1280
-img.height = 720
+img.resize(1280, 720)
 
 # Check capacity
-max_w, max_h = img.get_max_capacity()
-print(f"Capacity: {max_w}×{max_h}")  # 1920×1080
+max_pixels = img.get_max_capacity()
+print(f"Capacity: {max_pixels:,} pixels")  # 2,073,600 pixels (1920×1080)
 print(f"Current: {img.width}×{img.height}")  # 1280×720
 ```
 
-Use case: Loading variable-sized images into fixed buffers.
-```python
-buffer = Image(4096, 4096)  # Max capacity
-
-for filename in images:
-    load(filename, f32_buffer=buffer)  # Adjusts buffer dimensions
-    process(buffer)
-```
-
 ---
 
 ## Best Practices

pyimagecuda/__init__.py

@@ -1,7 +1,7 @@
 import ctypes
 import sys
 
-__version__ = "0.0.9"
+__version__ = "0.0.10"
 
 def _check_nvidia_driver():
     try:

pyimagecuda/effect.py

@@ -4,7 +4,6 @@
 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,15 +24,19 @@ def rounded_corners(image: Image, radius: float) -> None:
         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 == 0: return
-        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),
@@ -52,42 +55,60 @@ def drop_shadow(
             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)
 
         if blur > 0:
             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
@@ -105,38 +126,66 @@ def stroke(
 
         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
 
@@ -152,8 +201,10 @@ def vignette(
         
         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,14 +1,15 @@
 from .image import Image
-from .utils import ensure_capacity
 from .io import copy
-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 .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:
@@ -43,14 +44,14 @@ def gaussian_blur(
             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(
@@ -93,7 +94,7 @@ def sharpen(
             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(
@@ -157,7 +158,7 @@ def sobel(src: Image, dst_buffer: Image | None = None) -> Image | 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_sobel_f32(
@@ -187,7 +188,7 @@ def emboss(src: Image, strength: float = 1.0, dst_buffer: Image | None = 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(