init

Author: offerrall

.github/workflows/build.yml

@@ -0,0 +1,33 @@
+name: Build Minimal Test
+
+on: [push]
+
+jobs:
+  build_wheels:
+    name: Build on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [windows-2022]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install CUDA Toolkit
+        uses: Jimver/cuda-toolkit@v0.2.21
+        with:
+          cuda: '12.5.1'
+          method: 'network'
+          use-github-cache: 'true'
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v2.21.3
+        env:
+          CIBW_ARCHS_WINDOWS: "AMD64"
+          CIBW_SKIP: "cp36-* cp37-* cp38-* cp39-* pp*"
+          CIBW_BUILD_VERBOSITY: 1
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels
+          path: ./wheelhouse/*.whl

.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyd
+build/
+dist/
+wheelhouse/
+*.obj
+*.lib
+*.exp
+.vscode/

CMakeLists.txt

@@ -0,0 +1,26 @@
+cmake_minimum_required(VERSION 3.18)
+
+set(CMAKE_CUDA_RUNTIME_LIBRARY Static)
+
+project(pyimagecuda_internal LANGUAGES CXX CUDA)
+
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CUDA_STANDARD 14)
+
+if(NOT CMAKE_CUDA_ARCHITECTURES)
+    set(CMAKE_CUDA_ARCHITECTURES "50;60;61;70;75;80;86;89")
+endif()
+
+find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
+find_package(CUDAToolkit REQUIRED)
+
+file(GLOB_RECURSE SOURCES "src/*.cu" "src/*.cpp")
+
+python_add_library(pyimagecuda_internal MODULE ${SOURCES} WITH_SOABI)
+
+target_include_directories(pyimagecuda_internal PRIVATE src)
+
+target_link_libraries(pyimagecuda_internal PRIVATE CUDA::cudart_static Python::Module)
+
+install(TARGETS pyimagecuda_internal DESTINATION pyimagecuda)
+install(DIRECTORY pyimagecuda DESTINATION .)

README.md

@@ -0,0 +1,22 @@
+# 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:
+
+```python
+import pyimagecuda
+# Verifies drivers, loads the DLL, and runs a test kernel
+pyimagecuda.check_system()
+```

examples/blend.py

@@ -0,0 +1,42 @@
+from pyimagecuda import Image, load, save, Fill, Blend
+
+
+# Create background with gradient
+background = Image(1920, 1080)
+Fill.gradient(background, 
+              rgba1=(0.2, 0.3, 0.5, 1.0),  # Dark blue
+              rgba2=(0.8, 0.4, 0.6, 1.0),  # Pink
+              direction='diagonal')
+save(background, "./background_gradient.jpg")
+
+# Load overlay image
+overlay = load("examples/test.jpg")
+
+# Blend overlay onto gradient background
+Blend.normal(background, overlay, pos_x=100, pos_y=50, opacity=0.8)
+save(background, "./blended_on_gradient.jpg")
+
+# Create solid color background
+background.free()
+background = Image(1920, 1080)
+Fill.color(background, rgba=(0.1, 0.1, 0.15, 1.0))  # Dark gray
+
+# Multiply blend
+Blend.multiply(background, overlay, pos_x=200, pos_y=100, opacity=0.9)
+save(background, "./blended_multiply.jpg")
+
+# Radial gradient background
+background.free()
+background = Image(1920, 1080)
+Fill.gradient(background,
+              rgba1=(1.0, 1.0, 1.0, 1.0),  # White center
+              rgba2=(0.0, 0.0, 0.0, 1.0),  # Black edges
+              direction='radial')
+
+# Screen blend
+Blend.screen(background, overlay, pos_x=400, pos_y=300, opacity=0.7)
+save(background, "./blended_screen.jpg")
+
+
+background.free()
+overlay.free()

examples/effect.py

@@ -0,0 +1,64 @@
+from pyimagecuda import Image, save, Fill, Blend, Effect
+
+
+# Create large transparent canvas
+canvas = Image(1920, 1080)
+Fill.color(canvas, rgba=(0.0, 0.0, 0.0, 0.0))
+
+# Create smaller square with gradient
+square_size = 600
+square = Image(square_size, square_size)
+Fill.gradient(square,
+              rgba1=(0.2, 0.5, 0.9, 1.0),  # Blue
+              rgba2=(0.9, 0.3, 0.6, 1.0),  # Pink
+              direction='diagonal')
+
+# Round the corners
+Effect.rounded_corners(square, radius=60.0)
+
+# Blend square onto canvas FIRST (centered)
+pos_x = (canvas.width - square_size) // 2
+pos_y = (canvas.height - square_size) // 2
+Blend.normal(canvas, square, pos_x=pos_x, pos_y=pos_y)
+
+# Apply drop shadow with auto-allocated buffers
+canvas_with_shadow = Effect.drop_shadow(canvas,
+                                        offset_x=20,
+                                        offset_y=20,
+                                        blur=40,
+                                        color=(0.0, 0.0, 0.0, 0.7))
+
+save(canvas_with_shadow, "./effect_showcase.png")
+
+
+# --- VERSION WITH CACHED BUFFERS FOR PERFORMANCE ---
+
+# Pre-allocate reusable buffers
+dst_buffer = Image(canvas.width, canvas.height)
+shadow_buffer = Image(canvas.width, canvas.height)
+temp_buffer = Image(canvas.width, canvas.height)
+
+# Reset canvas for second version
+Fill.color(canvas, rgba=(0.0, 0.0, 0.0, 0.0))
+Blend.normal(canvas, square, pos_x=pos_x, pos_y=pos_y)
+
+# Apply drop shadow with cached buffers (no allocation)
+Effect.drop_shadow(canvas,
+                   offset_x=20,
+                   offset_y=20,
+                   blur=40,
+                   color=(0.0, 0.0, 0.0, 0.7),
+                   dst_buffer=dst_buffer,
+                   shadow_buffer=shadow_buffer,
+                   temp_buffer=temp_buffer)
+
+save(dst_buffer, "./effect_showcase_cached.png")
+
+
+# Cleanup
+canvas.free()
+square.free()
+canvas_with_shadow.free()
+dst_buffer.free()
+shadow_buffer.free()
+temp_buffer.free()

examples/filters.py

@@ -0,0 +1,37 @@
+from pyimagecuda import Image, load, save, Filter
+
+
+# Load image
+image = load("examples/test.jpg")
+
+# Gaussian blur - auto-allocated buffers
+blurred = Filter.gaussian_blur(image, radius=10)
+save(blurred, "./blurred_auto.jpg")
+
+# Gaussian blur - with custom sigma
+blurred_custom = Filter.gaussian_blur(image, radius=15, sigma=5.0)
+save(blurred_custom, "./blurred_custom_sigma.jpg")
+
+# Sharpen filter
+sharpened = Filter.sharpen(image, strength=1.5)
+save(sharpened, "./sharpened.jpg")
+
+# Reuse buffers for performance
+dst_buffer = Image(image.width, image.height)
+temp_buffer = Image(image.width, image.height)
+
+Filter.gaussian_blur(image, radius=20, dst_buffer=dst_buffer, temp_buffer=temp_buffer)
+save(dst_buffer, "./blurred_reused.jpg")
+
+# Chain filters using buffer reuse
+Filter.gaussian_blur(image, radius=5, dst_buffer=dst_buffer, temp_buffer=temp_buffer)
+Filter.sharpen(dst_buffer, strength=2.0, dst_buffer=dst_buffer)
+save(dst_buffer, "./blur_then_sharpen.jpg")
+
+
+image.free()
+blurred.free()
+blurred_custom.free()
+sharpened.free()
+dst_buffer.free()
+temp_buffer.free()

examples/resize.py

@@ -0,0 +1,21 @@
+from pyimagecuda import Image, load, save, Resize
+
+
+target_resolution = (1024, 768)
+
+image = load("examples/test.jpg")
+cache_result = Image(*target_resolution)
+
+
+# No dst buffer provided, a new Image will be created and returned
+resized_image = Resize.bilinear(image, *target_resolution)
+save(resized_image, "./resized_test.jpg")
+
+# Reuse existing dst buffer
+Resize.bilinear(image, *target_resolution, dst_buffer=cache_result)
+save(cache_result, "./resized_test_cached.jpg")
+
+
+image.free()
+resized_image.free()
+cache_result.free()

examples/test.jpg

@@ -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