smart-downscaler 0.3.8 → 0.3.9

package/package.json

@@ -5,7 +5,7 @@
     "Pixagram"
   ],
   "description": "Intelligent pixel art downscaler with region-aware color quantization",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "license": "MIT",
   "repository": {
     "type": "git",

package/smart_downscaler.d.ts

@@ -1,6 +1,30 @@
 /* tslint:disable */
 /* eslint-disable */
 
+export class ColorAnalysisResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    getColor(index: number): ColorEntry | undefined;
+    getColorsFlat(): Uint8Array;
+    toJson(): ColorEntry[];
+    readonly colorCount: number;
+    readonly success: boolean;
+    readonly totalPixels: number;
+}
+
+export class ColorEntry {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly hex: string;
+    b: number;
+    count: number;
+    g: number;
+    percentage: number;
+    r: number;
+}
+
 export class SmartDownscaler {
     free(): void;
     [Symbol.dispose](): void;
@@ -22,6 +46,26 @@ export class SmartDownscaler {
     set_slic_params(region_size: number, _compactness: number, _iterations: number): void;
 }
 
+export class WasmDownscaleConfig {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor();
+    set_edge_weight(weight: number): void;
+    set_hierarchy_params(threshold: number): void;
+    set_k_centroid(k: number): void;
+    set_k_centroid_iterations(iterations: number): void;
+    set_kmeans_iterations(iterations: number): void;
+    set_max_color_preprocess(count: number): void;
+    set_max_resolution(mp: number): void;
+    set_neighbor_weight(weight: number): void;
+    set_palette_size(size: number): void;
+    set_palette_strategy(strategy: number): void;
+    set_refinement_iterations(iterations: number): void;
+    set_region_weight(weight: number): void;
+    set_segmentation_method(method: number): void;
+    set_slic_params(region_size: number, _compactness: number, _iterations: number): void;
+}
+
 export class WasmDownscaleResult {
     private constructor();
     free(): void;
@@ -32,3 +76,7 @@ export class WasmDownscaleResult {
     height(): number;
     width(): number;
 }
+
+export function analyze_colors(image_data: Uint8Array, max_colors: number, sort_method: string): ColorAnalysisResult;
+
+export function downscale_rgba(image_data: Uint8Array, width: number, height: number, target_width: number, target_height: number, config: WasmDownscaleConfig): WasmDownscaleResult;

package/smart_downscaler.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./smart_downscaler_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    SmartDownscaler, WasmDownscaleResult
+    ColorAnalysisResult, ColorEntry, SmartDownscaler, WasmDownscaleConfig, WasmDownscaleResult, analyze_colors, downscale_rgba
 } from "./smart_downscaler_bg.js";

package/smart_downscaler_bg.js

@@ -1,3 +1,172 @@
+export class ColorAnalysisResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ColorAnalysisResult.prototype);
+        obj.__wbg_ptr = ptr;
+        ColorAnalysisResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ColorAnalysisResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_coloranalysisresult_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get colorCount() {
+        const ret = wasm.coloranalysisresult_color_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} index
+     * @returns {ColorEntry | undefined}
+     */
+    getColor(index) {
+        const ret = wasm.coloranalysisresult_getColor(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : ColorEntry.__wrap(ret);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    getColorsFlat() {
+        const ret = wasm.coloranalysisresult_getColorsFlat(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get success() {
+        const ret = wasm.coloranalysisresult_success(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {ColorEntry[]}
+     */
+    toJson() {
+        const ret = wasm.coloranalysisresult_toJson(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {number}
+     */
+    get totalPixels() {
+        const ret = wasm.coloranalysisresult_total_pixels(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ColorAnalysisResult.prototype[Symbol.dispose] = ColorAnalysisResult.prototype.free;
+
+export class ColorEntry {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ColorEntry.prototype);
+        obj.__wbg_ptr = ptr;
+        ColorEntryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ColorEntryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_colorentry_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.colorentry_hex(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);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get b() {
+        const ret = wasm.__wbg_get_colorentry_b(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get count() {
+        const ret = wasm.__wbg_get_colorentry_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get g() {
+        const ret = wasm.__wbg_get_colorentry_g(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get percentage() {
+        const ret = wasm.__wbg_get_colorentry_percentage(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get r() {
+        const ret = wasm.__wbg_get_colorentry_r(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set b(arg0) {
+        wasm.__wbg_set_colorentry_b(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set count(arg0) {
+        wasm.__wbg_set_colorentry_count(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set g(arg0) {
+        wasm.__wbg_set_colorentry_g(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set percentage(arg0) {
+        wasm.__wbg_set_colorentry_percentage(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set r(arg0) {
+        wasm.__wbg_set_colorentry_r(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) ColorEntry.prototype[Symbol.dispose] = ColorEntry.prototype.free;
+
 export class SmartDownscaler {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -118,6 +287,112 @@ export class SmartDownscaler {
 }
 if (Symbol.dispose) SmartDownscaler.prototype[Symbol.dispose] = SmartDownscaler.prototype.free;
 
+export class WasmDownscaleConfig {
+    __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);
+    }
+    constructor() {
+        const ret = wasm.smartdownscaler_new();
+        this.__wbg_ptr = ret >>> 0;
+        WasmDownscaleConfigFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {number} weight
+     */
+    set_edge_weight(weight) {
+        wasm.smartdownscaler_set_edge_weight(this.__wbg_ptr, weight);
+    }
+    /**
+     * @param {number} threshold
+     */
+    set_hierarchy_params(threshold) {
+        wasm.wasmdownscaleconfig_set_hierarchy_params(this.__wbg_ptr, threshold);
+    }
+    /**
+     * @param {number} k
+     */
+    set_k_centroid(k) {
+        wasm.smartdownscaler_set_k_centroid(this.__wbg_ptr, k);
+    }
+    /**
+     * @param {number} iterations
+     */
+    set_k_centroid_iterations(iterations) {
+        wasm.smartdownscaler_set_k_centroid_iterations(this.__wbg_ptr, iterations);
+    }
+    /**
+     * @param {number} iterations
+     */
+    set_kmeans_iterations(iterations) {
+        wasm.smartdownscaler_set_kmeans_iterations(this.__wbg_ptr, iterations);
+    }
+    /**
+     * @param {number} count
+     */
+    set_max_color_preprocess(count) {
+        wasm.smartdownscaler_set_max_color_preprocess(this.__wbg_ptr, count);
+    }
+    /**
+     * @param {number} mp
+     */
+    set_max_resolution(mp) {
+        wasm.smartdownscaler_set_max_resolution(this.__wbg_ptr, mp);
+    }
+    /**
+     * @param {number} weight
+     */
+    set_neighbor_weight(weight) {
+        wasm.smartdownscaler_set_neighbor_weight(this.__wbg_ptr, weight);
+    }
+    /**
+     * @param {number} size
+     */
+    set_palette_size(size) {
+        wasm.smartdownscaler_set_palette_size(this.__wbg_ptr, size);
+    }
+    /**
+     * @param {number} strategy
+     */
+    set_palette_strategy(strategy) {
+        wasm.smartdownscaler_set_palette_strategy(this.__wbg_ptr, strategy);
+    }
+    /**
+     * @param {number} iterations
+     */
+    set_refinement_iterations(iterations) {
+        wasm.smartdownscaler_set_refinement_iterations(this.__wbg_ptr, iterations);
+    }
+    /**
+     * @param {number} weight
+     */
+    set_region_weight(weight) {
+        wasm.smartdownscaler_set_region_weight(this.__wbg_ptr, weight);
+    }
+    /**
+     * @param {number} method
+     */
+    set_segmentation_method(method) {
+        wasm.wasmdownscaleconfig_set_segmentation_method(this.__wbg_ptr, method);
+    }
+    /**
+     * @param {number} region_size
+     * @param {number} _compactness
+     * @param {number} _iterations
+     */
+    set_slic_params(region_size, _compactness, _iterations) {
+        wasm.wasmdownscaleconfig_set_slic_params(this.__wbg_ptr, region_size, _compactness, _iterations);
+    }
+}
+if (Symbol.dispose) WasmDownscaleConfig.prototype[Symbol.dispose] = WasmDownscaleConfig.prototype.free;
+
 export class WasmDownscaleResult {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -179,9 +454,45 @@ export class WasmDownscaleResult {
     }
 }
 if (Symbol.dispose) WasmDownscaleResult.prototype[Symbol.dispose] = WasmDownscaleResult.prototype.free;
+
+/**
+ * @param {Uint8Array} image_data
+ * @param {number} max_colors
+ * @param {string} sort_method
+ * @returns {ColorAnalysisResult}
+ */
+export function analyze_colors(image_data, max_colors, sort_method) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(sort_method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.analyze_colors(ptr0, len0, max_colors, ptr1, len1);
+    return ColorAnalysisResult.__wrap(ret);
+}
+
+/**
+ * @param {Uint8Array} image_data
+ * @param {number} width
+ * @param {number} height
+ * @param {number} target_width
+ * @param {number} target_height
+ * @param {WasmDownscaleConfig} config
+ * @returns {WasmDownscaleResult}
+ */
+export function downscale_rgba(image_data, width, height, target_width, target_height, config) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(config, WasmDownscaleConfig);
+    const ret = wasm.downscale_rgba(ptr0, len0, width, height, target_width, target_height, config.__wbg_ptr);
+    return WasmDownscaleResult.__wrap(ret);
+}
 export function __wbg___wbindgen_throw_be289d5034ed271b(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
+export function __wbg_colorentry_new(arg0) {
+    const ret = ColorEntry.__wrap(arg0);
+    return ret;
+}
 export function __wbindgen_init_externref_table() {
     const table = wasm.__wbindgen_externrefs;
     const offset = table.grow(4);
@@ -191,18 +502,52 @@ export function __wbindgen_init_externref_table() {
     table.set(offset + 2, true);
     table.set(offset + 3, false);
 }
+const ColorAnalysisResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_coloranalysisresult_free(ptr >>> 0, 1));
+const ColorEntryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_colorentry_free(ptr >>> 0, 1));
 const SmartDownscalerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_smartdownscaler_free(ptr >>> 0, 1));
+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));
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return decodeText(ptr, len);
@@ -223,6 +568,43 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+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;
+}
+
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 cachedTextDecoder.decode();
 const MAX_SAFARI_DECODE_BYTES = 2146435072;
@@ -237,6 +619,19 @@ function decodeText(ptr, 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;