pyimagecuda 0.0.4__cp312-cp312-win_amd64.whl

pyimagecuda/__init__.py

@@ -0,0 +1,64 @@
+import ctypes
+import sys
+
+__version__ = "0.0.4"
+
+def _check_nvidia_driver():
+    try:
+        ctypes.windll.LoadLibrary("nvcuda.dll")
+        return True
+    except OSError:
+        return False
+
+_INTERNAL_LOADED = False
+
+try:
+    from . import pyimagecuda_internal
+    _INTERNAL_LOADED = True
+except ImportError as e:
+    _INTERNAL_LOADED = False
+    error_msg = str(e).lower()
+
+    if "dll load failed" in error_msg:
+        print("\n" + "!" * 75)
+        print(" [CRITICAL ERROR] Failed to load pyimagecuda backend.")
+        
+        if not _check_nvidia_driver():
+            print(" CAUSE: NVIDIA Drivers are missing or not detected.")
+            print(" SOLUTION: Install latest drivers from: https://www.nvidia.com/Download/index.aspx")
+        else:
+            print(" CAUSE: Microsoft Visual C++ Redistributable is missing.")
+            print(" SOLUTION: Install it from: https://aka.ms/vs/17/release/vc_redist.x64.exe")
+        
+        print("!" * 75 + "\n")
+    else:
+        print(f"Error loading internal module: {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 .fill import Fill
+        from .resize import Resize
+        from .blend import Blend
+        from .filter import Filter
+        from .effect import Effect
+        from .adjust import Adjust
+        from .transform import Transform
+    except ImportError as e:
+        print(f"Warning: Error importing Python wrappers: {e}")
+
+def check_system():
+    print("--- PYIMAGECUDA DIAGNOSTIC ---")
+    
+    if not _INTERNAL_LOADED:
+        print("❌ Backend C++ NOT loaded. See errors above.")
+        return False
+    
+    try:
+        pyimagecuda_internal.cuda_sync()
+        print("✅ SYSTEM OK. GPU Ready & Libraries Loaded.")
+        return True
+    except Exception as e:
+        print(f"❌ Backend loaded but GPU runtime failed: {e}")
+        return False

pyimagecuda/adjust.py

@@ -0,0 +1,101 @@
+from .image import Image
+from .pyimagecuda_internal import ( #type: ignore
+    adjust_brightness_f32, 
+    adjust_contrast_f32,
+    adjust_saturation_f32,
+    adjust_gamma_f32,
+    adjust_opacity_f32
+)
+
+
+class Adjust:
+    
+    @staticmethod
+    def brightness(image: Image, factor: float) -> None:
+        """
+        Adjusts image brightness by adding a factor (in-place).
+        
+        Positive factor brightens, negative darkens.
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/adjust/#brightness
+        """
+        adjust_brightness_f32(
+            image._buffer._handle,
+            image.width,
+            image.height,
+            float(factor)
+        )
+
+    @staticmethod
+    def contrast(image: Image, factor: float) -> None:
+        """
+        Adjusts image contrast relative to middle gray (in-place).
+        
+        factor > 1.0 increases contrast.
+        factor < 1.0 decreases contrast.
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/adjust/#contrast
+        """
+        adjust_contrast_f32(
+            image._buffer._handle,
+            image.width,
+            image.height,
+            float(factor)
+        )
+
+    @staticmethod
+    def saturation(image: Image, factor: float) -> None:
+        """
+        Adjusts color intensity (in-place).
+        
+        factor 0.0 = Grayscale
+        factor 1.0 = Original
+        factor > 1.0 = More vibrant
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/adjust/#saturation
+        """
+        adjust_saturation_f32(
+            image._buffer._handle,
+            image.width,
+            image.height,
+            float(factor)
+        )
+
+    @staticmethod
+    def gamma(image: Image, gamma: float) -> None:
+        """
+        Adjusts gamma correction (non-linear brightness) (in-place).
+        
+        Useful for brightening shadows without washing out highlights.
+        
+        gamma > 1.0: Brightens midtones.
+        gamma < 1.0: Darkens midtones.
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/adjust/#gamma
+        """
+        if gamma <= 0:
+            raise ValueError("Gamma must be positive")
+            
+        adjust_gamma_f32(
+            image._buffer._handle,
+            image.width,
+            image.height,
+            float(gamma)
+        )
+
+    @staticmethod
+    def opacity(image: Image, factor: float) -> None:
+        """
+        Multiplies the alpha channel by a factor (In-Place).
+        
+        - factor: 0.0 (Fully Transparent) to 1.0 (No change). 
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/adjust/#opacity
+        """
+
+        adjust_opacity_f32(
+            image._buffer._handle,
+            image.width,
+            image.height,
+            float(factor)
+        )

pyimagecuda/blend.py

@@ -0,0 +1,273 @@
+from typing import Literal
+from .image import Image
+from .pyimagecuda_internal import blend_f32, blend_mask_f32 # type: ignore
+
+
+def _calculate_position(
+    base_width: int,
+    base_height: int,
+    overlay_width: int,
+    overlay_height: int,
+    anchor: str,
+    offset_x: int,
+    offset_y: int
+) -> tuple[int, int]:
+
+    pos_x = offset_x
+    pos_y = offset_y
+    
+    if 'center' in anchor and anchor in ['top-center', 'center', 'bottom-center']:
+        pos_x += (base_width - overlay_width) // 2
+    elif 'right' in anchor:
+        pos_x += base_width - overlay_width
+    
+    if 'center' in anchor and anchor in ['center-left', 'center', 'center-right']:
+        pos_y += (base_height - overlay_height) // 2
+    elif 'bottom' in anchor:
+        pos_y += base_height - overlay_height
+    
+    return pos_x, pos_y
+
+
+class Blend:
+
+    @staticmethod
+    def normal(
+        base: Image,
+        overlay: Image,
+        anchor: Literal['top-left', 'top-center', 'top-right', 'center-left', 'center', 'center-right', 'bottom-left', 'bottom-center', 'bottom-right'] = 'top-left',
+        offset_x: int = 0,
+        offset_y: int = 0,
+        opacity: float = 1.0
+    ) -> None:
+        """
+        Standard alpha blending (in-place).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#normal
+        """
+        pos_x, pos_y = _calculate_position(
+            base.width, base.height,
+            overlay.width, overlay.height,
+            anchor, offset_x, offset_y
+        )
+        
+        blend_f32(
+            base._buffer._handle,
+            overlay._buffer._handle,
+            base.width, base.height,
+            overlay.width, overlay.height,
+            pos_x, pos_y,
+            0,
+            opacity
+        )
+
+    @staticmethod
+    def multiply(
+        base: Image,
+        overlay: Image,
+        anchor: Literal['top-left', 'top-center', 'top-right', 'center-left', 'center', 'center-right', 'bottom-left', 'bottom-center', 'bottom-right'] = 'top-left',
+        offset_x: int = 0,
+        offset_y: int = 0,
+        opacity: float = 1.0
+    ) -> None:
+        """
+        Multiplies color values, darkening the image (in-place).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#multiply
+        """
+        pos_x, pos_y = _calculate_position(
+            base.width, base.height,
+            overlay.width, overlay.height,
+            anchor, offset_x, offset_y
+        )
+        
+        blend_f32(
+            base._buffer._handle,
+            overlay._buffer._handle,
+            base.width, base.height,
+            overlay.width, overlay.height,
+            pos_x, pos_y,
+            1,
+            opacity
+        )
+
+    @staticmethod
+    def screen(
+        base: Image,
+        overlay: Image,
+        anchor: Literal['top-left', 'top-center', 'top-right', 'center-left', 'center', 'center-right', 'bottom-left', 'bottom-center', 'bottom-right'] = 'top-left',
+        offset_x: int = 0,
+        offset_y: int = 0,
+        opacity: float = 1.0
+    ) -> None:
+        """
+        Inverted multiply, lightening the image (in-place).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#screen
+        """
+        pos_x, pos_y = _calculate_position(
+            base.width, base.height,
+            overlay.width, overlay.height,
+            anchor, offset_x, offset_y
+        )
+        
+        blend_f32(
+            base._buffer._handle,
+            overlay._buffer._handle,
+            base.width, base.height,
+            overlay.width, overlay.height,
+            pos_x, pos_y,
+            2,
+            opacity
+        )
+
+    @staticmethod
+    def add(
+        base: Image,
+        overlay: Image,
+        anchor: Literal['top-left', 'top-center', 'top-right', 'center-left', 'center', 'center-right', 'bottom-left', 'bottom-center', 'bottom-right'] = 'top-left',
+        offset_x: int = 0,
+        offset_y: int = 0,
+        opacity: float = 1.0
+    ) -> None:
+        """
+        Additive blending, useful for light effects (in-place).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#add
+        """
+        pos_x, pos_y = _calculate_position(
+            base.width, base.height,
+            overlay.width, overlay.height,
+            anchor, offset_x, offset_y
+        )
+        
+        blend_f32(
+            base._buffer._handle,
+            overlay._buffer._handle,
+            base.width, base.height,
+            overlay.width, overlay.height,
+            pos_x, pos_y,
+            3,
+            opacity
+        )
+
+    @staticmethod
+    def overlay(
+        base: Image,
+        overlay: Image,
+        anchor: Literal['top-left', 'top-center', 'top-right', 'center-left', 'center', 'center-right', 'bottom-left', 'bottom-center', 'bottom-right'] = 'top-left',
+        offset_x: int = 0,
+        offset_y: int = 0,
+        opacity: float = 1.0
+    ) -> None:
+        """
+        Combines Multiply and Screen. Increases contrast (in-place).
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#overlay
+        """
+        pos_x, pos_y = _calculate_position(
+            base.width, base.height,
+            overlay.width, overlay.height,
+            anchor, offset_x, offset_y
+        )
+        
+        blend_f32(
+            base._buffer._handle,
+            overlay._buffer._handle,
+            base.width, base.height,
+            overlay.width, overlay.height,
+            pos_x, pos_y,
+            4,
+            opacity
+        )
+
+    @staticmethod
+    def soft_light(
+        base: Image,
+        overlay: Image,
+        anchor: Literal['top-left', 'top-center', 'top-right', 'center-left', 'center', 'center-right', 'bottom-left', 'bottom-center', 'bottom-right'] = 'top-left',
+        offset_x: int = 0,
+        offset_y: int = 0,
+        opacity: float = 1.0
+    ) -> None:
+        """
+        Gentle lighting effect, like a diffuse spotlight (in-place).
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#soft-light
+        """
+        pos_x, pos_y = _calculate_position(
+            base.width, base.height,
+            overlay.width, overlay.height,
+            anchor, offset_x, offset_y
+        )
+        
+        blend_f32(
+            base._buffer._handle,
+            overlay._buffer._handle,
+            base.width, base.height,
+            overlay.width, overlay.height,
+            pos_x, pos_y,
+            5,
+            opacity
+        )
+
+    @staticmethod
+    def hard_light(
+        base: Image,
+        overlay: Image,
+        anchor: Literal['top-left', 'top-center', 'top-right', 'center-left', 'center', 'center-right', 'bottom-left', 'bottom-center', 'bottom-right'] = 'top-left',
+        offset_x: int = 0,
+        offset_y: int = 0,
+        opacity: float = 1.0
+    ) -> None:
+        """
+        Strong lighting effect, like a harsh spotlight (in-place).
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#hard-light
+        """
+        pos_x, pos_y = _calculate_position(
+            base.width, base.height,
+            overlay.width, overlay.height,
+            anchor, offset_x, offset_y
+        )
+        
+        blend_f32(
+            base._buffer._handle,
+            overlay._buffer._handle,
+            base.width, base.height,
+            overlay.width, overlay.height,
+            pos_x, pos_y,
+            6,
+            opacity
+        )
+
+    @staticmethod
+    def mask(
+        base: Image,
+        mask: Image,
+        anchor: Literal['top-left', 'top-center', 'top-right', 'center-left', 'center', 'center-right', 'bottom-left', 'bottom-center', 'bottom-right'] = 'top-left',
+        offset_x: int = 0,
+        offset_y: int = 0,
+        mode: Literal['alpha', 'luminance'] = 'luminance'
+    ) -> None:
+        """
+        Applies an image as an alpha mask to the base image (in-place).
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/blend/#mask
+        """
+        pos_x, pos_y = _calculate_position(
+            base.width, base.height,
+            mask.width, mask.height,
+            anchor, offset_x, offset_y
+        )
+        
+        mode_int = 1 if mode == 'luminance' else 0
+        
+        blend_mask_f32(
+            base._buffer._handle,
+            mask._buffer._handle,
+            base.width, base.height,
+            mask.width, mask.height,
+            pos_x, pos_y,
+            mode_int
+        )

pyimagecuda/effect.py

@@ -0,0 +1,164 @@
+from typing import Literal
+
+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,
+    colorize_alpha_mask_f32,
+    compute_distance_field_f32,
+    generate_stroke_composite_f32,
+    effect_vignette_f32
+)
+
+
+class Effect:
+
+    @staticmethod
+    def rounded_corners(image: Image, radius: float) -> None:
+        """
+        Applies rounded corners to the image (in-place).
+
+        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
+        
+        rounded_corners_f32(image._buffer._handle, image.width, image.height, float(radius))
+
+    @staticmethod
+    def drop_shadow(
+        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),
+        expand: bool = True,
+        dst_buffer: Image | None = None,
+        shadow_buffer: Image | None = None,
+        temp_buffer: Image | None = None
+    ) -> Image | None:
+        """
+        Adds a drop shadow to the image.
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/effect/#drop_shadow
+        """
+        if expand:
+            pad_l = blur + max(0, -offset_x)
+            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
+        else:
+            res_w, res_h = image.width, image.height
+            img_x, img_y = 0, 0
+            
+        if dst_buffer is None:
+            result = Image(res_w, res_h); ret = True
+        else:
+            ensure_capacity(dst_buffer, res_w, res_h); result = dst_buffer; ret = False
+
+        if shadow_buffer is None:
+            shadow = Image(res_w, res_h); own_shadow = True
+        else:
+            ensure_capacity(shadow_buffer, 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
+            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()
+        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))
+        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()
+        return result if ret else None
+
+    @staticmethod
+    def stroke(
+        image: Image,
+        width: int = 2,
+        color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 1.0),
+        position: Literal['outside', 'inside'] = 'outside',
+        expand: bool = True,
+        dst_buffer: Image | None = None,
+        distance_buffer: Image | None = None,
+    ) -> Image | None:
+        """
+        Adds a stroke (outline) to the image using distance field method.
+
+        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 position == 'outside' and expand:
+            res_w, res_h = image.width + width * 2, image.height + width * 2
+            off_x, off_y = width, width
+        else:
+            res_w, res_h = image.width, image.height
+            off_x, off_y = 0, 0
+        
+        if dst_buffer is None:
+            result = Image(res_w, res_h); ret = True
+        else:
+            ensure_capacity(dst_buffer, res_w, res_h); result = dst_buffer; ret = False
+        
+        if distance_buffer is None:
+            distance = Image(res_w, res_h); own_dist = True
+        else:
+            ensure_capacity(distance_buffer, 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
+        )
+
+        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
+        )
+        
+        if own_dist: distance.free()
+        
+        return result if ret else None
+
+    @staticmethod
+    def vignette(
+        image: Image,
+        radius: float = 0.9,
+        softness: float = 1.0,
+        color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 1.0)
+    ) -> None:
+        """
+        Applies a vignette effect (darkening edges) (in-place).
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/effect/#vignette
+        """
+        if radius < 0: radius = 0.0
+        if softness < 0: softness = 0.0
+        
+        effect_vignette_f32(
+            image._buffer._handle,
+            image.width,
+            image.height,
+            float(radius),
+            float(softness),
+            color
+        )