image-js 0.35.0 → 0.35.2

package/index.d.ts

@@ -77,12 +77,30 @@ export declare class Image {
     min?: number;
     max?: number;
   }): this;
-  // add
-  // subtract
-  // subtractImage
-  // multiply
-  // divide
-  // hypotenuse
+  add(
+    value: Array<number> | Image | number,
+    options?: { channels?: Array<Channel> },
+  ): this;
+  subtract(
+    value: Array<number> | Image | number,
+    options?: { channels?: Array<Channel> },
+  ): this;
+  subtractImage(
+    otherImage: Image,
+    options?: { channels?: Array<Channel>; absolute?: boolean },
+  ): this;
+  multiply(
+    value: Array<number> | Image | number,
+    options?: { channels?: Array<Channel> },
+  ): this;
+  divide(
+    value: Array<number> | Image | number,
+    options?: { channels?: Array<Channel> },
+  ): this;
+  hypotenuse(
+    otherImage: Image,
+    options?: { bitDepth?: number; channels?: Array<Channel> },
+  ): Image;
   // background
   flipX(): this;
   flipY(): this;
@@ -106,45 +124,95 @@ export declare class Image {
   blackHat(options?: MorphologicalOptions): Image;
   morphologicalGradient(options?: MorphologicalOptions): Image;
 
-  // warpingFourPoints
+  warpingFourPoints(
+    pts: Array<Array<number>>,
+    options?: {
+      calculateRatio?: boolean;
+    },
+  ): Image;
   crop(options?: CropOptions): Image;
-  // cropAlpha
+  cropAlpha(options?: { threshold?: number }): Image;
   resize(options?: ResizeOptions): Image;
-  // hsv
-  // hsl
-  // cmyk
-  // rgba8
+  hsv(): Image;
+  hsl(): Image;
+  cmyk(): Image;
+  rgba8(): Image;
   grey(options?: GreyOptions): Image;
   mask(options?: MaskOptions): Image;
-  // pad
-  // colorDepth
-  // setBorder
+  pad(options?: {
+    size?: number;
+    algorithm?: 'set' | 'copy';
+    color?: Array<number>;
+  }): Image;
+  colorDepth(newColorDepth: 8 | 16): Image;
+  setBorder(options?: {
+    size?: number;
+    algorithm?: 'set' | 'copy';
+    color?: Array<number>;
+  }): Image;
   rotate(angle: number, options?: RotateOptions): Image;
   rotateLeft(): Image;
   rotateRight(): Image;
 
-  // getRow
-  // getColumn
-  // getMatrix
-  // setMatrix
-  // getPixelsArray
-  // getIntersection
-  // getClosestCommonParent
-  // getThreshold
-
-  // split
-  // getChannel
-  // combineChannels
+  getRow(row: number, channel?: number): Array<number>;
+  getColumn(row: number, channel?: number): Array<number>;
+  getMatrix(options?: { channel?: number }): Matrix;
+  setMatrix(matrix: Matrix, options?: { channel?: number });
+  getPixelsArray(): Array<Array<number>>;
+  getIntersection(mask2: Image): object;
+  getClosestCommonParent(mask: Image): Image;
+  getThreshold(options?: { algorithm?: ThresholdAlgorithm }): number;
+
+  split(options?: { preserveAlpha?: boolean }): Stack;
+  getChannel(
+    channel: Channel,
+    options?: { keepAlpha?: boolean; mergeAlpha?: boolean },
+  ): Image;
+  combineChannels(
+    method?: Function,
+    options?: { keepAlpha?: boolean; mergeAlpha?: boolean },
+  ): Image;
   setChannel(channel: any, image: Image): this;
-  // getSimilarity
-  // getPixelsGrid
-  // getBestMatch
+  getSimilarity(
+    image: Image,
+    options?: {
+      shift?: Array<number>;
+      average?: boolean;
+      channels?: Array<Channel>;
+      defaultAlpha?: boolean;
+      normalize?: boolean;
+      border?: Array<number>;
+    },
+  ): Array<number> | number;
+  getPixelsGrid(options?: {
+    sampling?: Array<number>;
+    painted?: boolean;
+    mask?: Image;
+  }): { xyS: Array<number>; zS: Array<number>; painted: Image };
+  getBestMatch(
+    image: Image,
+    options?: { border?: Array<number> },
+  ): Array<number>;
 
   // cannyEdge
   convolution(kernel: Kernel, options?: ConvolutionOptions): Image;
-  // extract
+  extract(
+    mask: Image,
+    options?: {
+      position?: Array<number>;
+    },
+  ): this;
   // floodFill
-  // paintLabels
+  paintLabels(
+    labels: Array<string>,
+    positions: Array<Array<number>>,
+    options?: {
+      color?: Array<number> | string;
+      colors?: Array<Array<number>> | Array<string>;
+      font?: string | Array<string>;
+      rotate?: number | Array<number>;
+    },
+  ): this;
   paintMasks(
     masks: Image | Array<Image>,
     options?: {
@@ -158,35 +226,87 @@ export declare class Image {
       labelColor?: string;
       labelFont?: string;
     },
-  ): Image;
-  // paintPoints
-  // paintPolyline
-  // paintPolylines
+  ): this;
+  paintPoints(
+    points: Array<Array<number>>,
+    options?: {
+      color?: Array<number> | string;
+      colors?: Array<Array<number>> | Array<string>;
+      randomColors?: boolean;
+      distinctColors?: boolean;
+      shape?: object;
+    },
+  ): this;
+  paintPolyline(
+    points: Array<Array<number>>,
+    options?: {
+      color?: Array<number>;
+      closed?: boolean;
+    },
+  ): this;
+  paintPolylines(
+    polylines: Array<Array<Array<number>>>,
+    options?: {
+      color?: Array<number> | string;
+      colors?: Array<Array<number>> | Array<string>;
+      randomColors?: boolean;
+      distinctColors?: boolean;
+      shape?: object;
+    },
+  ): this;
   paintPolygon(
     points: Array<Array<number>>,
     options?: {
       color?: Array<number>;
       filled?: boolean;
     },
-  ): Image;
-
-  // paintPolygons
-
-  // countAlphaPixels
-  // monotoneChainConvexHull
-  // minimalBoundingRectangle
-  // getHistogram
-  // getHistograms
-  // getColorHistogram
-  // getMin
-  // getMax
-  // getSum
-  // getMoment
-  // getLocalMaxima
-  // getMedian
-  // getMean
-  // getPoints
-  // getRelativePosition
+  ): this;
+  paintPolygons(
+    points: Array<Array<Array<number>>>,
+    options?: {
+      color?: Array<number> | string;
+      colors?: Array<Array<number>> | Array<string>;
+      randomColors?: boolean;
+      distinctColors?: boolean;
+      shape?: object;
+    },
+  ): this;
+
+  countAlphaPixels(options?: { alpha?: number }): number;
+  monotoneChainConvexHull(): Array<Array<number>>;
+  minimalBoundingRectangle(options?: {
+    originalPoints?: Array<Array<number>>;
+  }): Array<Array<number>>;
+  getHistogram(options?: {
+    maxSlots?: number;
+    channel?: number;
+    useAlpha?: boolean;
+  }): Array<number>;
+  getHistograms(options?: { maxSlots?: number }): Array<Array<number>>;
+  getColorHistogram(options?: {
+    useAlpha?: boolean;
+    nbSlots?: number;
+  }): Array<number>;
+  getMin(): Array<number>;
+  getMax(): Array<number>;
+  getSum(): Array<number>;
+  getMoment(xPower: number, yPower: number): number;
+  getLocalMaxima(options?: {
+    mask?: Image;
+    region?: number;
+    removeClosePoints?: number;
+    invert?: boolean;
+    maxEquals?: number;
+  }): Array<number>;
+  getMedian(): Array<number>;
+  getMean(): Array<number>;
+  getPoints(): Array<Array<number>>;
+  getRelativePosition(
+    targetImage: Image,
+    options?: {
+      defaultFurther?: boolean;
+    },
+  ): Array<number> | boolean;
 }
 
 export declare class Stack extends Array<Image> {
@@ -208,6 +328,15 @@ export declare class Stack extends Array<Image> {
 
 export declare class RoiManager {}
 
+export declare class Matrix extends Array<Array<number>> {
+  constructor();
+  constructor(width: number, height: number, defaultValue?: number);
+
+  localMin(x: number, y: number): { position: Array<number>; value: number };
+  localMax(x: number, y: number): { position: Array<number>; value: number };
+  localSearch(x: number, y: number, value: number): Array<Array<number>>;
+}
+
 export interface ImageConstructorOptions {
   width?: number;
   height?: number;
@@ -391,5 +520,6 @@ export type BinaryValue = 0 | 1;
 export type SelectedChannels = number | string | Array<number> | Array<string>;
 export type BinaryKernel = Array<Array<BinaryValue>>;
 export type Kernel = Array<Array<number>>;
+export type Channel = number | string;
 
 export default Image;

package/lib/image/operator/paintLabels.js

@@ -10,15 +10,15 @@ var _color = require("../../util/color");
 var _model = require("../model/model");
 
 /**
- * Paint a mask or masks on the current image.
+ * Paint a label or labels on the current image.
  * @memberof Image
  * @instance
  *
- * @param {Array<string>}       [labels] - Array of labels to display. Should the the same size as masks.
- * @param {Array<Array>}        [positions] - Array of labels to display. Should the the same size as masks.
- * @param {object}              [options]
- * @param {number[]|string}     [options.color='red'] - Array of 3 elements (R, G, B) or a valid css color.
- * @param {Array<Array<number>>|Array<string>} [options.colors] - Array of Array of 3 elements (R, G, B) for each color of each mask
+ * @param {Array<string>}           [labels] - Array of labels to display.
+ * @param {Array<Array<number>>}    [positions] - Array of points [x,y] where the labels should be displayed.
+ * @param {object}                  [options]
+ * @param {Array<number>|string}    [options.color='red'] - Array of 3 elements (R, G, B) or a valid css color.
+ * @param {Array<Array<number>>|Array<string>} [options.colors] - Array of Array of 3 elements (R, G, B) for each color of each label.
  * @param {string|Array<string>} [options.font='12px Helvetica'] - Paint the labels in a different CSS style
  * @param {number|Array<number>} [options.rotate=0] - Rotate each label of a define angle
  * @return {this} The original painted image

package/lib/image/operator/paintPolygon.js

@@ -12,7 +12,7 @@ exports.default = paintPolygon;
  * @param {Array<Array<number>>} points - Array of [x,y] points
  * @param {object} [options]
  * @param {Array<number>} [options.color=[max,0,0]] - Array of 3 elements (R, G, B), default is red.
- * @param {Array<number>} [options.filled=false] - If you want the polygon to be filled or not.
+ * @param {boolean} [options.filled=false] - If you want the polygon to be filled or not.
  * @return {this} The original painted image
  */
 function paintPolygon(points, options = {}) {

package/lib/image/operator/paintPolygons.js

@@ -8,10 +8,10 @@ exports.default = paintPolygons;
 var _color = require("../../util/color");
 
 /**
- * Paint an array of polygon on the current image.
+ * Paint an array of polygons on the current image.
  * @memberof Image
  * @instance
- * @param {Array<Array<number>>} polygons - Array of array of [x,y] points
+ * @param {Array<Array<Array<number>>>} polygons - Array of array of [x,y] points
  * @param {object} [options]
  * @param {Array<number>|string}     [options.color] - Array of 3 elements (R, G, B) or a valid css color.
  * @param {Array<Array<number>>|Array<string>} [options.colors] - Array of Array of 3 elements (R, G, B) for each color of each mask

package/lib/image/operator/paintPolylines.js

@@ -11,7 +11,7 @@ var _color = require("../../util/color");
  * Paint polylines on the current image.
  * @memberof Image
  * @instance
- * @param {Array<Array<number>>} polylines - Array of array of [x,y] points
+ * @param {Array<Array<Array<number>>>} polylines - Array of array of [x,y] points
  * @param {object} [options]
  * @param {Array<number>|string}     [options.color] - Array of 3 elements (R, G, B) or a valid css color.
  * @param {Array<Array<number>>|Array<string>} [options.colors] - Array of Array of 3 elements (R, G, B) for each color of each mask

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "image-js",
-  "version": "0.35.0",
+  "version": "0.35.2",
   "description": "Image processing and manipulation in JavaScript",
   "keywords": [
     "image",
@@ -81,7 +81,7 @@
     "@swiftcarrot/color-fns": "^3.2.0",
     "blob-util": "^2.0.2",
     "canny-edge-detector": "^1.0.0",
-    "fast-bmp": "^1.0.0",
+    "fast-bmp": "^2.0.1",
     "fast-jpeg": "^1.0.1",
     "fast-list": "^1.0.3",
     "fast-png": "^6.1.0",

package/src/image/operator/paintLabels.js

@@ -2,15 +2,15 @@ import { css2array } from '../../util/color';
 import { RGB } from '../model/model';
 
 /**
- * Paint a mask or masks on the current image.
+ * Paint a label or labels on the current image.
  * @memberof Image
  * @instance
  *
- * @param {Array<string>}       [labels] - Array of labels to display. Should the the same size as masks.
- * @param {Array<Array>}        [positions] - Array of labels to display. Should the the same size as masks.
- * @param {object}              [options]
- * @param {number[]|string}     [options.color='red'] - Array of 3 elements (R, G, B) or a valid css color.
- * @param {Array<Array<number>>|Array<string>} [options.colors] - Array of Array of 3 elements (R, G, B) for each color of each mask
+ * @param {Array<string>}           [labels] - Array of labels to display.
+ * @param {Array<Array<number>>}    [positions] - Array of points [x,y] where the labels should be displayed.
+ * @param {object}                  [options]
+ * @param {Array<number>|string}    [options.color='red'] - Array of 3 elements (R, G, B) or a valid css color.
+ * @param {Array<Array<number>>|Array<string>} [options.colors] - Array of Array of 3 elements (R, G, B) for each color of each label.
  * @param {string|Array<string>} [options.font='12px Helvetica'] - Paint the labels in a different CSS style
  * @param {number|Array<number>} [options.rotate=0] - Rotate each label of a define angle
  * @return {this} The original painted image

package/src/image/operator/paintPolygon.js

@@ -5,7 +5,7 @@
  * @param {Array<Array<number>>} points - Array of [x,y] points
  * @param {object} [options]
  * @param {Array<number>} [options.color=[max,0,0]] - Array of 3 elements (R, G, B), default is red.
- * @param {Array<number>} [options.filled=false] - If you want the polygon to be filled or not.
+ * @param {boolean} [options.filled=false] - If you want the polygon to be filled or not.
  * @return {this} The original painted image
  */
 export default function paintPolygon(points, options = {}) {

package/src/image/operator/paintPolygons.js

@@ -1,10 +1,10 @@
 import { getColors } from '../../util/color';
 
 /**
- * Paint an array of polygon on the current image.
+ * Paint an array of polygons on the current image.
  * @memberof Image
  * @instance
- * @param {Array<Array<number>>} polygons - Array of array of [x,y] points
+ * @param {Array<Array<Array<number>>>} polygons - Array of array of [x,y] points
  * @param {object} [options]
  * @param {Array<number>|string}     [options.color] - Array of 3 elements (R, G, B) or a valid css color.
  * @param {Array<Array<number>>|Array<string>} [options.colors] - Array of Array of 3 elements (R, G, B) for each color of each mask

package/src/image/operator/paintPolylines.js

@@ -4,7 +4,7 @@ import { getColors } from '../../util/color';
  * Paint polylines on the current image.
  * @memberof Image
  * @instance
- * @param {Array<Array<number>>} polylines - Array of array of [x,y] points
+ * @param {Array<Array<Array<number>>>} polylines - Array of array of [x,y] points
  * @param {object} [options]
  * @param {Array<number>|string}     [options.color] - Array of 3 elements (R, G, B) or a valid css color.
  * @param {Array<Array<number>>|Array<string>} [options.colors] - Array of Array of 3 elements (R, G, B) for each color of each mask