image-js 0.35.1 → 0.35.3

package/lib/image/operator/convolution.js

@@ -4,23 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = convolution;
-
 var _mlMatrixConvolution = require("ml-matrix-convolution");
-
 var _channel = require("../../util/channel");
-
 var _kernel = require("../../util/kernel");
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 var _clamp = require("../internal/clamp");
-
 var _convolutionSeparable = _interopRequireDefault(require("./convolutionSeparable"));
-
 var _getSeparatedKernel = _interopRequireDefault(require("./getSeparatedKernel"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * @memberof Image
  * @instance
@@ -47,11 +38,8 @@ function convolution(kernel, options = {}) {
   } = options;
   let createOptions = {};
   if (bitDepth) createOptions.bitDepth = bitDepth;
-
   let newImage = _Image.default.createFrom(this, createOptions);
-
   channels = (0, _channel.validateArrayOfChannels)(this, channels, true);
-
   if (algorithm !== 'separable') {
     ({
       kernel
@@ -59,10 +47,8 @@ function convolution(kernel, options = {}) {
   } else if (!Array.isArray(kernel) || kernel.length !== 2) {
     throw new RangeError('separable convolution requires two arrays of numbers to represent the kernel');
   }
-
   if (algorithm === 'auto') {
     let separatedKernel = (0, _getSeparatedKernel.default)(kernel);
-
     if (separatedKernel !== null) {
       algorithm = 'separable';
       kernel = separatedKernel;
@@ -72,9 +58,7 @@ function convolution(kernel, options = {}) {
       algorithm = 'direct';
     }
   }
-
   let halfHeight, halfWidth;
-
   if (algorithm === 'separable') {
     halfHeight = Math.floor(kernel[0].length / 2);
     halfWidth = Math.floor(kernel[1].length / 2);
@@ -82,21 +66,18 @@ function convolution(kernel, options = {}) {
     halfHeight = Math.floor(kernel.length / 2);
     halfWidth = Math.floor(kernel[0].length / 2);
   }
-
   let clamped = newImage.isClamped;
   let tmpData = new Array(this.height * this.width);
   let index, x, y, channel, c, tmpResult;
-
   for (channel = 0; channel < channels.length; channel++) {
-    c = channels[channel]; // Copy the channel in a single array
-
+    c = channels[channel];
+    // Copy the channel in a single array
     for (y = 0; y < this.height; y++) {
       for (x = 0; x < this.width; x++) {
         index = y * this.width + x;
         tmpData[index] = this.data[index * this.channels + c];
       }
     }
-
     if (algorithm === 'direct') {
       tmpResult = (0, _mlMatrixConvolution.direct)(tmpData, kernel, {
         rows: this.height,
@@ -106,17 +87,14 @@ function convolution(kernel, options = {}) {
       });
     } else if (algorithm === 'separable') {
       tmpResult = (0, _convolutionSeparable.default)(tmpData, kernel, this.width, this.height);
-
       if (normalize) {
         divisor = 0;
-
         for (let i = 0; i < kernel[0].length; i++) {
           for (let j = 0; j < kernel[1].length; j++) {
             divisor += kernel[0][i] * kernel[1][j];
           }
         }
       }
-
       if (divisor !== 1) {
         for (let i = 0; i < tmpResult.length; i++) {
           tmpResult[i] /= divisor;
@@ -129,13 +107,12 @@ function convolution(kernel, options = {}) {
         normalize: normalize,
         divisor: divisor
       });
-    } // Copy the result to the output image
-
+    }
 
+    // Copy the result to the output image
     for (y = 0; y < this.height; y++) {
       for (x = 0; x < this.width; x++) {
         index = y * this.width + x;
-
         if (clamped) {
           newImage.data[index * this.channels + c] = (0, _clamp.clamp)(tmpResult[index], newImage);
         } else {
@@ -143,27 +120,25 @@ function convolution(kernel, options = {}) {
         }
       }
     }
-  } // if the kernel was not applied on the alpha channel we just copy it
+  }
+  // if the kernel was not applied on the alpha channel we just copy it
   // TODO: in general we should copy the channels that where not changed
   // TODO: probably we should just copy the image at the beginning ?
-
-
   if (this.alpha && !channels.includes(this.channels)) {
     for (x = this.components; x < this.data.length; x = x + this.channels) {
       newImage.data[x] = this.data[x];
     }
-  } // I only can have 3 types of borders:
+  }
+
+  // I only can have 3 types of borders:
   //  1. Considering the image as periodic: periodic
   //  2. Extend the interior borders: copy
   //  3. fill with a color: set
-
-
   if (border !== 'periodic') {
     newImage.setBorder({
       size: [halfWidth, halfHeight],
       algorithm: border
     });
   }
-
   return newImage;
 }

package/lib/image/operator/convolutionSeparable.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = convolutionSeparable;
-
 var _mlConvolution = require("ml-convolution");
-
 function convolutionSeparable(data, separatedKernel, width, height) {
   const result = new Array(data.length);
   let tmp, conv, offset, kernel;
@@ -14,35 +12,27 @@ function convolutionSeparable(data, separatedKernel, width, height) {
   offset = (kernel.length - 1) / 2;
   conv = new Array(width + kernel.length - 1);
   tmp = new Array(width);
-
   for (let y = 0; y < height; y++) {
     for (let x = 0; x < width; x++) {
       tmp[x] = data[y * width + x];
     }
-
     (0, _mlConvolution.directConvolution)(tmp, kernel, conv);
-
     for (let x = 0; x < width; x++) {
       result[y * width + x] = conv[offset + x];
     }
   }
-
   kernel = separatedKernel[0];
   offset = (kernel.length - 1) / 2;
   conv = new Array(height + kernel.length - 1);
   tmp = new Array(height);
-
   for (let x = 0; x < width; x++) {
     for (let y = 0; y < height; y++) {
       tmp[y] = result[y * width + x];
     }
-
     (0, _mlConvolution.directConvolution)(tmp, kernel, conv);
-
     for (let y = 0; y < height; y++) {
       result[y * width + x] = conv[offset + y];
     }
   }
-
   return result;
 }

package/lib/image/operator/extract.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = extract;
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Extracts a part of an original image based on a mask. By default the mask may contain
  * a relative position and this part of the original image will be extracted.
@@ -25,16 +22,15 @@ function extract(mask, options = {}) {
   } = options;
   this.checkProcessable('extract', {
     bitDepth: [1, 8, 16]
-  }); // we need to find the relative position to the parent
+  });
 
+  // we need to find the relative position to the parent
   if (!position) {
     position = mask.getRelativePosition(this);
-
     if (!position) {
       throw new Error('extract : can not extract an image because the relative position can not be ' + 'determined, try to specify manually the position as an array of 2 elements [x,y].');
     }
   }
-
   if (this.bitDepth > 1) {
     let extract = _Image.default.createFrom(this, {
       width: mask.width,
@@ -44,22 +40,19 @@ function extract(mask, options = {}) {
       position: position,
       parent: this
     });
-
     for (let x = 0; x < mask.width; x++) {
       for (let y = 0; y < mask.height; y++) {
         // we copy the point
         for (let channel = 0; channel < this.channels; channel++) {
           let value = this.getValueXY(x + position[0], y + position[1], channel);
           extract.setValueXY(x, y, channel, value);
-        } // we make it transparent in case it is not in the mask
-
-
+        }
+        // we make it transparent in case it is not in the mask
         if (!mask.getBitXY(x, y)) {
           extract.setValueXY(x, y, this.components, 0);
         }
       }
     }
-
     return extract;
   } else {
     let extract = _Image.default.createFrom(this, {
@@ -68,7 +61,6 @@ function extract(mask, options = {}) {
       position: position,
       parent: this
     });
-
     for (let y = 0; y < mask.height; y++) {
       for (let x = 0; x < mask.width; x++) {
         if (mask.getBitXY(x, y)) {
@@ -78,7 +70,6 @@ function extract(mask, options = {}) {
         }
       }
     }
-
     return extract;
   }
 }

package/lib/image/operator/floodFill.js

@@ -4,13 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = floodFill;
-
 var _fastList = _interopRequireDefault(require("fast-list"));
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 function floodFill(options = {}) {
   const {
     x = 0,
@@ -25,36 +21,29 @@ function floodFill(options = {}) {
   if (bit) return destination;
   const queue = new _fastList.default();
   queue.push(new Node(x, y));
-
   while (queue.length > 0) {
     const node = queue.shift();
     destination.setBitXY(node.x, node.y);
-
     for (let i = node.x + 1; i < this.width; i++) {
       if (!destination.getBitXY(i, node.y) && !this.getBitXY(i, node.y)) {
         destination.setBitXY(i, node.y);
-
         if (node.y + 1 < this.height && !this.getBitXY(i, node.y + 1)) {
           queue.push(new Node(i, node.y + 1));
         }
-
         if (node.y - 1 >= 0 && !this.getBitXY(i, node.y - 1)) {
           queue.push(new Node(i, node.y - 1));
         }
       } else {
         break;
       }
-    } // eslint-disable-next-line for-direction
-
-
+    }
+    // eslint-disable-next-line for-direction
     for (let i = node.x - 1; i >= 0; i++) {
       if (!destination.getBitXY(i, node.y) && !this.getBitXY(i, node.y)) {
         destination.setBitXY(i, node.y);
-
         if (node.y + 1 < this.height && !this.getBitXY(i, node.y + 1)) {
           queue.push(new Node(i, node.y + 1));
         }
-
         if (node.y - 1 >= 0 && !this.getBitXY(i, node.y - 1)) {
           queue.push(new Node(i, node.y - 1));
         }
@@ -63,10 +52,8 @@ function floodFill(options = {}) {
       }
     }
   }
-
   return destination;
 }
-
 function Node(x, y) {
   this.x = x;
   this.y = y;

package/lib/image/operator/getSeparatedKernel.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = getSeparatedKernel;
-
 var _mlMatrix = require("ml-matrix");
-
 function getSeparatedKernel(kernel) {
   const svd = new _mlMatrix.SVD(kernel, {
     autoTranspose: true

package/lib/image/operator/paintLabels.js

@@ -4,21 +4,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = paintLabels;
-
 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
@@ -35,41 +32,34 @@ function paintLabels(labels, positions, options = {}) {
     bitDepth: [8, 16],
     colorModel: _model.RGB
   });
-
   if (!Array.isArray(labels)) {
     throw Error('paintLabels: labels must be an array');
   }
-
   if (!Array.isArray(positions)) {
     throw Error('paintLabels: positions must be an array');
   }
-
   if (color && !Array.isArray(color)) {
     color = (0, _color.css2array)(color);
   }
-
   if (colors) {
     colors = colors.map(function (color) {
       if (!Array.isArray(color)) {
         return (0, _color.css2array)(color);
       }
-
       return color;
     });
   } else {
     colors = [color];
   }
-
   if (labels.length !== positions.length) {
     throw Error('paintLabels: positions and labels must be arrays from the same size');
-  } // We convert everything to array so that we can simply loop thourgh all the labels
-
+  }
 
+  // We convert everything to array so that we can simply loop thourgh all the labels
   if (!Array.isArray(font)) font = [font];
   if (!Array.isArray(rotate)) rotate = [rotate];
   let canvas = this.getCanvas();
   let ctx = canvas.getContext('2d');
-
   for (let i = 0; i < labels.length; i++) {
     ctx.save();
     let color = colors[i % colors.length];
@@ -81,7 +71,6 @@ function paintLabels(labels, positions, options = {}) {
     ctx.fillText(labels[i], 0, 0);
     ctx.restore();
   }
-
   this.data = Uint8Array.from(ctx.getImageData(0, 0, this.width, this.height).data);
   return this;
 }

package/lib/image/operator/paintMasks.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = paintMasks;
-
 var _color = require("../../util/color");
-
 var _model = require("../model/model");
-
 /**
  * Paint a mask or masks on the current image.
  * @memberof Image
@@ -43,16 +40,13 @@ function paintMasks(masks, options = {}) {
   let colors = (0, _color.getColors)(Object.assign({}, options, {
     numberColors: masks.length
   }));
-
   if (!Array.isArray(masks)) {
     masks = [masks];
   }
-
   for (let i = 0; i < masks.length; i++) {
-    let mask = masks[i]; // we need to find the parent image to calculate the relative position
-
+    let mask = masks[i];
+    // we need to find the parent image to calculate the relative position
     let color = colors[i % colors.length];
-
     for (let x = 0; x < mask.width; x++) {
       for (let y = 0; y < mask.height; y++) {
         if (mask.getBitXY(x, y)) {
@@ -69,20 +63,16 @@ function paintMasks(masks, options = {}) {
       }
     }
   }
-
   if (Array.isArray(labels) && labels.length > 0) {
     let canvas = this.getCanvas();
     let ctx = canvas.getContext('2d');
     ctx.fillStyle = labelColor;
     ctx.font = labelFont;
-
     for (let i = 0; i < Math.min(masks.length, labels.length); i++) {
       let position = labelsPosition[i] ? labelsPosition[i] : masks[i].position;
       ctx.fillText(labels[i], position[0], position[1]);
     }
-
     this.data = Uint8Array.from(ctx.getImageData(0, 0, this.width, this.height).data);
   }
-
   return this;
 }

package/lib/image/operator/paintPoints.js

@@ -4,13 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = paintPoints;
-
 var _Shape = _interopRequireDefault(require("../../util/Shape"));
-
 var _color = require("../../util/color");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Paint pixels on the current image.
  * @memberof Image
@@ -36,25 +32,20 @@ function paintPoints(points, options = {}) {
   }));
   let shapePixels = new _Shape.default(shape).getPoints();
   let numberChannels = Math.min(this.channels, colors[0].length);
-
   for (let i = 0; i < points.length; i++) {
     let color = colors[i % colors.length];
     let xP = points[i][0];
     let yP = points[i][1];
-
     for (let j = 0; j < shapePixels.length; j++) {
       let xS = shapePixels[j][0];
       let yS = shapePixels[j][1];
-
       if (xP + xS >= 0 && yP + yS >= 0 && xP + xS < this.width && yP + yS < this.height) {
         let position = (xP + xS + (yP + yS) * this.width) * this.channels;
-
         for (let channel = 0; channel < numberChannels; channel++) {
           this.data[position + channel] = color[channel];
         }
       }
     }
   }
-
   return this;
 }

package/lib/image/operator/paintPolygon.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = paintPolygon;
-
 /**
  * Paint a polygon defined by an array of points.
  * @memberof Image
@@ -12,7 +11,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 = {}) {
@@ -25,23 +24,18 @@ function paintPolygon(points, options = {}) {
   });
   options.closed = true;
   let filteredPoints = deleteDouble(points);
-
   if (filled === false) {
     return this.paintPolyline(points, options);
   } else {
     let matrixBinary = Array(this.height);
-
     for (let i = 0; i < this.height; i++) {
       matrixBinary[i] = [];
-
       for (let j = 0; j < this.width; j++) {
         matrixBinary[i].push(0);
       }
     }
-
     for (let p = 0; p < filteredPoints.length; p++) {
       const line = lineBetweenTwoPoints(filteredPoints[p], filteredPoints[(p + 1) % filteredPoints.length]);
-
       for (let y = 0; y < this.height; y++) {
         for (let x = 0; x < this.width; x++) {
           if (isAtTheRightOfTheLine(x, y, line, this.height)) {
@@ -50,7 +44,6 @@ function paintPolygon(points, options = {}) {
         }
       }
     }
-
     for (let y = 0; y < this.height; y++) {
       for (let x = 0; x < this.width; x++) {
         if (matrixBinary[y][x] === 1) {
@@ -59,7 +52,6 @@ function paintPolygon(points, options = {}) {
           } else {
             let numberChannels = Math.min(this.channels, color.length);
             let position = (x + y * this.width) * this.channels;
-
             for (let channel = 0; channel < numberChannels; channel++) {
               this.data[position + channel] = color[channel];
             }
@@ -67,14 +59,11 @@ function paintPolygon(points, options = {}) {
         }
       }
     }
-
     return this.paintPolyline(points, options);
   }
 }
-
 function deleteDouble(points) {
   let finalPoints = [];
-
   for (let i = 0; i < points.length; i++) {
     if (points[i][0] === points[(i + 1) % points.length][0] && points[i][1] === points[(i + 1) % points.length][1]) {
       continue;
@@ -86,10 +75,8 @@ function deleteDouble(points) {
       finalPoints.push(points[i]);
     }
   }
-
   return finalPoints;
 }
-
 function lineBetweenTwoPoints(p1, p2) {
   if (p1[0] === p2[0]) {
     return {
@@ -107,7 +94,6 @@ function lineBetweenTwoPoints(p1, p2) {
     };
   }
 }
-
 function isAtTheRightOfTheLine(x, y, line, height) {
   if (line.vertical === true) {
     return line.b <= x;

package/lib/image/operator/paintPolygons.js

@@ -4,14 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 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
@@ -28,11 +26,9 @@ function paintPolygons(polygons, options = {}) {
   let colors = (0, _color.getColors)(Object.assign({}, options, {
     numberColors: polygons.length
   }));
-
   for (let i = 0; i < polygons.length; i++) {
     optionsCopy.color = colors[i % colors.length];
     this.paintPolygon(polygons[i], optionsCopy);
   }
-
   return this;
 }

package/lib/image/operator/paintPolyline.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = paintPolyline;
-
 /**
  * Paint a polyline defined by an array of points.
  * @memberof Image
@@ -24,7 +23,6 @@ function paintPolyline(points, options = {}) {
     bitDepth: [1, 8, 16]
   });
   let numberChannels = Math.min(this.channels, color.length);
-
   for (let i = 0; i < points.length - 1 + closed; i++) {
     let from = points[i];
     let to = points[(i + 1) % points.length];
@@ -35,27 +33,22 @@ function paintPolyline(points, options = {}) {
     let yIncrement = dy / steps;
     let x = from[0];
     let y = from[1];
-
     for (let j = 0; j <= steps; j++) {
       let xPoint = Math.round(x);
       let yPoint = Math.round(y);
-
       if (xPoint >= 0 && yPoint >= 0 && xPoint < this.width && yPoint < this.height) {
         if (this.bitDepth === 1) {
           this.setBitXY(xPoint, yPoint);
         } else {
           let position = (xPoint + yPoint * this.width) * this.channels;
-
           for (let channel = 0; channel < numberChannels; channel++) {
             this.data[position + channel] = color[channel];
           }
         }
       }
-
       x = x + xIncrement;
       y = y + yIncrement;
     }
   }
-
   return this;
 }