pyimagecuda 0.1.0__cp311-cp311-win_amd64.whl

pyimagecuda/io.py

@@ -0,0 +1,259 @@
+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
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+def upload(image: ImageBase, data: bytes | bytearray | memoryview) -> None:
+    """
+    Uploads the image data from a bytes-like object to the GPU.
+
+    Docs & Examples: https://offerrall.github.io/pyimagecuda/io/#direct-uploaddownload
+    """
+    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:
+    """
+    Downloads the image data from the GPU to a bytes object.
+
+    Docs & Examples: https://offerrall.github.io/pyimagecuda/io/#direct-uploaddownload
+    """
+    return download_from_buffer(image._buffer._handle, image.width, image.height)
+
+
+def copy(dst: ImageBase, src: ImageBase) -> None:
+    """
+    Copies image data from the source image to the destination image.
+
+    Docs & Examples: https://offerrall.github.io/pyimagecuda/io/#copy-between-buffers
+    """
+    dst.resize(src.width, src.height)
+    copy_buffer(dst._buffer._handle, src._buffer._handle, src.width, src.height)
+
+
+def convert_float_to_u8(dst: ImageU8, src: Image) -> None:
+    """
+    Converts a floating-point image to an 8-bit unsigned integer image.
+
+    Docs & Examples: https://offerrall.github.io/pyimagecuda/io/#manual-conversions
+    """
+    dst.resize(src.width, src.height)
+    convert_f32_to_u8(dst._buffer._handle, src._buffer._handle, src.width, src.height)
+
+
+def convert_u8_to_float(dst: Image, src: ImageU8) -> None:
+    """
+    Converts an 8-bit unsigned integer image to a floating-point image.
+
+    Docs & Examples: https://offerrall.github.io/pyimagecuda/io/#manual-conversions
+    """
+    dst.resize(src.width, src.height)
+    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 | None:
+    """
+    Loads an image from a file (returns new image or writes to buffer).
+    
+    Docs & Examples: https://offerrall.github.io/pyimagecuda/io/#loading-images
+    """
+    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
+
+    should_return = False
+    
+    if f32_buffer is None:
+        f32_buffer = Image(width, height)
+        should_return = True
+    else:
+        f32_buffer.resize(width, height)
+        should_return = False
+
+    if u8_buffer is None:
+        u8_buffer = ImageU8(width, height)
+        owns_u8 = True
+    else:
+        u8_buffer.resize(width, 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 if should_return else None
+
+
+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,
+        u8_image.width,
+        u8_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)
+
+
+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()
+
+
+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

@@ -0,0 +1,108 @@
+from .image import Image
+from .pyimagecuda_internal import resize_f32 #type: ignore
+from .io import copy
+
+
+def _resize_internal(
+    src: Image,
+    width: int | None,
+    height: int | None,
+    method: int,
+    dst_buffer: Image | None = None
+) -> Image | None:
+    
+    if width is None and height is None:
+        raise ValueError("At least one of width or height must be specified")
+    elif width is None:
+        width = int(src.width * (height / src.height))
+    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:
+        dst_buffer.resize(width, 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 | None = None,
+        height: int | None = None,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        """
+        Resizes the image using nearest neighbor interpolation (returns new image or writes to buffer).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/resize/#nearest
+        """
+        return _resize_internal(src, width, height, 0, dst_buffer)
+
+    @staticmethod
+    def bilinear(
+        src: Image,
+        width: int | None = None,
+        height: int | None = None,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        """
+        Resizes the image using bilinear interpolation (returns new image or writes to buffer).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/resize/#bilinear
+        """
+
+        return _resize_internal(src, width, height, 1, dst_buffer)
+
+    @staticmethod
+    def bicubic(
+        src: Image,
+        width: int | None = None,
+        height: int | None = None,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        """
+        Resizes the image using bicubic interpolation (returns new image or writes to buffer).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/resize/#bicubic
+        """
+        return _resize_internal(src, width, height, 2, dst_buffer)
+
+    @staticmethod
+    def lanczos(
+        src: Image,
+        width: int | None = None,
+        height: int | None = None,
+        dst_buffer: Image | None = None
+    ) -> Image | None:
+        """
+        Resizes the image using Lanczos interpolation (returns new image or writes to buffer).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/resize/#lanczos
+        """
+        return _resize_internal(src, width, height, 3, dst_buffer)

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