pyimagecuda 0.0.5__cp310-cp310-win_amd64.whl

pyimagecuda/fill.py

@@ -0,0 +1,263 @@
+from typing import Literal
+from .image import Image
+from .pyimagecuda_internal import (fill_color_f32, #type: ignore
+                                   fill_gradient_f32,
+                                   fill_circle_f32,
+                                   fill_checkerboard_f32,
+                                   fill_grid_f32,
+                                   fill_stripes_f32,
+                                   fill_dots_f32,
+                                   fill_noise_f32,
+                                   fill_perlin_f32,
+                                   fill_ngon_f32
+                                   )
+
+
+class Fill:
+    
+    @staticmethod
+    def color(image: Image, rgba: tuple[float, float, float, float]) -> None:
+        """
+        Fills the image with a solid color (in-place).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/fill/#solid-colors
+        """
+        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:
+        """
+        Fills the image with a gradient (in-place).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/fill/#gradients
+        """
+        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
+        )
+
+    @staticmethod
+    def checkerboard(
+        image: Image,
+        size: int = 20,
+        color1: tuple[float, float, float, float] = (0.8, 0.8, 0.8, 1.0),
+        color2: tuple[float, float, float, float] = (0.5, 0.5, 0.5, 1.0),
+        offset_x: int = 0,
+        offset_y: int = 0
+    ) -> None:
+        """
+        Fills buffer with a checkerboard pattern.
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/fill/#checkerboard
+        """
+        if size <= 0:
+            raise ValueError("Checkerboard size must be positive")
+        
+        fill_checkerboard_f32(
+            image._buffer._handle,
+            image.width, image.height,
+            int(size),
+            int(offset_x), int(offset_y),
+            color1, color2
+        )
+
+    @staticmethod
+    def grid(
+        image: Image,
+        spacing: int = 50,
+        line_width: int = 1,
+        color: tuple[float, float, float, float] = (0.5, 0.5, 0.5, 1.0),
+        bg_color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+        offset_x: int = 0,
+        offset_y: int = 0
+    ) -> None:
+        """
+        Fills buffer with a grid pattern.
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/fill/#grid
+        """
+        if spacing <= 0:
+            raise ValueError("Grid spacing must be positive")
+        if line_width <= 0:
+            raise ValueError("Line width must be positive")
+        
+        fill_grid_f32(
+            image._buffer._handle,
+            image.width, image.height,
+            int(spacing), int(line_width),
+            int(offset_x), int(offset_y),
+            color, bg_color
+        )
+
+    @staticmethod
+    def stripes(
+        image: Image,
+        angle: float = 45.0,
+        spacing: int = 40,
+        width: int = 20,
+        color1: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
+        color2: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+        offset: int = 0
+    ) -> None:
+        """
+        Fills buffer with alternating stripes with Anti-Aliasing.
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/fill/#stripes
+        """
+        if spacing <= 0:
+            raise ValueError("Stripes spacing must be positive")
+        
+        fill_stripes_f32(
+            image._buffer._handle,
+            image.width, image.height,
+            float(angle), int(spacing), int(width), int(offset),
+            color1, color2
+        )
+
+    @staticmethod
+    def dots(
+        image: Image,
+        spacing: int = 40,
+        radius: float = 10.0,
+        color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
+        bg_color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+        offset_x: int = 0,
+        offset_y: int = 0,
+        softness: float = 0.0
+    ) -> None:
+        """
+        Fills buffer with a Polka Dot pattern.
+        - softness: 0.0 = Hard edge, 1.0 = Soft glow.
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/fill/#dots
+        """
+        if spacing <= 0:
+            raise ValueError("Spacing must be positive")
+
+        fill_dots_f32(
+            image._buffer._handle,
+            image.width, image.height,
+            int(spacing), float(radius), 
+            int(offset_x), int(offset_y), float(softness),
+            color, bg_color
+        )
+
+    @staticmethod
+    def circle(
+        image: Image,
+        color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
+        bg_color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+        softness: float = 0.0
+    ) -> None:
+        """
+        Fills the buffer with a centered circle fitted to the image size.
+        - softness: Edge softness. 0.0 = Hard edge (with AA), >0.0 = Soft gradient.
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/fill/#circle
+        """
+
+        fill_circle_f32(
+            image._buffer._handle,
+            image.width, image.height,
+            float(softness),
+            color, bg_color
+        )
+
+    @staticmethod
+    def noise(
+        image: Image,
+        seed: float = 0.0,
+        monochrome: bool = True
+    ) -> None:
+        """
+        Fills the buffer with random White Noise.
+        - seed: Random seed. Change this to animate the noise.
+        - monochrome: True for grayscale noise, False for RGB noise.
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/fill/#noise
+        """
+        
+        fill_noise_f32(
+            image._buffer._handle,
+            image.width, image.height,
+            float(seed),
+            int(monochrome)
+        )
+
+    @staticmethod
+    def perlin(
+        image: Image,
+        scale: float = 50.0,
+        seed: float = 0.0,
+        octaves: int = 1,
+        persistence: float = 0.5,
+        lacunarity: float = 2.0,
+        offset_x: float = 0.0,
+        offset_y: float = 0.0,
+        color1: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 1.0),
+        color2: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0)
+    ) -> None:
+        """
+        Fills buffer with Perlin Noise (Gradient Noise).
+        - scale: "Zoom" level. Higher values = bigger features (zoomed in).
+        - octaves: Detail layers. 1 = smooth, 6 = rocky/detailed.
+        - persistence: How much each octave contributes (0.0 to 1.0).
+        - lacunarity: Detail frequency multiplier (usually 2.0).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/fill/#perlin-noise
+        """
+        if scale <= 0: scale = 0.001
+        
+        fill_perlin_f32(
+            image._buffer._handle,
+            image.width, image.height,
+            float(scale), float(seed),
+            int(octaves), float(persistence), float(lacunarity),
+            float(offset_x), float(offset_y),
+            color1, color2
+        )
+
+    @staticmethod
+    def ngon(
+        image: Image,
+        sides: int = 3,
+        color: tuple[float, float, float, float] = (1.0, 1.0, 1.0, 1.0),
+        bg_color: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0),
+        rotation: float = 0.0,
+        softness: float = 0.0
+    ) -> None:
+        """
+        Fills buffer with a Regular Polygon (Triangle, Pentagon, Hexagon...).
+        - softness: Edge softness (0.0 = Hard AA, >0.0 = Glow).
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/fill/#ngon
+        """
+        if sides < 3:
+            raise ValueError("Polygon must have at least 3 sides")
+
+        fill_ngon_f32(
+            image._buffer._handle,
+            image.width, image.height,
+            int(sides), float(rotation), float(softness),
+            color, bg_color
+        )

pyimagecuda/filter.py

@@ -0,0 +1,168 @@
+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)
+
+
+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:
+        """
+        Applies a Gaussian blur to the image (returns new image or writes to buffer).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/filter/#gaussian-blur
+        """
+
+        if sigma is None:
+            sigma = radius / 3.0
+        
+        if dst_buffer is None:
+            dst_buffer = Image(src.width, src.height)
+            return_dst = True
+        else:
+            ensure_capacity(dst_buffer, 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)
+            owns_temp = False
+
+        gaussian_blur_separable_f32(
+            src._buffer._handle,
+            temp_buffer._buffer._handle,
+            dst_buffer._buffer._handle,
+            src.width,
+            src.height,
+            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:
+        """
+        Sharpens the image (returns new image or writes to buffer).
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/filter/#sharpen
+        """
+
+        if dst_buffer is None:
+            dst_buffer = Image(src.width, src.height)
+            return_buffer = True
+        else:
+            ensure_capacity(dst_buffer, src.width, src.height)
+            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
+
+    @staticmethod
+    def sepia(image: Image, intensity: float = 1.0) -> None:
+        """
+        Applies Sepia tone (in-place).
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/filter/#sepia
+        """
+        
+        sepia_f32(image._buffer._handle, image.width, image.height, float(intensity))
+
+    @staticmethod
+    def invert(image: Image) -> None:
+        """
+        Inverts colors (Negative effect) in-place.
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/filter/#invert
+        """
+        invert_f32(image._buffer._handle, image.width, image.height)
+
+    @staticmethod
+    def threshold(image: Image, value: float = 0.5) -> None:
+        """
+        Converts to pure Black & White based on luminance threshold.
+        value: 0.0 to 1.0. Pixels brighter than value become white, others black.
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/filter/#threshold
+        """
+        threshold_f32(image._buffer._handle, image.width, image.height, float(value))
+
+    @staticmethod
+    def solarize(image: Image, threshold: float = 0.5) -> None:
+        """
+        Inverts only pixels brighter than threshold. Creates a psychedelic/retro look.
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/filter/#solarize
+        """
+        solarize_f32(image._buffer._handle, image.width, image.height, float(threshold))
+
+    @staticmethod
+    def sobel(src: Image, dst_buffer: Image | None = None) -> Image | None:
+        """
+        Detects edges using Sobel operator. Returns a black & white image with edges.
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/filter/#sobel
+        """
+        if dst_buffer is None:
+            dst_buffer = Image(src.width, src.height)
+            return_buffer = True
+        else:
+            ensure_capacity(dst_buffer, src.width, src.height)
+            return_buffer = False
+
+        filter_sobel_f32(
+            src._buffer._handle,
+            dst_buffer._buffer._handle,
+            src.width, src.height
+        )
+        return dst_buffer if return_buffer else None
+
+    @staticmethod
+    def emboss(src: Image, strength: float = 1.0, dst_buffer: Image | None = None) -> Image | None:
+        """
+        Applies Emboss (Relief) effect.
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/filter/#emboss
+        """
+        if dst_buffer is None:
+            dst_buffer = Image(src.width, src.height)
+            return_buffer = True
+        else:
+            ensure_capacity(dst_buffer, src.width, src.height)
+            return_buffer = False
+        
+        filter_emboss_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,95 @@
+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 __enter__(self):
+        return self
+    
+    def __exit__(self, exc_type, exc_value, traceback):
+        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):
+        """
+        Creates a floating-point image with the given width and height.
+        
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/image/#image-float32-precision
+        """
+        super().__init__(width, height, is_u8=False)
+
+
+class ImageU8(ImageBase):
+    
+    def __init__(self, width: int, height: int):
+        """
+        Creates an 8-bit unsigned integer image with the given width and height.
+
+        Docs & Examples: https://offerrall.github.io/pyimagecuda/image/#imageu8-8-bit-precision
+        """
+        super().__init__(width, height, is_u8=True)

pyimagecuda/io.py

@@ -0,0 +1,158 @@
+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 ensure_capacity
+
+
+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
+    """
+    ensure_capacity(dst, 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
+    """
+    ensure_capacity(dst, 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
+    """
+    ensure_capacity(dst, 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:
+        ensure_capacity(f32_buffer, width, height)
+        should_return = False
+
+    if u8_buffer is None:
+        u8_buffer = ImageU8(width, height)
+        owns_u8 = True
+    else:
+        ensure_capacity(u8_buffer, 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(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:
+        ensure_capacity(u8_buffer, image.width, image.height)
+        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()