image-js 0.35.1 → 0.35.3

package/lib/image/compute/extendedPoints.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = extendedPoints;
-
 /**
  * Allows to generate an array of points for a binary image (bit depth = 1)
  * The points consider the beginning and the end of each pixel
@@ -18,16 +17,13 @@ function extendedPoints() {
     bitDepth: [1]
   });
   const pixels = [];
-
   for (let y = 0; y < this.height; y++) {
     for (let x = 0; x < this.width; x++) {
       if (this.getBitXY(x, y) === 1) {
         pixels.push([x, y]);
-
         if (this.getBitXY(x + 1, y) !== 1) {
           pixels.push([x + 1, y]);
           pixels.push([x + 1, y + 1]);
-
           if (this.getBitXY(x, y + 1) !== 1) {
             pixels.push([x, y + 1]);
           }
@@ -36,15 +32,14 @@ function extendedPoints() {
             pixels.push([x, y + 1]);
             pixels.push([x + 1, y + 1]);
           }
-        } // this small optimization allows to reduce dramatically the number of points for MBR calculation
-
+        }
 
+        // this small optimization allows to reduce dramatically the number of points for MBR calculation
         while (x < this.width - 2 && this.getBitXY(x + 1, y) === 1 && this.getBitXY(x + 2, y) === 1) {
           x++;
         }
       }
     }
   }
-
   return pixels;
 }

package/lib/image/compute/histogram.js

@@ -5,13 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getHistogram = getHistogram;
 exports.getHistograms = getHistograms;
-
 var _isInteger = _interopRequireDefault(require("is-integer"));
-
 var _newArray = _interopRequireDefault(require("new-array"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Returns a histogram for the specified channel
  * @memberof Image
@@ -31,20 +27,18 @@ function getHistogram(options = {}) {
   this.checkProcessable('getHistogram', {
     bitDepth: [1, 8, 16]
   });
-
   if (channel === undefined) {
     if (this.components > 1) {
       throw new RangeError('You need to define the channel for an image that contains more than one channel');
     }
-
     channel = 0;
   }
-
   return getChannelHistogram.call(this, channel, {
     useAlpha,
     maxSlots
   });
 }
+
 /**
  * Returns an array (number of channels) of array (number of slots) containing
  * the number of data of a specific intensity.
@@ -64,8 +58,6 @@ function getHistogram(options = {}) {
  *          useAlpha: false
  *      });
  */
-
-
 function getHistograms(options = {}) {
   const {
     maxSlots = 256,
@@ -75,30 +67,27 @@ function getHistograms(options = {}) {
     bitDepth: [8, 16]
   });
   let results = new Array(useAlpha ? this.components : this.channels);
-
   for (let i = 0; i < results.length; i++) {
     results[i] = getChannelHistogram.call(this, i, {
       useAlpha,
       maxSlots
     });
   }
-
   return results;
 }
-
 function getChannelHistogram(channel, options) {
   let {
     useAlpha,
     maxSlots
-  } = options; // for a mask, return a number array containing count of black and white points (black = array[0], white = array[1])
+  } = options;
+
+  // for a mask, return a number array containing count of black and white points (black = array[0], white = array[1])
 
   if (this.bitDepth === 1) {
     let blackWhiteCount = [0, 0];
-
     for (let i = 0; i < this.height; i++) {
       for (let j = 0; j < this.width; j++) {
         let value = this.getBitXY(i, j);
-
         if (value === 0) {
           blackWhiteCount[0] += 1;
         } else if (value === 1) {
@@ -106,31 +95,24 @@ function getChannelHistogram(channel, options) {
         }
       }
     }
-
     return blackWhiteCount;
   }
-
   let bitSlots = Math.log2(maxSlots);
-
   if (!(0, _isInteger.default)(bitSlots)) {
     throw new RangeError('maxSlots must be a power of 2, for example: 64, 256, 1024');
-  } // we will compare the bitSlots to the bitDepth of the image
+  }
+  // we will compare the bitSlots to the bitDepth of the image
   // based on this we will shift the values. This allows to generate a histogram
   // of 16 grey even if the images has 256 shade of grey
 
-
   let bitShift = 0;
-
   if (this.bitDepth > bitSlots) {
     bitShift = this.bitDepth - bitSlots;
   }
-
   let data = this.data;
   let result = (0, _newArray.default)(Math.pow(2, Math.min(this.bitDepth, bitSlots)), 0);
-
   if (useAlpha && this.alpha) {
     let alphaChannelDiff = this.channels - channel - 1;
-
     for (let i = channel; i < data.length; i += this.channels) {
       result[data[i] >> bitShift] += data[i + alphaChannelDiff] / this.maxValue;
     }
@@ -139,6 +121,5 @@ function getChannelHistogram(channel, options) {
       result[data[i] >> bitShift]++;
     }
   }
-
   return result;
 }

package/lib/image/compute/localMaxima.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = localMaxima;
-
 /**
  * Returns an array of object with position.
  * @memberof Image
@@ -37,17 +36,14 @@ function localMaxima(options = {}) {
   let dy = [0, +1, 0, -1, +1, -1, +1, -1, 0, +2, 0, -2, +2, -2, +2, -2];
   let shift = region <= 8 ? 1 : 2;
   let points = [];
-
   for (let currentY = shift; currentY < image.height - shift; currentY++) {
     for (let currentX = shift; currentX < image.width - shift; currentX++) {
       if (mask && mask.getBitXY(currentX, currentY) !== maskExpectedValue) {
         continue;
       }
-
       let counter = 0;
       let nbEquals = 0;
       let currentValue = image.data[currentX + currentY * image.width];
-
       for (let dir = 0; dir < region; dir++) {
         if (invert) {
           // we search for minima
@@ -59,24 +55,21 @@ function localMaxima(options = {}) {
             counter++;
           }
         }
-
         if (image.data[currentX + dx[dir] + (currentY + dy[dir]) * image.width] === currentValue) {
           nbEquals++;
         }
       }
-
       if (counter + nbEquals === region && nbEquals <= maxEquals) {
         points.push([currentX, currentY]);
       }
     }
-  } // TODO How to make a more performant and general way
+  }
+  // TODO How to make a more performant and general way
   // we don't deal correctly here with groups of points that should be grouped if at the
   // beginning one of them is closer to another
   // Seems that we would ened to calculate a matrix and then split this matrix in 'independant matrices'
   // Or to assign a cluster to each point and regroup them if 2 clusters are close to each other
   // later approach seems much better
-
-
   if (removeClosePoints > 0) {
     for (let i = 0; i < points.length; i++) {
       for (let j = i + 1; j < points.length; j++) {
@@ -89,6 +82,5 @@ function localMaxima(options = {}) {
       }
     }
   }
-
   return points;
 }

package/lib/image/compute/max.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = max;
-
 var _newArray = _interopRequireDefault(require("new-array"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Returns an array with the maximal value of each channel
  * @memberof Image
@@ -20,7 +17,6 @@ function max() {
     bitDepth: [8, 16, 32]
   });
   let result = (0, _newArray.default)(this.channels, -Infinity);
-
   for (let i = 0; i < this.data.length; i += this.channels) {
     for (let c = 0; c < this.channels; c++) {
       if (this.data[i + c] > result[c]) {
@@ -28,6 +24,5 @@ function max() {
       }
     }
   }
-
   return result;
 }

package/lib/image/compute/mean.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = mean;
-
 var _histogram = require("../../util/histogram");
-
 /**
  * Returns an array with the average value of each channel
  * @memberof Image
@@ -18,11 +16,9 @@ function mean() {
     maxSlots: this.maxValue + 1
   });
   let result = new Array(histograms.length);
-
   for (let c = 0; c < histograms.length; c++) {
     let histogram = histograms[c];
     result[c] = (0, _histogram.mean)(histogram);
   }
-
   return result;
 }

package/lib/image/compute/median.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = median;
-
 var _histogram = require("../../util/histogram");
-
 /**
  * Returns an array with the median value of each channel
  * @memberof Image
@@ -18,11 +16,9 @@ function median() {
     maxSlots: this.maxValue + 1
   });
   let result = new Array(histograms.length);
-
   for (let c = 0; c < histograms.length; c++) {
     let histogram = histograms[c];
     result[c] = (0, _histogram.median)(histogram);
   }
-
   return result;
 }

package/lib/image/compute/min.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = min;
-
 var _newArray = _interopRequireDefault(require("new-array"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Returns an array with the minimal value of each channel
  * @memberof Image
@@ -20,7 +17,6 @@ function min() {
     bitDepth: [8, 16, 32]
   });
   let result = (0, _newArray.default)(this.channels, +Infinity);
-
   for (let i = 0; i < this.data.length; i += this.channels) {
     for (let c = 0; c < this.channels; c++) {
       if (this.data[i + c] < result[c]) {
@@ -28,6 +24,5 @@ function min() {
       }
     }
   }
-
   return result;
 }

package/lib/image/compute/minimalBoundingRectangle.js

@@ -4,13 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = minimalBoundingRectangle;
-
 var _points = require("../../util/points");
-
 var _monotoneChainConvexHull = _interopRequireDefault(require("./monotoneChainConvexHull"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Computes the minimum bounding box around a binary image
  * https://www.researchgate.net/profile/Lennert_Den_Boer2/publication/303783472_A_Fast_Algorithm_for_Generating_a_Minimal_Bounding_Rectangle/links/5751a14108ae6807fafb2aa5.pdf
@@ -24,24 +20,21 @@ function minimalBoundingRectangle(options = {}) {
   const {
     originalPoints = _monotoneChainConvexHull.default.call(this)
   } = options;
-
   if (originalPoints.length === 0) {
     return [];
   }
-
   if (originalPoints.length === 1) {
     return [originalPoints[0], originalPoints[0], originalPoints[0], originalPoints[0]];
   }
-
   const p = new Array(originalPoints.length);
   let minSurface = +Infinity;
   let minSurfaceAngle = 0;
   let mbr;
-
   for (let i = 0; i < p.length; i++) {
     let angle = getAngle(originalPoints[i], originalPoints[(i + 1) % p.length]);
-    (0, _points.rotate)(-angle, originalPoints, p); // we rotate and translate so that this axe is in the bottom
+    (0, _points.rotate)(-angle, originalPoints, p);
 
+    // we rotate and translate so that this axe is in the bottom
     let aX = p[i][0];
     let aY = p[i][1];
     let bX = p[(i + 1) % p.length][0];
@@ -50,12 +43,10 @@ function minimalBoundingRectangle(options = {}) {
     let tMin = 0;
     let tMax = 0;
     let maxWidth = 0;
-
     for (let j = 0; j < p.length; j++) {
       let cX = p[j][0];
       let cY = p[j][1];
       let t = (cX - aX) / (bX - aX);
-
       if (tUndefined === true) {
         tUndefined = false;
         tMin = t;
@@ -64,28 +55,24 @@ function minimalBoundingRectangle(options = {}) {
         if (t < tMin) tMin = t;
         if (t > tMax) tMax = t;
       }
-
       let width = (-(bX - aX) * cY + bX * aY - bY * aX) / (bX - aX);
       if (Math.abs(width) > Math.abs(maxWidth)) maxWidth = width;
     }
-
     let pMin = [aX + tMin * (bX - aX), aY];
     let pMax = [aX + tMax * (bX - aX), aY];
     let currentSurface = Math.abs(maxWidth * (tMin - tMax) * (bX - aX));
-
     if (currentSurface < minSurface) {
       minSurfaceAngle = angle;
       minSurface = currentSurface;
       mbr = [pMin, pMax, [pMax[0], pMax[1] - maxWidth], [pMin[0], pMin[1] - maxWidth]];
     }
   }
-
   (0, _points.rotate)(minSurfaceAngle, mbr, mbr);
   return mbr;
-} // the angle that allows to make the line going through p1 and p2 horizontal
-// this is an optimized version because it assume one vector is horizontal
-
+}
 
+// the angle that allows to make the line going through p1 and p2 horizontal
+// this is an optimized version because it assume one vector is horizontal
 function getAngle(p1, p2) {
   let diff = (0, _points.difference)(p2, p1);
   let vector = (0, _points.normalize)(diff);

package/lib/image/compute/moment.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = getMoment;
-
 /**
  * Returns the moment of an image (https://en.wikipedia.org/wiki/Image_moment)
  * @memberof Image
@@ -18,7 +17,6 @@ function getMoment(xPower = 0, yPower = 0) {
     bitDepth: [1]
   });
   let m = 0;
-
   for (let x = 0; x < this.width; x++) {
     for (let y = 0; y < this.height; y++) {
       if (this.getBitXY(x, y) === 1) {
@@ -26,6 +24,5 @@ function getMoment(xPower = 0, yPower = 0) {
       }
     }
   }
-
   return m;
 }

package/lib/image/compute/monotoneChainConvexHull.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = monotoneChainConvexHull;
-
 var _monotoneChainConvexHull = _interopRequireDefault(require("monotone-chain-convex-hull"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Returns the convex hull of a binary image
  * @memberof Image

package/lib/image/compute/points.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = points;
-
 /**
  * Allows to generate an array of points for a binary image (bit depth = 1)
  * @memberof Image
@@ -16,7 +15,6 @@ function points() {
     bitDepth: [1]
   });
   const pixels = [];
-
   for (let x = 0; x < this.width; x++) {
     for (let y = 0; y < this.height; y++) {
       if (this.getBitXY(x, y) === 1) {
@@ -24,6 +22,5 @@ function points() {
       }
     }
   }
-
   return pixels;
 }

package/lib/image/compute/relativePosition.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = getRelativePosition;
-
 /**
  * An image may be derived from another image either by a crop
  * or because it is a ROI (region of interest)
@@ -26,25 +25,20 @@ function getRelativePosition(targetImage, options = {}) {
   if (this === targetImage) {
     return [0, 0];
   }
-
   let position = [0, 0];
   let currentImage = this;
-
   while (currentImage) {
     if (currentImage === targetImage) {
       return position;
     }
-
     if (currentImage.position) {
       position[0] += currentImage.position[0];
       position[1] += currentImage.position[1];
     }
-
     currentImage = currentImage.parent;
-  } // we should never reach this place, this means we could not find the parent
+  }
+  // we should never reach this place, this means we could not find the parent
   // throw Error('Parent image was not found, can not get relative position.')
-
-
   if (options.defaultFurther) return position;
   return false;
 }

package/lib/image/compute/sum.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = sum;
-
 var _newArray = _interopRequireDefault(require("new-array"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Returns an array with the sum of the values of each channel
  * @memberof Image
@@ -20,12 +17,10 @@ function sum() {
     bitDepth: [8, 16]
   });
   let result = (0, _newArray.default)(this.channels, 0);
-
   for (let i = 0; i < this.data.length; i += this.channels) {
     for (let c = 0; c < this.channels; c++) {
       result[c] += this.data[i + c];
     }
   }
-
   return result;
 }

package/lib/image/core/bitMethods.js

@@ -17,7 +17,6 @@ const bitMethods = {
   getBit(pixel) {
     return this.data[getSlot(pixel)] & 1 << getShift(pixel) ? 1 : 0;
   },
-
   /**
    * Set the bit of a pixel using a pixel index.
    * This method can only be called on binary images.
@@ -28,7 +27,6 @@ const bitMethods = {
   setBit(pixel) {
     this.data[getSlot(pixel)] |= 1 << getShift(pixel);
   },
-
   /**
    * Clear the bit of a pixel using a pixel index.
    * This method can only be called on binary images.
@@ -39,7 +37,6 @@ const bitMethods = {
   clearBit(pixel) {
     this.data[getSlot(pixel)] &= ~(1 << getShift(pixel));
   },
-
   /**
    * Toggle (invert) the bit of a pixel using a pixel index.
    * This method can only be called on binary images.
@@ -50,7 +47,6 @@ const bitMethods = {
   toggleBit(pixel) {
     this.data[getSlot(pixel)] ^= 1 << getShift(pixel);
   },
-
   /**
    * Get the bit of a pixel using coordinates.
    * This method can only be called on binary images.
@@ -64,7 +60,6 @@ const bitMethods = {
     if (x >= this.width || y >= this.height) return 0;
     return this.getBit(y * this.width + x);
   },
-
   /**
    * Set the bit of a pixel using coordinates.
    * This method can only be called on binary images.
@@ -76,7 +71,6 @@ const bitMethods = {
   setBitXY(x, y) {
     this.setBit(y * this.width + x);
   },
-
   /**
    * Clear the bit of a pixel using coordinates.
    * @memberof Image
@@ -87,7 +81,6 @@ const bitMethods = {
   clearBitXY(x, y) {
     this.clearBit(y * this.width + x);
   },
-
   /**
    * Toggle (invert) the bit of a pixel using coordinates.
    * @memberof Image
@@ -98,17 +91,13 @@ const bitMethods = {
   toggleBitXY(x, y) {
     this.toggleBit(y * this.width + x);
   }
-
 };
-
 function getSlot(pixel) {
   return pixel >> 3;
 }
-
 function getShift(pixel) {
   return 7 - (pixel & 0b00000111);
 }
-
 function setBitMethods(Image) {
   for (const i in bitMethods) {
     Image.prototype[i] = bitMethods[i];

package/lib/image/core/checkProcessable.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = checkProcessable;
-
 /**
  * This method checks if a process can be applied on the current image
  * @memberof Image
@@ -20,49 +19,39 @@ function checkProcessable(processName, options = {}) {
     components,
     channels
   } = options;
-
   if (typeof processName !== 'string' || processName.length === 0) {
     throw new TypeError('processName must be a string');
   }
-
   if (bitDepth) {
     if (!Array.isArray(bitDepth)) {
       bitDepth = [bitDepth];
     }
-
     if (!bitDepth.includes(this.bitDepth)) {
       throw new TypeError(`The process: ${processName} can only be applied if bit depth is in: ${bitDepth}`);
     }
   }
-
   if (alpha) {
     if (!Array.isArray(alpha)) {
       alpha = [alpha];
     }
-
     if (!alpha.includes(this.alpha)) {
       throw new TypeError(`The process: ${processName} can only be applied if alpha is in: ${alpha}`);
     }
   }
-
   if (colorModel) {
     if (!Array.isArray(colorModel)) {
       colorModel = [colorModel];
     }
-
     if (!colorModel.includes(this.colorModel)) {
       throw new TypeError(`The process: ${processName} can only be applied if color model is in: ${colorModel}`);
     }
   }
-
   if (components) {
     if (!Array.isArray(components)) {
       components = [components];
     }
-
     if (!components.includes(this.components)) {
       let errorMessage = `The process: ${processName} can only be applied if the number of components is in: ${components}`;
-
       if (components.length === 1 && components[0] === 1) {
         throw new TypeError(`${errorMessage}.\rYou should transform your image using "image.grey()" before applying the algorithm.`);
       } else {
@@ -70,12 +59,10 @@ function checkProcessable(processName, options = {}) {
       }
     }
   }
-
   if (channels) {
     if (!Array.isArray(channels)) {
       channels = [channels];
     }
-
     if (!channels.includes(this.channels)) {
       throw new TypeError(`The process: ${processName} can only be applied if the number of channels is in: ${channels}`);
     }