smart-downscaler 0.1.0

package/README.md

@@ -0,0 +1,330 @@
+# Smart Pixel Art Downscaler
+
+A sophisticated Rust library for intelligent image downscaling with focus on pixel art quality. Combines global palette extraction, region-aware segmentation, and iterative refinement for optimal results.
+
+**Available as both a native Rust library and a WebAssembly module for browser/Node.js usage.**
+
+## Features
+
+- **Global Palette Extraction**: Median Cut + K-Means++ refinement in Lab color space for perceptually optimal palettes
+- **Multiple Segmentation Methods**:
+  - SLIC superpixels for fast, balanced regions
+  - VTracer-style hierarchical clustering for content-aware boundaries
+  - Union-find based fast hierarchical clustering
+- **Edge-Aware Processing**: Sobel/Scharr edge detection to preserve boundaries
+- **Neighbor-Coherent Assignment**: Spatial coherence through neighbor and region voting
+- **Two-Pass Refinement**: Iterative optimization for smooth results
+- **Graph-Cut Optimization**: Optional MRF energy minimization for advanced refinement
+- **WebAssembly Support**: Run in browsers with full performance
+
+## Installation
+
+### Native (Rust)
+
+Add to your `Cargo.toml`:
+
+```toml
+[dependencies]
+smart-downscaler = "0.1"
+```
+
+### WebAssembly (npm)
+
+```bash
+npm install smart-downscaler
+```
+
+Or use directly in browser:
+
+```html
+<script type="module">
+  import init, { downscale } from './pkg/web/smart_downscaler.js';
+  await init();
+</script>
+```
+
+## Quick Start
+
+### Native Rust
+
+```rust
+use smart_downscaler::prelude::*;
+
+fn main() {
+    let img = image::open("input.png").unwrap().to_rgb8();
+    let result = downscale(&img, 64, 64, 16);
+    result.save("output.png").unwrap();
+}
+```
+
+### WebAssembly (Browser)
+
+```javascript
+import init, { WasmDownscaleConfig, downscale_rgba } from 'smart-downscaler';
+
+// Initialize WASM
+await init();
+
+// Get image data from canvas
+const ctx = canvas.getContext('2d');
+const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+
+// Configure
+const config = new WasmDownscaleConfig();
+config.palette_size = 16;
+config.neighbor_weight = 0.3;
+config.segmentation_method = 'hierarchy_fast';
+
+// Downscale
+const result = downscale_rgba(
+  imageData.data,
+  canvas.width,
+  canvas.height,
+  64, 64,  // target size
+  config
+);
+
+// Use result
+const outputData = new ImageData(result.data, result.width, result.height);
+outputCtx.putImageData(outputData, 0, 0);
+
+// Access palette
+console.log(`Used ${result.palette_size} colors`);
+```
+
+### Using the JavaScript Wrapper
+
+For an even simpler API, use the included JavaScript wrapper:
+
+```javascript
+import { init, downscale, extractPalette, getPresetPalette } from './smart-downscaler.js';
+
+await init();
+
+// Simple downscale
+const result = downscale(canvas, 64, 64, {
+  paletteSize: 16,
+  segmentation: 'hierarchy_fast'
+});
+
+// With preset palette (Game Boy, NES, PICO-8, CGA)
+const gbPalette = getPresetPalette('gameboy');
+const gbResult = downscaleWithPalette(canvas, 64, 64, gbPalette);
+
+// Extract palette only
+const palette = extractPalette(canvas, 16);
+```
+
+## Building WebAssembly
+
+Requirements: [wasm-pack](https://rustwasm.github.io/wasm-pack/)
+
+```bash
+# Install wasm-pack
+cargo install wasm-pack
+
+# Build all targets
+./build-wasm.sh
+
+# Or manually:
+wasm-pack build --target web --features wasm --no-default-features --out-dir pkg/web
+```
+
+## WASM API Reference
+
+### Functions
+
+| Function | Description |
+|----------|-------------|
+| `downscale(data, w, h, tw, th, config?)` | Downscale RGBA image data |
+| `downscale_rgba(data, w, h, tw, th, config?)` | Same, for Uint8ClampedArray |
+| `downscale_simple(data, w, h, tw, th, colors)` | Simple API with color count |
+| `downscale_with_palette(data, w, h, tw, th, palette, config?)` | Use custom palette |
+| `extract_palette_from_image(data, w, h, colors, iters)` | Extract palette only |
+| `quantize_to_palette(data, w, h, palette)` | Quantize without resizing |
+
+### WasmDownscaleConfig
+
+```javascript
+const config = new WasmDownscaleConfig();
+config.palette_size = 16;           // Output colors
+config.kmeans_iterations = 5;       // Palette refinement
+config.neighbor_weight = 0.3;       // Spatial coherence [0-1]
+config.region_weight = 0.2;         // Region coherence [0-1]
+config.two_pass_refinement = true;  // Enable refinement
+config.refinement_iterations = 3;   // Refinement passes
+config.edge_weight = 0.5;           // Edge detection weight
+config.segmentation_method = 'hierarchy_fast'; // 'none'|'slic'|'hierarchy'|'hierarchy_fast'
+
+// Presets
+const fast = WasmDownscaleConfig.fast();
+const quality = WasmDownscaleConfig.quality();
+```
+
+### WasmDownscaleResult
+
+```javascript
+result.width          // Output width
+result.height         // Output height
+result.data           // Uint8ClampedArray (RGBA for ImageData)
+result.rgb_data()     // Uint8Array (RGB only)
+result.palette        // Uint8Array (RGB, 3 bytes per color)
+result.indices        // Uint8Array (palette index per pixel)
+result.palette_size   // Number of colors
+```
+
+## Command Line Interface
+
+```bash
+# Basic usage
+smart-downscaler input.png output.png -w 64 -h 64
+
+# With custom palette size
+smart-downscaler input.png output.png -w 128 -h 128 -p 32
+
+# Using scale factor
+smart-downscaler input.png output.png -s 0.125 -p 16
+
+# With SLIC segmentation
+smart-downscaler input.png output.png -w 64 -h 64 --segmentation slic
+```
+
+## Algorithm Details
+
+### 1. Global Palette Extraction
+
+The traditional per-tile k-means approach causes color drift across the image. We instead:
+
+1. Build a weighted color histogram from all source pixels
+2. Apply Median Cut to partition the color space, finding initial centroids with good distribution
+3. Refine centroids using K-Means++ in CIE Lab space for perceptual accuracy
+
+### 2. Region Pre-Segmentation
+
+Before downscaling, we identify coherent regions to preserve:
+
+**SLIC Superpixels:**
+- Iteratively clusters pixels by color and spatial proximity
+- Produces compact, regular regions
+- Fast and predictable
+
+**Hierarchical Clustering (VTracer-style):**
+- Bottom-up merging of similar adjacent pixels
+- Content-aware boundaries that follow natural edges
+- Configurable merge threshold and minimum region size
+
+**Fast Hierarchical (Union-Find):**
+- O(α(n)) per operation using union by rank + path compression
+- Best for large images where full hierarchical is too slow
+
+### 3. Edge-Aware Tile Computation
+
+Each output tile's color is computed as a weighted average of source pixels:
+
+```
+weight(pixel) = 1 / (1 + edge_strength * edge_weight)
+```
+
+This reduces the influence of transitional edge pixels, avoiding muddy colors from averaging across boundaries.
+
+### 4. Neighbor-Coherent Assignment
+
+When assigning each tile to a palette color, we consider:
+
+- **Color distance** to the tile's weighted average (primary factor)
+- **Neighbor votes**: already-assigned neighbors bias toward their colors
+- **Region membership**: tiles in the same source region prefer consistent colors
+
+The scoring function:
+```
+score(color) = distance(color, tile_avg) * (1 - neighbor_bias - region_bias)
+```
+
+### 5. Two-Pass Refinement
+
+After initial assignment, we iteratively refine:
+
+1. For each pixel, gather all 8 neighbors
+2. Re-evaluate the best palette color considering neighbor votes
+3. Update if a better assignment is found
+4. Repeat until convergence or max iterations
+
+This smooths isolated outliers while preserving intentional edges.
+
+### 6. Graph-Cut Optimization (Optional)
+
+For highest quality, we offer MRF energy minimization:
+
+- **Data term**: color distance between tile and palette color
+- **Smoothness term**: penalty for different labels between neighbors
+- **Alpha-expansion**: iteratively try changing each pixel to each label
+
+## Comparison with Existing Tools
+
+| Feature | Smart Downscaler | Per-Tile K-Means | Simple Resize |
+|---------|------------------|------------------|---------------|
+| Global color consistency | ✓ | ✗ | ✗ |
+| Edge preservation | ✓ | Partial | ✗ |
+| Region awareness | ✓ | ✗ | ✗ |
+| Spatial coherence | ✓ | ✗ | ✗ |
+| Two-pass refinement | ✓ | ✗ | ✗ |
+| Custom palette support | ✓ | ✓ | ✗ |
+| Perceptual color space | ✓ (Lab) | Often RGB | N/A |
+
+## Performance
+
+Typical performance on a modern CPU (single-threaded):
+
+| Image Size | Target Size | Palette | Time |
+|------------|-------------|---------|------|
+| 256×256 | 32×32 | 16 | ~50ms |
+| 512×512 | 64×64 | 32 | ~200ms |
+| 1024×1024 | 128×128 | 32 | ~800ms |
+| 2048×2048 | 256×256 | 64 | ~3s |
+
+Enable the `parallel` feature for multi-threaded processing on large images.
+
+## Configuration Reference
+
+### DownscaleConfig
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `palette_size` | usize | 16 | Number of colors in output palette |
+| `kmeans_iterations` | usize | 5 | K-Means refinement iterations |
+| `neighbor_weight` | f32 | 0.3 | Weight for neighbor coherence [0-1] |
+| `region_weight` | f32 | 0.2 | Weight for region coherence [0-1] |
+| `two_pass_refinement` | bool | true | Enable iterative refinement |
+| `refinement_iterations` | usize | 3 | Max refinement iterations |
+| `segmentation` | SegmentationMethod | Hierarchy | Pre-segmentation method |
+| `edge_weight` | f32 | 0.5 | Edge influence in tile averaging |
+
+### HierarchyConfig
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `merge_threshold` | f32 | 15.0 | Max color distance for merging |
+| `min_region_size` | usize | 4 | Minimum pixels per region |
+| `max_regions` | usize | 0 | Max regions (0 = unlimited) |
+| `spatial_weight` | f32 | 0.1 | Spatial proximity influence |
+
+### SlicConfig
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `num_superpixels` | usize | 100 | Approximate superpixel count |
+| `compactness` | f32 | 10.0 | Shape regularity (higher = more compact) |
+| `max_iterations` | usize | 10 | SLIC iterations |
+| `convergence_threshold` | f32 | 1.0 | Early termination threshold |
+
+## License
+
+MIT
+
+## Credits
+
+Inspired by:
+- VTracer's hierarchical clustering approach
+- SLIC superpixel algorithm
+- K-Means++ initialization
+- CIE Lab perceptual color space

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "smart-downscaler",
+  "type": "module",
+  "collaborators": [
+    "Pixagram"
+  ],
+  "description": "Intelligent pixel art downscaler with region-aware color quantization",
+  "version": "0.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pixagram/smart-downscaler"
+  },
+  "files": [
+    "smart_downscaler_bg.wasm",
+    "smart_downscaler.js",
+    "smart_downscaler_bg.js",
+    "smart_downscaler.d.ts"
+  ],
+  "main": "smart_downscaler.js",
+  "types": "smart_downscaler.d.ts",
+  "sideEffects": [
+    "./smart_downscaler.js",
+    "./snippets/*"
+  ],
+  "keywords": [
+    "pixel-art",
+    "image-processing",
+    "downscaling",
+    "quantization",
+    "wasm"
+  ]
+}

package/smart_downscaler.d.ts

@@ -0,0 +1,161 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class WasmDownscaleConfig {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new configuration with default values
+   */
+  constructor();
+  /**
+   * Create configuration optimized for speed
+   */
+  static fast(): WasmDownscaleConfig;
+  /**
+   * Create configuration optimized for quality
+   */
+  static quality(): WasmDownscaleConfig;
+  /**
+   * Number of colors in the output palette (default: 16)
+   */
+  palette_size: number;
+  /**
+   * K-Means iterations for palette refinement (default: 5)
+   */
+  kmeans_iterations: number;
+  /**
+   * Weight for neighbor color coherence [0.0, 1.0] (default: 0.3)
+   */
+  neighbor_weight: number;
+  /**
+   * Weight for region membership coherence [0.0, 1.0] (default: 0.2)
+   */
+  region_weight: number;
+  /**
+   * Enable two-pass refinement (default: true)
+   */
+  two_pass_refinement: boolean;
+  /**
+   * Maximum refinement iterations (default: 3)
+   */
+  refinement_iterations: number;
+  /**
+   * Edge weight in tile color computation (default: 0.5)
+   */
+  edge_weight: number;
+  /**
+   * For SLIC: approximate number of superpixels (default: 100)
+   */
+  slic_superpixels: number;
+  /**
+   * For SLIC: compactness factor (default: 10.0)
+   */
+  slic_compactness: number;
+  /**
+   * For hierarchy: merge threshold (default: 15.0)
+   */
+  hierarchy_threshold: number;
+  /**
+   * For hierarchy: minimum region size (default: 4)
+   */
+  hierarchy_min_size: number;
+  /**
+   * Get the segmentation method
+   */
+  segmentation_method: string;
+}
+
+export class WasmDownscaleResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get RGB pixel data as Uint8Array (without alpha)
+   */
+  rgb_data(): Uint8Array;
+  /**
+   * Get palette color at index as [r, g, b]
+   */
+  get_palette_color(index: number): Uint8Array;
+  /**
+   * Get output width
+   */
+  readonly width: number;
+  /**
+   * Get output height
+   */
+  readonly height: number;
+  /**
+   * Get RGBA pixel data as Uint8ClampedArray (for ImageData)
+   */
+  readonly data: Uint8ClampedArray;
+  /**
+   * Get palette as Uint8Array (RGB, 3 bytes per color)
+   */
+  readonly palette: Uint8Array;
+  /**
+   * Get palette indices for each pixel
+   */
+  readonly indices: Uint8Array;
+  /**
+   * Get number of colors in palette
+   */
+  readonly palette_size: number;
+}
+
+/**
+ * Main downscaling function for WebAssembly
+ *
+ * # Arguments
+ * * `image_data` - RGBA pixel data as Uint8Array or Uint8ClampedArray
+ * * `width` - Source image width
+ * * `height` - Source image height
+ * * `target_width` - Output image width
+ * * `target_height` - Output image height
+ * * `config` - Optional configuration (uses defaults if not provided)
+ *
+ * # Returns
+ * WasmDownscaleResult containing the downscaled image data
+ */
+export function downscale(image_data: Uint8Array, width: number, height: number, target_width: number, target_height: number, config?: WasmDownscaleConfig | null): WasmDownscaleResult;
+
+/**
+ * Downscale with RGBA input directly from ImageData
+ */
+export function downscale_rgba(image_data: Uint8ClampedArray, width: number, height: number, target_width: number, target_height: number, config?: WasmDownscaleConfig | null): WasmDownscaleResult;
+
+/**
+ * Simple downscale function with minimal parameters
+ */
+export function downscale_simple(image_data: Uint8Array, width: number, height: number, target_width: number, target_height: number, num_colors: number): WasmDownscaleResult;
+
+/**
+ * Downscale with a pre-defined palette
+ */
+export function downscale_with_palette(image_data: Uint8Array, width: number, height: number, target_width: number, target_height: number, palette_data: Uint8Array, config?: WasmDownscaleConfig | null): WasmDownscaleResult;
+
+/**
+ * Extract a color palette from an image without downscaling
+ */
+export function extract_palette_from_image(image_data: Uint8Array, _width: number, _height: number, num_colors: number, kmeans_iterations: number): Uint8Array;
+
+/**
+ * Initialize panic hook for better error messages in browser console
+ */
+export function init(): void;
+
+/**
+ * Log a message to the browser console (for debugging)
+ */
+export function log(message: string): void;
+
+/**
+ * Quantize an image to a specific palette without resizing
+ */
+export function quantize_to_palette(image_data: Uint8Array, width: number, height: number, palette_data: Uint8Array): WasmDownscaleResult;
+
+/**
+ * Get library version
+ */
+export function version(): string;

package/smart_downscaler.js

@@ -0,0 +1,5 @@
+import * as wasm from "./smart_downscaler_bg.wasm";
+export * from "./smart_downscaler_bg.js";
+import { __wbg_set_wasm } from "./smart_downscaler_bg.js";
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();

package/smart_downscaler_bg.js

@@ -0,0 +1,659 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const WasmDownscaleConfigFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmdownscaleconfig_free(ptr >>> 0, 1));
+
+const WasmDownscaleResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmdownscaleresult_free(ptr >>> 0, 1));
+
+/**
+ * Configuration options for the downscaler (JavaScript-compatible)
+ */
+export class WasmDownscaleConfig {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmDownscaleConfig.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmDownscaleConfigFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmDownscaleConfigFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmdownscaleconfig_free(ptr, 0);
+    }
+    /**
+     * Number of colors in the output palette (default: 16)
+     * @returns {number}
+     */
+    get palette_size() {
+        const ret = wasm.__wbg_get_wasmdownscaleconfig_palette_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of colors in the output palette (default: 16)
+     * @param {number} arg0
+     */
+    set palette_size(arg0) {
+        wasm.__wbg_set_wasmdownscaleconfig_palette_size(this.__wbg_ptr, arg0);
+    }
+    /**
+     * K-Means iterations for palette refinement (default: 5)
+     * @returns {number}
+     */
+    get kmeans_iterations() {
+        const ret = wasm.__wbg_get_wasmdownscaleconfig_kmeans_iterations(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * K-Means iterations for palette refinement (default: 5)
+     * @param {number} arg0
+     */
+    set kmeans_iterations(arg0) {
+        wasm.__wbg_set_wasmdownscaleconfig_kmeans_iterations(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Weight for neighbor color coherence [0.0, 1.0] (default: 0.3)
+     * @returns {number}
+     */
+    get neighbor_weight() {
+        const ret = wasm.__wbg_get_wasmdownscaleconfig_neighbor_weight(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Weight for neighbor color coherence [0.0, 1.0] (default: 0.3)
+     * @param {number} arg0
+     */
+    set neighbor_weight(arg0) {
+        wasm.__wbg_set_wasmdownscaleconfig_neighbor_weight(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Weight for region membership coherence [0.0, 1.0] (default: 0.2)
+     * @returns {number}
+     */
+    get region_weight() {
+        const ret = wasm.__wbg_get_wasmdownscaleconfig_region_weight(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Weight for region membership coherence [0.0, 1.0] (default: 0.2)
+     * @param {number} arg0
+     */
+    set region_weight(arg0) {
+        wasm.__wbg_set_wasmdownscaleconfig_region_weight(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Enable two-pass refinement (default: true)
+     * @returns {boolean}
+     */
+    get two_pass_refinement() {
+        const ret = wasm.__wbg_get_wasmdownscaleconfig_two_pass_refinement(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Enable two-pass refinement (default: true)
+     * @param {boolean} arg0
+     */
+    set two_pass_refinement(arg0) {
+        wasm.__wbg_set_wasmdownscaleconfig_two_pass_refinement(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Maximum refinement iterations (default: 3)
+     * @returns {number}
+     */
+    get refinement_iterations() {
+        const ret = wasm.__wbg_get_wasmdownscaleconfig_refinement_iterations(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Maximum refinement iterations (default: 3)
+     * @param {number} arg0
+     */
+    set refinement_iterations(arg0) {
+        wasm.__wbg_set_wasmdownscaleconfig_refinement_iterations(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Edge weight in tile color computation (default: 0.5)
+     * @returns {number}
+     */
+    get edge_weight() {
+        const ret = wasm.__wbg_get_wasmdownscaleconfig_edge_weight(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Edge weight in tile color computation (default: 0.5)
+     * @param {number} arg0
+     */
+    set edge_weight(arg0) {
+        wasm.__wbg_set_wasmdownscaleconfig_edge_weight(this.__wbg_ptr, arg0);
+    }
+    /**
+     * For SLIC: approximate number of superpixels (default: 100)
+     * @returns {number}
+     */
+    get slic_superpixels() {
+        const ret = wasm.__wbg_get_wasmdownscaleconfig_slic_superpixels(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * For SLIC: approximate number of superpixels (default: 100)
+     * @param {number} arg0
+     */
+    set slic_superpixels(arg0) {
+        wasm.__wbg_set_wasmdownscaleconfig_slic_superpixels(this.__wbg_ptr, arg0);
+    }
+    /**
+     * For SLIC: compactness factor (default: 10.0)
+     * @returns {number}
+     */
+    get slic_compactness() {
+        const ret = wasm.__wbg_get_wasmdownscaleconfig_slic_compactness(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * For SLIC: compactness factor (default: 10.0)
+     * @param {number} arg0
+     */
+    set slic_compactness(arg0) {
+        wasm.__wbg_set_wasmdownscaleconfig_slic_compactness(this.__wbg_ptr, arg0);
+    }
+    /**
+     * For hierarchy: merge threshold (default: 15.0)
+     * @returns {number}
+     */
+    get hierarchy_threshold() {
+        const ret = wasm.__wbg_get_wasmdownscaleconfig_hierarchy_threshold(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * For hierarchy: merge threshold (default: 15.0)
+     * @param {number} arg0
+     */
+    set hierarchy_threshold(arg0) {
+        wasm.__wbg_set_wasmdownscaleconfig_hierarchy_threshold(this.__wbg_ptr, arg0);
+    }
+    /**
+     * For hierarchy: minimum region size (default: 4)
+     * @returns {number}
+     */
+    get hierarchy_min_size() {
+        const ret = wasm.__wbg_get_wasmdownscaleconfig_hierarchy_min_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * For hierarchy: minimum region size (default: 4)
+     * @param {number} arg0
+     */
+    set hierarchy_min_size(arg0) {
+        wasm.__wbg_set_wasmdownscaleconfig_hierarchy_min_size(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Create a new configuration with default values
+     */
+    constructor() {
+        const ret = wasm.wasmdownscaleconfig_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmDownscaleConfigFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Set the segmentation method
+     * @param {string} method
+     */
+    set segmentation_method(method) {
+        const ptr0 = passStringToWasm0(method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasmdownscaleconfig_set_segmentation_method(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Get the segmentation method
+     * @returns {string}
+     */
+    get segmentation_method() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmdownscaleconfig_segmentation_method(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Create configuration optimized for speed
+     * @returns {WasmDownscaleConfig}
+     */
+    static fast() {
+        const ret = wasm.wasmdownscaleconfig_fast();
+        return WasmDownscaleConfig.__wrap(ret);
+    }
+    /**
+     * Create configuration optimized for quality
+     * @returns {WasmDownscaleConfig}
+     */
+    static quality() {
+        const ret = wasm.wasmdownscaleconfig_quality();
+        return WasmDownscaleConfig.__wrap(ret);
+    }
+}
+if (Symbol.dispose) WasmDownscaleConfig.prototype[Symbol.dispose] = WasmDownscaleConfig.prototype.free;
+
+/**
+ * Result of downscaling operation
+ */
+export class WasmDownscaleResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmDownscaleResult.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmDownscaleResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmDownscaleResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmdownscaleresult_free(ptr, 0);
+    }
+    /**
+     * Get output width
+     * @returns {number}
+     */
+    get width() {
+        const ret = wasm.wasmdownscaleresult_width(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get output height
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.wasmdownscaleresult_height(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get RGBA pixel data as Uint8ClampedArray (for ImageData)
+     * @returns {Uint8ClampedArray}
+     */
+    get data() {
+        const ret = wasm.wasmdownscaleresult_data(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get RGB pixel data as Uint8Array (without alpha)
+     * @returns {Uint8Array}
+     */
+    rgb_data() {
+        const ret = wasm.wasmdownscaleresult_rgb_data(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get palette as Uint8Array (RGB, 3 bytes per color)
+     * @returns {Uint8Array}
+     */
+    get palette() {
+        const ret = wasm.wasmdownscaleresult_palette(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get palette indices for each pixel
+     * @returns {Uint8Array}
+     */
+    get indices() {
+        const ret = wasm.wasmdownscaleresult_indices(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get number of colors in palette
+     * @returns {number}
+     */
+    get palette_size() {
+        const ret = wasm.wasmdownscaleresult_palette_size(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get palette color at index as [r, g, b]
+     * @param {number} index
+     * @returns {Uint8Array}
+     */
+    get_palette_color(index) {
+        const ret = wasm.wasmdownscaleresult_get_palette_color(this.__wbg_ptr, index);
+        return ret;
+    }
+}
+if (Symbol.dispose) WasmDownscaleResult.prototype[Symbol.dispose] = WasmDownscaleResult.prototype.free;
+
+/**
+ * Main downscaling function for WebAssembly
+ *
+ * # Arguments
+ * * `image_data` - RGBA pixel data as Uint8Array or Uint8ClampedArray
+ * * `width` - Source image width
+ * * `height` - Source image height
+ * * `target_width` - Output image width
+ * * `target_height` - Output image height
+ * * `config` - Optional configuration (uses defaults if not provided)
+ *
+ * # Returns
+ * WasmDownscaleResult containing the downscaled image data
+ * @param {Uint8Array} image_data
+ * @param {number} width
+ * @param {number} height
+ * @param {number} target_width
+ * @param {number} target_height
+ * @param {WasmDownscaleConfig | null} [config]
+ * @returns {WasmDownscaleResult}
+ */
+export function downscale(image_data, width, height, target_width, target_height, config) {
+    let ptr0 = 0;
+    if (!isLikeNone(config)) {
+        _assertClass(config, WasmDownscaleConfig);
+        ptr0 = config.__destroy_into_raw();
+    }
+    const ret = wasm.downscale(image_data, width, height, target_width, target_height, ptr0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmDownscaleResult.__wrap(ret[0]);
+}
+
+/**
+ * Downscale with RGBA input directly from ImageData
+ * @param {Uint8ClampedArray} image_data
+ * @param {number} width
+ * @param {number} height
+ * @param {number} target_width
+ * @param {number} target_height
+ * @param {WasmDownscaleConfig | null} [config]
+ * @returns {WasmDownscaleResult}
+ */
+export function downscale_rgba(image_data, width, height, target_width, target_height, config) {
+    let ptr0 = 0;
+    if (!isLikeNone(config)) {
+        _assertClass(config, WasmDownscaleConfig);
+        ptr0 = config.__destroy_into_raw();
+    }
+    const ret = wasm.downscale_rgba(image_data, width, height, target_width, target_height, ptr0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmDownscaleResult.__wrap(ret[0]);
+}
+
+/**
+ * Simple downscale function with minimal parameters
+ * @param {Uint8Array} image_data
+ * @param {number} width
+ * @param {number} height
+ * @param {number} target_width
+ * @param {number} target_height
+ * @param {number} num_colors
+ * @returns {WasmDownscaleResult}
+ */
+export function downscale_simple(image_data, width, height, target_width, target_height, num_colors) {
+    const ret = wasm.downscale_simple(image_data, width, height, target_width, target_height, num_colors);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmDownscaleResult.__wrap(ret[0]);
+}
+
+/**
+ * Downscale with a pre-defined palette
+ * @param {Uint8Array} image_data
+ * @param {number} width
+ * @param {number} height
+ * @param {number} target_width
+ * @param {number} target_height
+ * @param {Uint8Array} palette_data
+ * @param {WasmDownscaleConfig | null} [config]
+ * @returns {WasmDownscaleResult}
+ */
+export function downscale_with_palette(image_data, width, height, target_width, target_height, palette_data, config) {
+    let ptr0 = 0;
+    if (!isLikeNone(config)) {
+        _assertClass(config, WasmDownscaleConfig);
+        ptr0 = config.__destroy_into_raw();
+    }
+    const ret = wasm.downscale_with_palette(image_data, width, height, target_width, target_height, palette_data, ptr0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmDownscaleResult.__wrap(ret[0]);
+}
+
+/**
+ * Extract a color palette from an image without downscaling
+ * @param {Uint8Array} image_data
+ * @param {number} _width
+ * @param {number} _height
+ * @param {number} num_colors
+ * @param {number} kmeans_iterations
+ * @returns {Uint8Array}
+ */
+export function extract_palette_from_image(image_data, _width, _height, num_colors, kmeans_iterations) {
+    const ret = wasm.extract_palette_from_image(image_data, _width, _height, num_colors, kmeans_iterations);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Initialize panic hook for better error messages in browser console
+ */
+export function init() {
+    wasm.init();
+}
+
+/**
+ * Log a message to the browser console (for debugging)
+ * @param {string} message
+ */
+export function log(message) {
+    const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.log(ptr0, len0);
+}
+
+/**
+ * Quantize an image to a specific palette without resizing
+ * @param {Uint8Array} image_data
+ * @param {number} width
+ * @param {number} height
+ * @param {Uint8Array} palette_data
+ * @returns {WasmDownscaleResult}
+ */
+export function quantize_to_palette(image_data, width, height, palette_data) {
+    const ret = wasm.quantize_to_palette(image_data, width, height, palette_data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return WasmDownscaleResult.__wrap(ret[0]);
+}
+
+/**
+ * Get library version
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.version();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+export function __wbg___wbindgen_throw_dd24417ed36fc46e(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbg_length_22ac23eaec9d8053(arg0) {
+    const ret = arg0.length;
+    return ret;
+};
+
+export function __wbg_log_1d990106d99dacb7(arg0) {
+    console.log(arg0);
+};
+
+export function __wbg_new_6421f6084cc5bc5a(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+};
+
+export function __wbg_new_from_slice_de10fccb49c7f3c0(arg0, arg1) {
+    const ret = new Uint8ClampedArray(getArrayU8FromWasm0(arg0, arg1));
+    return ret;
+};
+
+export function __wbg_new_from_slice_f9c22b9153b26992(arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+    return ret;
+};
+
+export function __wbg_new_with_length_aa5eaf41d35235e5(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return ret;
+};
+
+export function __wbg_prototypesetcall_dfe9b766cdc1f1fd(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+};
+
+export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+};
+
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+};