k-centroid-scaler 1.3.0 → 1.3.1

package/k_centroid_scaler.d.ts

@@ -1,26 +1,11 @@
 /* tslint:disable */
 /* eslint-disable */
 export function k_centroid_resize(image_data: Uint8Array, original_width: number, original_height: number, target_width: number, target_height: number, centroids: number, iterations: number): ImageResult;
-/**
- * Stage 1: Fast quantization to 256 colors or less using k-means++ in RGB space
- * This stage is fast and doesn't alter tints significantly
- */
-export function quantize_colors_stage1(image_data: Uint8Array, width: number, height: number, target_colors: number): ImageResult;
-/**
- * Stage 2: Perceptually accurate quantization using CIELAB color space
- * Best for final color reduction where human perception matters
- */
-export function quantize_colors_stage2_lab(image_data: Uint8Array, width: number, height: number, target_colors: number, dithering: boolean): ImageResult;
-/**
- * Complete two-stage quantization: Stage 1 (fast) -> Stage 2 (perceptual)
- */
-export function quantize_colors_two_stage(image_data: Uint8Array, width: number, height: number, target_colors: number, dithering: boolean): ImageResult;
+export function quantize_perceptual(image_data: Uint8Array, width: number, height: number, num_colors: number, dithering: boolean): ImageResult;
 export function quantize_colors_median_cut(image_data: Uint8Array, width: number, height: number, num_colors: number, dithering: boolean): ImageResult;
-export function quantize_colors_kmeans(image_data: Uint8Array, width: number, height: number, num_colors: number, _iterations: number, dithering: boolean): ImageResult;
-export function extract_palette(image_data: Uint8Array, max_colors: number): ColorPalette;
+export function extract_palette(image_data: Uint8Array, num_colors: number): ColorPalette;
 export function analyze_colors(image_data: Uint8Array, max_colors: number, sort_method: string): ColorAnalysis;
 export function get_dominant_colors(image_data: Uint8Array, num_colors: number, min_coverage: number): ColorAnalysis;
-export function process_image(data: Uint8Array, width: number, height: number, target_width: number, target_height: number, centroids: number, iterations: number): any;
 export class ColorAnalysis {
   private constructor();
   free(): void;
@@ -79,17 +64,13 @@ export interface InitOutput {
   readonly __wbg_set_coloranalysis_total_pixels: (a: number, b: number) => void;
   readonly coloranalysis_colors: (a: number, b: number) => void;
   readonly k_centroid_resize: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
-  readonly quantize_colors_stage1: (a: number, b: number, c: number, d: number, e: number) => number;
-  readonly quantize_colors_stage2_lab: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+  readonly quantize_perceptual: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
   readonly quantize_colors_median_cut: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
-  readonly quantize_colors_kmeans: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
   readonly extract_palette: (a: number, b: number, c: number) => number;
   readonly analyze_colors: (a: number, b: number, c: number, d: number, e: number) => number;
   readonly get_dominant_colors: (a: number, b: number, c: number, d: number) => number;
-  readonly process_image: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
   readonly __wbg_set_imageresult_width: (a: number, b: number) => void;
   readonly __wbg_set_imageresult_height: (a: number, b: number) => void;
-  readonly quantize_colors_two_stage: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
   readonly __wbg_get_colorpalette_count: (a: number) => number;
   readonly __wbg_get_imageresult_height: (a: number) => number;
   readonly __wbg_get_imageresult_width: (a: number) => number;

package/k_centroid_scaler.js

@@ -4,8 +4,6 @@ let heap = new Array(128).fill(undefined);
 
 heap.push(undefined, null, true, false);
 
-function getObject(idx) { return heap[idx]; }
-
 let heap_next = heap.length;
 
 function addHeapObject(obj) {
@@ -17,19 +15,7 @@ function addHeapObject(obj) {
     return idx;
 }
 
-let cachedUint8ArrayMemory0 = null;
-
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
+function getObject(idx) { return heap[idx]; }
 
 function handleError(f, args) {
     try {
@@ -106,6 +92,15 @@ function debugString(val) {
 
 let WASM_VECTOR_LEN = 0;
 
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
 const cachedTextEncoder = new TextEncoder();
 
 if (!('encodeInto' in cachedTextEncoder)) {
@@ -200,6 +195,11 @@ function takeObject(idx) {
     return ret;
 }
 
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 function getArrayJsValueFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     const mem = getDataViewMemory0();
@@ -234,51 +234,17 @@ export function k_centroid_resize(image_data, original_width, original_height, t
 }
 
 /**
- * Stage 1: Fast quantization to 256 colors or less using k-means++ in RGB space
- * This stage is fast and doesn't alter tints significantly
  * @param {Uint8Array} image_data
  * @param {number} width
  * @param {number} height
- * @param {number} target_colors
- * @returns {ImageResult}
- */
-export function quantize_colors_stage1(image_data, width, height, target_colors) {
-    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_export_1);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.quantize_colors_stage1(ptr0, len0, width, height, target_colors);
-    return ImageResult.__wrap(ret);
-}
-
-/**
- * Stage 2: Perceptually accurate quantization using CIELAB color space
- * Best for final color reduction where human perception matters
- * @param {Uint8Array} image_data
- * @param {number} width
- * @param {number} height
- * @param {number} target_colors
- * @param {boolean} dithering
- * @returns {ImageResult}
- */
-export function quantize_colors_stage2_lab(image_data, width, height, target_colors, dithering) {
-    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_export_1);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.quantize_colors_stage2_lab(ptr0, len0, width, height, target_colors, dithering);
-    return ImageResult.__wrap(ret);
-}
-
-/**
- * Complete two-stage quantization: Stage 1 (fast) -> Stage 2 (perceptual)
- * @param {Uint8Array} image_data
- * @param {number} width
- * @param {number} height
- * @param {number} target_colors
+ * @param {number} num_colors
  * @param {boolean} dithering
  * @returns {ImageResult}
  */
-export function quantize_colors_two_stage(image_data, width, height, target_colors, dithering) {
+export function quantize_perceptual(image_data, width, height, num_colors, dithering) {
     const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_export_1);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.quantize_colors_median_cut(ptr0, len0, width, height, target_colors, dithering);
+    const ret = wasm.quantize_perceptual(ptr0, len0, width, height, num_colors, dithering);
     return ImageResult.__wrap(ret);
 }
 
@@ -299,29 +265,13 @@ export function quantize_colors_median_cut(image_data, width, height, num_colors
 
 /**
  * @param {Uint8Array} image_data
- * @param {number} width
- * @param {number} height
  * @param {number} num_colors
- * @param {number} _iterations
- * @param {boolean} dithering
- * @returns {ImageResult}
- */
-export function quantize_colors_kmeans(image_data, width, height, num_colors, _iterations, dithering) {
-    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_export_1);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.quantize_colors_kmeans(ptr0, len0, width, height, num_colors, _iterations, dithering);
-    return ImageResult.__wrap(ret);
-}
-
-/**
- * @param {Uint8Array} image_data
- * @param {number} max_colors
  * @returns {ColorPalette}
  */
-export function extract_palette(image_data, max_colors) {
+export function extract_palette(image_data, num_colors) {
     const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_export_1);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.extract_palette(ptr0, len0, max_colors);
+    const ret = wasm.extract_palette(ptr0, len0, num_colors);
     return ColorPalette.__wrap(ret);
 }
 
@@ -353,23 +303,6 @@ export function get_dominant_colors(image_data, num_colors, min_coverage) {
     return ColorAnalysis.__wrap(ret);
 }
 
-/**
- * @param {Uint8Array} data
- * @param {number} width
- * @param {number} height
- * @param {number} target_width
- * @param {number} target_height
- * @param {number} centroids
- * @param {number} iterations
- * @returns {any}
- */
-export function process_image(data, width, height, target_width, target_height, centroids, iterations) {
-    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export_1);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.process_image(ptr0, len0, width, height, target_width, target_height, centroids, iterations);
-    return takeObject(ret);
-}
-
 const ColorAnalysisFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_coloranalysis_free(ptr >>> 0, 1));
@@ -679,21 +612,10 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
-    imports.wbg.__wbg_length_6bb7e81f9d7713e4 = function(arg0) {
-        const ret = getObject(arg0).length;
-        return ret;
-    };
     imports.wbg.__wbg_new_19c25a3f2fa63a02 = function() {
         const ret = new Object();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_newwithlength_a167dcc7aaa3ba77 = function(arg0) {
-        const ret = new Uint8Array(arg0 >>> 0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_set_1353b2a5e96bc48c = function(arg0, arg1, arg2) {
-        getObject(arg0).set(getArrayU8FromWasm0(arg1, arg2));
-    };
     imports.wbg.__wbg_set_453345bcda80b89a = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
         return ret;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "k-centroid-scaler",
   "type": "module",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "files": [
     "k_centroid_scaler_bg.wasm",
     "k_centroid_scaler.js",