pyimagecuda 0.0.1__cp313-cp313-win_amd64.whl

pyimagecuda/__init__.py

@@ -0,0 +1,60 @@
+import ctypes
+import sys
+
+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
+    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/blend.py

@@ -0,0 +1,77 @@
+from .image import Image
+from .pyimagecuda_internal import blend_f32 #type: ignore
+
+
+class Blend:
+
+    @staticmethod
+    def normal(
+        base: Image,
+        overlay: Image,
+        pos_x: int = 0,
+        pos_y: int = 0,
+        opacity: float = 1.0
+    ) -> None:
+        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,
+        pos_x: int = 0,
+        pos_y: int = 0,
+        opacity: float = 1.0
+    ) -> None:
+        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,
+        pos_x: int = 0,
+        pos_y: int = 0,
+        opacity: float = 1.0
+    ) -> None:
+        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,
+        pos_x: int = 0,
+        pos_y: int = 0,
+        opacity: float = 1.0
+    ) -> None:
+        blend_f32(
+            base._buffer._handle,
+            overlay._buffer._handle,
+            base.width, base.height,
+            overlay.width, overlay.height,
+            pos_x, pos_y,
+            3,
+            opacity
+        )

pyimagecuda/effect.py

@@ -0,0 +1,90 @@
+from .image import Image
+from .filter import Filter
+from .blend import Blend
+from .fill import Fill
+from .utils import check_dimensions_match
+from .pyimagecuda_internal import ( #type: ignore
+    rounded_corners_f32,
+    extract_alpha_f32,
+    colorize_shadow_f32
+)
+
+
+class Effect:
+
+    @staticmethod
+    def rounded_corners(image: Image, radius: float) -> None:
+        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),
+        dst_buffer: Image | None = None,
+        shadow_buffer: Image | None = None,
+        temp_buffer: Image | None = None
+    ) -> Image | None:
+        
+        if dst_buffer is None:
+            result = Image(image.width, image.height)
+            return_result = True
+        else:
+            check_dimensions_match(dst_buffer, image)
+            result = dst_buffer
+            return_result = False
+        
+        if shadow_buffer is None:
+            shadow = Image(image.width, image.height)
+            owns_shadow = True
+        else:
+            check_dimensions_match(shadow_buffer, image)
+            shadow = shadow_buffer
+            owns_shadow = False
+        
+        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,
+                temp_buffer=temp_buffer
+            )
+        
+        colorize_shadow_f32(
+            shadow._buffer._handle,
+            shadow.width,
+            shadow.height,
+            color
+        )
+        
+        Fill.color(result, (0.0, 0.0, 0.0, 0.0))
+        Blend.normal(result, shadow, pos_x=offset_x, pos_y=offset_y)
+        Blend.normal(result, image, pos_x=0, pos_y=0)
+        
+        if owns_shadow:
+            shadow.free()
+        
+        return result if return_result else None

pyimagecuda/fill.py

@@ -0,0 +1,36 @@
+from typing import Literal
+from .image import Image
+from .pyimagecuda_internal import fill_color_f32, fill_gradient_f32  #type: ignore
+
+class Fill:
+    
+    @staticmethod
+    def color(image: Image, rgba: tuple[float, float, float, float]) -> None:
+        fill_color_f32(image._buffer._handle, rgba, image.width, image.height)
+    
+    @staticmethod
+    def gradient(image: Image, 
+                 rgba1: tuple[float, float, float, float],
+                 rgba2: tuple[float, float, float, float],
+                 direction: Literal['horizontal', 'vertical', 'diagonal', 'radial'] = 'horizontal',
+                 seamless: bool = False) -> None:
+        direction_map = {
+            'horizontal': 0,
+            'vertical': 1,
+            'diagonal': 2,
+            'radial': 3
+        }
+        
+        dir_int = direction_map.get(direction)
+        if dir_int is None:
+            raise ValueError(f"Invalid direction: {direction}. Must be one of {list(direction_map.keys())}")
+        
+        fill_gradient_f32(
+            image._buffer._handle, 
+            rgba1, 
+            rgba2, 
+            image.width, 
+            image.height, 
+            dir_int,
+            seamless
+        )

pyimagecuda/filter.py

@@ -0,0 +1,71 @@
+from .image import Image
+from .utils import check_dimensions_match
+from .pyimagecuda_internal import gaussian_blur_separable_f32, sharpen_f32  #type: ignore
+
+
+class Filter:
+
+    @staticmethod
+    def gaussian_blur(
+        src: Image,
+        radius: int = 3,
+        sigma: float | None = None,
+        dst_buffer: Image | None = None,
+        temp_buffer: Image | None = None
+    ) -> Image | None:
+
+        if sigma is None:
+            sigma = radius / 3.0
+        
+        if dst_buffer is None:
+            dst_buffer = Image(src.width, src.height)
+            return_dst = True
+        else:
+            check_dimensions_match(dst_buffer, src)
+            return_dst = False
+
+        if temp_buffer is None:
+            temp_buffer = Image(src.width, src.height)
+            owns_temp = True
+        else:
+            check_dimensions_match(temp_buffer, src)
+            owns_temp = False
+
+        gaussian_blur_separable_f32(
+            src._buffer._handle,
+            temp_buffer._buffer._handle,
+            dst_buffer._buffer._handle,
+            src.width,
+            src.height,
+            int(radius),
+            float(sigma)
+        )
+
+        if owns_temp:
+            temp_buffer.free()
+        
+        return dst_buffer if return_dst else None
+
+    @staticmethod
+    def sharpen(
+        src: Image,
+        strength: float = 1.0,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+
+        if dst_buffer is None:
+            dst_buffer = Image(src.width, src.height)
+            return_buffer = True
+        else:
+            check_dimensions_match(dst_buffer, src)
+            return_buffer = False
+        
+        sharpen_f32(
+            src._buffer._handle,
+            dst_buffer._buffer._handle,
+            src.width,
+            src.height,
+            float(strength)
+        )
+        
+        return dst_buffer if return_buffer else None

pyimagecuda/image.py

@@ -0,0 +1,78 @@
+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
+    
+    def free(self) -> None:
+        free_buffer(self._handle)
+
+
+class ImageBase:
+
+    def __init__(self, width: int, height: int, is_u8: bool = False):
+        self._buffer = Buffer(width, height, is_u8)
+        self._width = width
+        self._height = height
+    
+    @property
+    def width(self) -> int:
+        return self._width
+    
+    @width.setter
+    def width(self, value: int) -> None:
+        value = int(value)
+        if value <= 0:
+            raise ValueError(f"Width must be positive, got {value}")
+        
+        if value > self._buffer.capacity_width:
+            raise ValueError(
+                f"Width {value} exceeds buffer capacity "
+                f"{self._buffer.capacity_width}"
+            )
+        
+        self._width = value
+    
+    @property
+    def height(self) -> int:
+        return self._height
+    
+    @height.setter
+    def height(self, value: int) -> None:
+        value = int(value)
+        if value <= 0:
+            raise ValueError(f"Height must be positive, got {value}")
+        
+        if value > self._buffer.capacity_height:
+            raise ValueError(
+                f"Height {value} exceeds buffer capacity "
+                f"{self._buffer.capacity_height}"
+            )
+        
+        self._height = value
+    
+    def free(self) -> None:
+        self._buffer.free()
+    
+    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):
+        super().__init__(width, height, is_u8=False)
+
+
+class ImageU8(ImageBase):
+    
+    def __init__(self, width: int, height: int):
+        super().__init__(width, height, is_u8=True)

pyimagecuda/io.py

@@ -0,0 +1,130 @@
+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 .image import Image, ImageU8, ImageBase
+from .utils import check_dimensions_match
+
+
+
+def upload(image: ImageBase, data: bytes | bytearray | memoryview) -> None:
+    bytes_per_pixel = 4 if isinstance(image, ImageU8) else 16
+    expected = image.width * image.height * bytes_per_pixel
+    actual = data.nbytes if isinstance(data, memoryview) else len(data)
+    
+    if actual != expected:
+        raise ValueError(f"Expected {expected} bytes, got {actual}")
+    
+    upload_to_buffer(image._buffer._handle, data, image.width, image.height)
+
+
+def download(image: ImageBase) -> bytes:
+    return download_from_buffer(image._buffer._handle, image.width, image.height)
+
+
+def copy(dst: ImageBase, src: ImageBase) -> None:
+    check_dimensions_match(dst, src)
+    copy_buffer(dst._buffer._handle, src._buffer._handle, src.width, src.height)
+
+
+def convert_float_to_u8(dst: ImageU8, src: Image) -> None:
+    check_dimensions_match(dst, src)
+    convert_f32_to_u8(dst._buffer._handle, src._buffer._handle, src.width, src.height)
+
+
+def convert_u8_to_float(dst: Image, src: ImageU8) -> None:
+    check_dimensions_match(dst, src)
+    convert_u8_to_f32(dst._buffer._handle, src._buffer._handle, src.width, src.height)
+
+
+def load(filepath: str, f32_buffer: Image | None = None, u8_buffer: ImageU8 | None = None) -> Image:    
+    vips_img = pyvips.Image.new_from_file(filepath, access='sequential')
+    
+    if vips_img.bands == 1:
+        vips_img = vips_img.bandjoin([vips_img, vips_img, vips_img])
+        vips_img = vips_img.bandjoin(255)
+    elif vips_img.bands == 3:
+        vips_img = vips_img.bandjoin(255)
+    elif vips_img.bands == 4:
+        pass
+    else:
+        raise ValueError(
+            f"Unsupported image format: {vips_img.bands} channels. "
+            f"Only grayscale (1), RGB (3), and RGBA (4) are supported."
+        )
+    
+    width = vips_img.width
+    height = vips_img.height
+    
+    if f32_buffer is None:
+        f32_buffer = Image(width, height)
+    else:
+        max_w, max_h = f32_buffer.get_max_capacity()
+        if width > max_w or height > max_h:
+            raise ValueError(
+                f"Image {width}×{height} exceeds f32_buffer capacity {max_w}×{max_h}"
+            )
+
+        f32_buffer.width = width
+        f32_buffer.height = height
+
+    if u8_buffer is None:
+        u8_buffer = ImageU8(width, height)
+        owns_u8 = True
+    else:
+        max_w, max_h = u8_buffer.get_max_capacity()
+        if width > max_w or height > max_h:
+            raise ValueError(
+                f"Image {width}×{height} exceeds u8_buffer capacity {max_w}×{max_h}"
+            )
+        
+        u8_buffer.width = width
+        u8_buffer.height = height
+        owns_u8 = False
+
+    vips_img = vips_img.cast('uchar')
+    pixel_data = vips_img.write_to_memory()
+    
+    upload(u8_buffer, pixel_data)
+    
+    convert_u8_to_float(f32_buffer, u8_buffer)
+    
+    if owns_u8:
+        u8_buffer.free()
+    
+    return f32_buffer
+
+
+def save(image: Image, filepath: str, u8_buffer: ImageU8 | None = None, quality: int | None = None) -> None:
+    if u8_buffer is None:
+        u8_buffer = ImageU8(image.width, image.height)
+        owns_buffer = True
+    else:
+        check_dimensions_match(u8_buffer, image)
+        owns_buffer = False
+    
+    convert_float_to_u8(u8_buffer, image)
+    pixel_data = download(u8_buffer)
+    
+    vips_img = pyvips.Image.new_from_memory(
+        pixel_data,
+        image.width,
+        image.height,
+        bands=4,
+        format='uchar'
+    )
+    
+    vips_img = vips_img.copy(interpretation='srgb')
+    
+    save_kwargs = {}
+    if quality is not None:
+        if filepath.lower().endswith(('.jpg', '.jpeg')):
+            save_kwargs['Q'] = quality
+        elif filepath.lower().endswith('.webp'):
+            save_kwargs['Q'] = quality
+        elif filepath.lower().endswith(('.heic', '.heif')):
+            save_kwargs['Q'] = quality
+    
+    vips_img.write_to_file(filepath, **save_kwargs)
+    
+    if owns_buffer:
+        u8_buffer.free()

pyimagecuda/resize.py

@@ -0,0 +1,72 @@
+from .image import Image
+from .pyimagecuda_internal import resize_f32  #type: ignore
+
+
+def _resize_internal(
+    src: Image,
+    width: int,
+    height: int,
+    method: int,
+    dst_buffer: Image | None = None
+) -> Image | None:
+    
+    if dst_buffer is None:
+        dst_buffer = Image(width, height)
+        return_buffer = True
+    else:
+        if dst_buffer.width != width or dst_buffer.height != height:
+            raise ValueError(
+                f"dst_buffer size mismatch: expected {width}×{height}, "
+                f"got {dst_buffer.width}×{dst_buffer.height}"
+            )
+        return_buffer = False
+    
+    resize_f32(
+        src._buffer._handle,
+        dst_buffer._buffer._handle,
+        src.width,
+        src.height,
+        width,
+        height,
+        method
+    )
+    
+    return dst_buffer if return_buffer else None
+
+
+class Resize:
+    @staticmethod
+    def nearest(
+        src: Image,
+        width: int,
+        height: int,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        return _resize_internal(src, width, height, 0, dst_buffer)
+
+    @staticmethod
+    def bilinear(
+        src: Image,
+        width: int,
+        height: int,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        return _resize_internal(src, width, height, 1, dst_buffer)
+
+    @staticmethod
+    def bicubic(
+        src: Image,
+        width: int,
+        height: int,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        return _resize_internal(src, width, height, 2, dst_buffer)
+
+    @staticmethod
+    def lanczos(
+        src: Image,
+        width: int,
+        height: int,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        return _resize_internal(src, width, height, 3, dst_buffer)

pyimagecuda/utils.py

@@ -0,0 +1,9 @@
+from .image import ImageBase
+
+
+
+def check_dimensions_match(img1: ImageBase, img2: ImageBase) -> None:
+    if img1.width != img2.width or img1.height != img2.height:
+        raise ValueError(
+            f"Dimension mismatch: {img1.width}×{img1.height} vs {img2.width}×{img2.height}"
+        )

pyimagecuda-0.0.1.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.2
+Name: pyimagecuda
+Version: 0.0.1
+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
+
+[![Build Status](https://github.com/offerrall/pyimagecuda/actions/workflows/build.yml/badge.svg)](https://github.com/offerrall/pyimagecuda/actions)
+
+> ⚠️ **STATUS: PRE-ALPHA / INFRASTRUCTURE TESTING**
+>
+> This repository is currently validating the build and distribution system.
+> **It is NOT ready for production use yet.**
+
+### Goal
+GPU-accelerated (CUDA) image processing library for Python.
+Designed to be installed via a simple `pip install` without requiring the user to have the CUDA Toolkit or Visual Studio installed.
+
+### Verification (Testers Only)
+
+If you have installed a test build, you can verify that hardware acceleration is working correctly by running:
+
+```bash
+python -c "import pyimagecuda; pyimagecuda.check_system()"
+```

pyimagecuda-0.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+pyimagecuda/__init__.py,sha256=YNyiiMnR1XgqMqdhXbbPG2r-w8VUPetHZN-la2sJUAU,1941
+pyimagecuda/blend.py,sha256=_WgLwveDHJ_-OpqpcRf7FVZIF_k0SoPhA_RwRjgqV1M,1824
+pyimagecuda/effect.py,sha256=BPnu53goEMZGWWF0_9_tPfKXEF5eLkMtfM99H_KN3GE,2585
+pyimagecuda/fill.py,sha256=ZBzN1L8iXsymd7aixovkc397osrD8AQCiytOWiYRwac,1238
+pyimagecuda/filter.py,sha256=GdGIiadYuqtY8k7kFISR8GMTHZ1QYtvtLWFxDMO9_qY,1956
+pyimagecuda/image.py,sha256=K3d13hhUb1y4DKu8zlA81JFgQ81_MWZeMKHc4OOUvFA,2304
+pyimagecuda/io.py,sha256=sATHtf0tHH-4luZ9kmVF1EQ7vhyoB5iIhLK7bnj9x5E,4285
+pyimagecuda/pyimagecuda_internal.cp313-win_amd64.pyd,sha256=iaNyBlVlySdiHYQtCUH13YeaIXmokMByNbjmYvfvKQA,336896
+pyimagecuda/resize.py,sha256=WZAf85t1BNxF4THbPR6_dcj44xZroLKmTR5T90pw6nk,1848
+pyimagecuda/utils.py,sha256=9QDAFFnb2uJYwXup3hHHUm7uOjT7e5omfDEpwRx_F_w,302
+pyimagecuda-0.0.1.dist-info/METADATA,sha256=nhfRJoEYkBlNw3d8pgQ89LCx1rB73exmg02Gc27fwGI,1001
+pyimagecuda-0.0.1.dist-info/WHEEL,sha256=vkL3wTIkhjZa3RmEXX20hldNp6Q8qtwRjrXW6K5sw_Q,106
+pyimagecuda-0.0.1.dist-info/RECORD,,

pyimagecuda-0.0.1.dist-info/WHEEL

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