wasm-image-processor 0.4.0 → 0.5.0

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "wasm-image-processor",
-  "type": "module",
   "collaborators": [
     "Stanley Masinde <hello@stanleymasinde.com>"
   ],
   "description": "High-performance client-side image processing toolkit powered by Rust and WebAssembly",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -17,7 +16,7 @@
     "wasm_image_processor_bg.js",
     "wasm_image_processor.d.ts"
   ],
-  "main": "wasm_image_processor.js",
+  "module": "wasm_image_processor.js",
   "homepage": "https://github.com/StanleyMasinde/wasm-image-processor",
   "types": "wasm_image_processor.d.ts",
   "sideEffects": [

package/wasm_image_processor.d.ts

@@ -1,5 +1,64 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Invert the colors on this image.
+ */
+export function invert(image_data: Uint8Array): Uint8Array;
+/**
+ * Hue rotate the supplied image.
+ * `value` is the degrees to rotate each pixel by.
+ * 0 and 360 do nothing, the rest rotates by the given degree value.
+ * just like the css webkit filter hue-rotate(180)
+ */
+export function hue_rotate(image_data: Uint8Array, degrees: number): Uint8Array;
+/**
+ * Scale this image down to fit within a specific size.
+ * Returns a new image. The image's aspect ratio is preserved.
+ * The image is scaled to the maximum possible size that fits
+ * within the bounds specified by `nwidth` and `nheight`.
+ *
+ * This method uses a fast integer algorithm where each source
+ * pixel contributes to exactly one target pixel.
+ * May give aliasing artifacts if new size is close to old size.
+ */
+export function thumbnail(image_data: Uint8Array, width: number, height: number): Uint8Array;
+/**
+ * Adjust the contrast of this image.
+ * `contrast` is the amount to adjust the contrast by.
+ * Negative values decrease the contrast and positive values increase the contrast.
+ */
+export function contrast(image_data: Uint8Array, value: number): Uint8Array;
+/**
+ * Performs a Gaussian blur on this image.
+ * `sigma` is a measure of how much to blur by.
+ * Use a value of less than 5
+ */
+export function blur(image_data: Uint8Array, sigma: number): Uint8Array;
+/**
+ * Performs a fast blur on this image.
+ * `sigma` is the standard deviation of the
+ * (approximated) Gaussian
+ */
+export function fast_blur(image_data: Uint8Array, sigma: number): Uint8Array;
+/**
+ * Resize an image
+ * Take an array of bytes, the len and the width
+ * The image's aspect ratio is preserved.
+ * The image is scaled to the maximum possible size that fits
+ * within the bounds specified by `width` and `height`
+ */
+export function resize(image_data: Uint8Array, width: number, height: number): Uint8Array;
+/**
+ * Return a cut-out of this image delimited by the bounding rectangle.
+ */
+export function crop(image_data: Uint8Array, x: number, y: number, width: number, height: number): Uint8Array;
+/**
+ * Add grayscale effect to image
+ * Return a grayscale version of this image.
+ * Returns `Luma` images in most cases. However, for `f32` images,
+ * this will return a grayscale `Rgb/Rgba` image instead.
+ */
+export function grayscale(image_data: Uint8Array): Uint8Array;
 /**
  * Resize an image by the given dimension.
  * The first parameter is an array of bytes.
@@ -9,3 +68,8 @@
  * It is is ideal for icon resizing.
  */
 export function resize_square(image_data: Uint8Array, side: number): Uint8Array;
+/**
+ * Brighten image
+ * The value is -100 to 100
+ */
+export function brighten(image_data: Uint8Array, value: number): Uint8Array;

package/wasm_image_processor_bg.js

@@ -43,6 +43,194 @@ function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
+/**
+ * Invert the colors on this image.
+ * @param {Uint8Array} image_data
+ * @returns {Uint8Array}
+ */
+export function invert(image_data) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.invert(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Hue rotate the supplied image.
+ * `value` is the degrees to rotate each pixel by.
+ * 0 and 360 do nothing, the rest rotates by the given degree value.
+ * just like the css webkit filter hue-rotate(180)
+ * @param {Uint8Array} image_data
+ * @param {number} degrees
+ * @returns {Uint8Array}
+ */
+export function hue_rotate(image_data, degrees) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.hue_rotate(ptr0, len0, degrees);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Scale this image down to fit within a specific size.
+ * Returns a new image. The image's aspect ratio is preserved.
+ * The image is scaled to the maximum possible size that fits
+ * within the bounds specified by `nwidth` and `nheight`.
+ *
+ * This method uses a fast integer algorithm where each source
+ * pixel contributes to exactly one target pixel.
+ * May give aliasing artifacts if new size is close to old size.
+ * @param {Uint8Array} image_data
+ * @param {number} width
+ * @param {number} height
+ * @returns {Uint8Array}
+ */
+export function thumbnail(image_data, width, height) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.thumbnail(ptr0, len0, width, height);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Adjust the contrast of this image.
+ * `contrast` is the amount to adjust the contrast by.
+ * Negative values decrease the contrast and positive values increase the contrast.
+ * @param {Uint8Array} image_data
+ * @param {number} value
+ * @returns {Uint8Array}
+ */
+export function contrast(image_data, value) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.contrast(ptr0, len0, value);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Performs a Gaussian blur on this image.
+ * `sigma` is a measure of how much to blur by.
+ * Use a value of less than 5
+ * @param {Uint8Array} image_data
+ * @param {number} sigma
+ * @returns {Uint8Array}
+ */
+export function blur(image_data, sigma) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.blur(ptr0, len0, sigma);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Performs a fast blur on this image.
+ * `sigma` is the standard deviation of the
+ * (approximated) Gaussian
+ * @param {Uint8Array} image_data
+ * @param {number} sigma
+ * @returns {Uint8Array}
+ */
+export function fast_blur(image_data, sigma) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.fast_blur(ptr0, len0, sigma);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Resize an image
+ * Take an array of bytes, the len and the width
+ * The image's aspect ratio is preserved.
+ * The image is scaled to the maximum possible size that fits
+ * within the bounds specified by `width` and `height`
+ * @param {Uint8Array} image_data
+ * @param {number} width
+ * @param {number} height
+ * @returns {Uint8Array}
+ */
+export function resize(image_data, width, height) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.resize(ptr0, len0, width, height);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Return a cut-out of this image delimited by the bounding rectangle.
+ * @param {Uint8Array} image_data
+ * @param {number} x
+ * @param {number} y
+ * @param {number} width
+ * @param {number} height
+ * @returns {Uint8Array}
+ */
+export function crop(image_data, x, y, width, height) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.crop(ptr0, len0, x, y, width, height);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * Add grayscale effect to image
+ * Return a grayscale version of this image.
+ * Returns `Luma` images in most cases. However, for `f32` images,
+ * this will return a grayscale `Rgb/Rgba` image instead.
+ * @param {Uint8Array} image_data
+ * @returns {Uint8Array}
+ */
+export function grayscale(image_data) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.grayscale(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
 /**
  * Resize an image by the given dimension.
  * The first parameter is an array of bytes.
@@ -66,6 +254,25 @@ export function resize_square(image_data, side) {
     return v2;
 }
 
+/**
+ * Brighten image
+ * The value is -100 to 100
+ * @param {Uint8Array} image_data
+ * @param {number} value
+ * @returns {Uint8Array}
+ */
+export function brighten(image_data, value) {
+    const ptr0 = passArray8ToWasm0(image_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.brighten(ptr0, len0, value);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
 export function __wbindgen_init_externref_table() {
     const table = wasm.__wbindgen_export_0;
     const offset = table.grow(4);