image-js 0.35.2 → 0.35.4

package/lib/image/morphology/dilate.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = dilate;
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Dilatation is one of two fundamental operations (with erosion) in morphological
  * image processing from which all other morphological operations are based (from Wikipedia).
@@ -32,13 +29,10 @@ function dilate(options = {}) {
     components: 1,
     alpha: 0
   });
-
   if (kernel.columns % 2 === 0 || kernel.rows % 2 === 0) {
     throw new TypeError('dilate: The number of rows and columns of the kernel must be odd');
   }
-
   let onlyOnes = true;
-
   outer: for (const row of kernel) {
     for (const value of row) {
       if (value !== 1) {
@@ -47,9 +41,7 @@ function dilate(options = {}) {
       }
     }
   }
-
   let result = this;
-
   for (let i = 0; i < iterations; i++) {
     if (this.bitDepth === 1) {
       if (onlyOnes) {
@@ -57,33 +49,26 @@ function dilate(options = {}) {
         result = dilateOnceBinaryOnlyOnes(result, newImage, kernel.length, kernel[0].length);
       } else {
         const newImage = _Image.default.createFrom(result);
-
         result = dilateOnceBinary(result, newImage, kernel);
       }
     } else if (onlyOnes) {
       const newImage = _Image.default.createFrom(result);
-
       result = dilateOnceGreyOnlyOnes(result, newImage, kernel.length, kernel[0].length);
     } else {
       const newImage = _Image.default.createFrom(result);
-
       result = dilateOnceGrey(result, newImage, kernel);
     }
   }
-
   return result;
 }
-
 function dilateOnceGrey(img, newImage, kernel) {
   const kernelWidth = kernel.length;
   const kernelHeight = kernel[0].length;
   let radiusX = (kernelWidth - 1) / 2;
   let radiusY = (kernelHeight - 1) / 2;
-
   for (let y = 0; y < img.height; y++) {
     for (let x = 0; x < img.width; x++) {
       let max = 0;
-
       for (let jj = 0; jj < kernelHeight; jj++) {
         for (let ii = 0; ii < kernelWidth; ii++) {
           if (kernel[ii][jj] !== 1) continue;
@@ -94,64 +79,49 @@ function dilateOnceGrey(img, newImage, kernel) {
           if (value > max) max = value;
         }
       }
-
       newImage.setValueXY(x, y, 0, max);
     }
   }
-
   return newImage;
 }
-
 function dilateOnceGreyOnlyOnes(img, newImage, kernelWidth, kernelHeight) {
   const radiusX = (kernelWidth - 1) / 2;
   const radiusY = (kernelHeight - 1) / 2;
   const maxList = [];
-
   for (let x = 0; x < img.width; x++) {
     maxList.push(0);
   }
-
   for (let y = 0; y < img.height; y++) {
     for (let x = 0; x < img.width; x++) {
       let max = 0;
-
       for (let h = Math.max(0, y - radiusY); h < Math.min(img.height, y + radiusY + 1); h++) {
         const value = img.getValueXY(x, h, 0);
-
         if (value > max) {
           max = value;
         }
       }
-
       maxList[x] = max;
     }
-
     for (let x = 0; x < img.width; x++) {
       let max = 0;
-
       for (let i = Math.max(0, x - radiusX); i < Math.min(img.width, x + radiusX + 1); i++) {
         if (maxList[i] > max) {
           max = maxList[i];
         }
       }
-
       newImage.setValueXY(x, y, 0, max);
     }
   }
-
   return newImage;
 }
-
 function dilateOnceBinary(img, newImage, kernel) {
   const kernelWidth = kernel.length;
   const kernelHeight = kernel[0].length;
   let radiusX = (kernelWidth - 1) / 2;
   let radiusY = (kernelHeight - 1) / 2;
-
   for (let y = 0; y < img.height; y++) {
     for (let x = 0; x < img.width; x++) {
       let max = 0;
-
       intLoop: for (let jj = 0; jj < kernelHeight; jj++) {
         for (let ii = 0; ii < kernelWidth; ii++) {
           if (kernel[ii][jj] !== 1) continue;
@@ -159,36 +129,29 @@ function dilateOnceBinary(img, newImage, kernel) {
           let j = jj - radiusY + y;
           if (j < 0 || i < 0 || i >= img.width || j >= img.height) continue;
           const value = img.getBitXY(i, j);
-
           if (value === 1) {
             max = 1;
             break intLoop;
           }
         }
       }
-
       if (max === 1) {
         newImage.setBitXY(x, y);
       }
     }
   }
-
   return newImage;
 }
-
 function dilateOnceBinaryOnlyOnes(img, newImage, kernelWidth, kernelHeight) {
   const radiusX = (kernelWidth - 1) / 2;
   const radiusY = (kernelHeight - 1) / 2;
   const maxList = [];
-
   for (let x = 0; x < img.width; x++) {
     maxList.push(1);
   }
-
   for (let y = 0; y < img.height; y++) {
     for (let x = 0; x < img.width; x++) {
       maxList[x] = 0;
-
       for (let h = Math.max(0, y - radiusY); h < Math.min(img.height, y + radiusY + 1); h++) {
         if (img.getBitXY(x, h) === 1) {
           maxList[x] = 1;
@@ -196,10 +159,8 @@ function dilateOnceBinaryOnlyOnes(img, newImage, kernelWidth, kernelHeight) {
         }
       }
     }
-
     for (let x = 0; x < img.width; x++) {
       if (newImage.getBitXY(x, y) === 1) continue;
-
       for (let i = Math.max(0, x - radiusX); i < Math.min(img.width, x + radiusX + 1); i++) {
         if (maxList[i] === 1) {
           newImage.setBitXY(x, y);
@@ -208,6 +169,5 @@ function dilateOnceBinaryOnlyOnes(img, newImage, kernelWidth, kernelHeight) {
       }
     }
   }
-
   return newImage;
 }

package/lib/image/morphology/erode.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = erode;
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Erosion is one of two fundamental operations (with dilatation) in morphological
  * image processing from which all other morphological operations are based (from Wikipedia).
@@ -32,13 +29,10 @@ function erode(options = {}) {
     components: 1,
     alpha: 0
   });
-
   if (kernel.columns % 2 === 0 || kernel.rows % 2 === 0) {
     throw new TypeError('erode: The number of rows and columns of the kernel must be odd');
   }
-
   let onlyOnes = true;
-
   outer: for (const row of kernel) {
     for (const value of row) {
       if (value !== 1) {
@@ -47,9 +41,7 @@ function erode(options = {}) {
       }
     }
   }
-
   let result = this;
-
   for (let i = 0; i < iterations; i++) {
     if (this.bitDepth === 1) {
       if (onlyOnes) {
@@ -57,33 +49,26 @@ function erode(options = {}) {
         result = erodeOnceBinaryOnlyOnes(result, newImage, kernel.length, kernel[0].length);
       } else {
         const newImage = _Image.default.createFrom(result);
-
         result = erodeOnceBinary(result, newImage, kernel);
       }
     } else if (onlyOnes) {
       const newImage = _Image.default.createFrom(result);
-
       result = erodeOnceGreyOnlyOnes(result, newImage, kernel.length, kernel[0].length);
     } else {
       const newImage = _Image.default.createFrom(result);
-
       result = erodeOnceGrey(result, newImage, kernel);
     }
   }
-
   return result;
 }
-
 function erodeOnceGrey(img, newImage, kernel) {
   const kernelWidth = kernel.length;
   const kernelHeight = kernel[0].length;
   let radiusX = (kernelWidth - 1) / 2;
   let radiusY = (kernelHeight - 1) / 2;
-
   for (let y = 0; y < img.height; y++) {
     for (let x = 0; x < img.width; x++) {
       let min = img.maxValue;
-
       for (let jj = 0; jj < kernelHeight; jj++) {
         for (let ii = 0; ii < kernelWidth; ii++) {
           if (kernel[ii][jj] !== 1) continue;
@@ -94,64 +79,49 @@ function erodeOnceGrey(img, newImage, kernel) {
           if (value < min) min = value;
         }
       }
-
       newImage.setValueXY(x, y, 0, min);
     }
   }
-
   return newImage;
 }
-
 function erodeOnceGreyOnlyOnes(img, newImage, kernelWidth, kernelHeight) {
   const radiusX = (kernelWidth - 1) / 2;
   const radiusY = (kernelHeight - 1) / 2;
   const minList = [];
-
   for (let x = 0; x < img.width; x++) {
     minList.push(0);
   }
-
   for (let y = 0; y < img.height; y++) {
     for (let x = 0; x < img.width; x++) {
       let min = img.maxValue;
-
       for (let h = Math.max(0, y - radiusY); h < Math.min(img.height, y + radiusY + 1); h++) {
         const value = img.getValueXY(x, h, 0);
-
         if (value < min) {
           min = value;
         }
       }
-
       minList[x] = min;
     }
-
     for (let x = 0; x < img.width; x++) {
       let min = img.maxValue;
-
       for (let i = Math.max(0, x - radiusX); i < Math.min(img.width, x + radiusX + 1); i++) {
         if (minList[i] < min) {
           min = minList[i];
         }
       }
-
       newImage.setValueXY(x, y, 0, min);
     }
   }
-
   return newImage;
 }
-
 function erodeOnceBinary(img, newImage, kernel) {
   const kernelWidth = kernel.length;
   const kernelHeight = kernel[0].length;
   let radiusX = (kernelWidth - 1) / 2;
   let radiusY = (kernelHeight - 1) / 2;
-
   for (let y = 0; y < img.height; y++) {
     for (let x = 0; x < img.width; x++) {
       let min = 1;
-
       intLoop: for (let jj = 0; jj < kernelHeight; jj++) {
         for (let ii = 0; ii < kernelWidth; ii++) {
           if (kernel[ii][jj] !== 1) continue;
@@ -159,36 +129,29 @@ function erodeOnceBinary(img, newImage, kernel) {
           let j = jj - radiusY + y;
           if (j < 0 || i < 0 || i >= img.width || j >= img.height) continue;
           const value = img.getBitXY(i, j);
-
           if (value === 0) {
             min = 0;
             break intLoop;
           }
         }
       }
-
       if (min === 1) {
         newImage.setBitXY(x, y);
       }
     }
   }
-
   return newImage;
 }
-
 function erodeOnceBinaryOnlyOnes(img, newImage, kernelWidth, kernelHeight) {
   const radiusX = (kernelWidth - 1) / 2;
   const radiusY = (kernelHeight - 1) / 2;
   const minList = [];
-
   for (let x = 0; x < img.width; x++) {
     minList.push(0);
   }
-
   for (let y = 0; y < img.height; y++) {
     for (let x = 0; x < img.width; x++) {
       minList[x] = 1;
-
       for (let h = Math.max(0, y - radiusY); h < Math.min(img.height, y + radiusY + 1); h++) {
         if (img.getBitXY(x, h) === 0) {
           minList[x] = 0;
@@ -196,10 +159,8 @@ function erodeOnceBinaryOnlyOnes(img, newImage, kernelWidth, kernelHeight) {
         }
       }
     }
-
     for (let x = 0; x < img.width; x++) {
       if (newImage.getBitXY(x, y) === 0) continue;
-
       for (let i = Math.max(0, x - radiusX); i < Math.min(img.width, x + radiusX + 1); i++) {
         if (minList[i] === 0) {
           newImage.clearBitXY(x, y);
@@ -208,6 +169,5 @@ function erodeOnceBinaryOnlyOnes(img, newImage, kernelWidth, kernelHeight) {
       }
     }
   }
-
   return newImage;
 }

package/lib/image/morphology/morphologicalGradient.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = morphologicalGradient;
-
 /**
  * In mathematical morphology and digital image processing, a morphological gradient is the difference between the dilation and the erosion of a given image. It is an image where each pixel value (typically non-negative) indicates the contrast intensity in the close neighborhood of that pixel. It is useful for edge detection and segmentation applications.
  * http://docs.opencv.org/2.4/doc/tutorials/imgproc/opening_closing_hats/opening_closing_hats.html
@@ -25,13 +24,10 @@ function morphologicalGradient(options = {}) {
     components: 1,
     alpha: 0
   });
-
   if (kernel.columns % 2 === 0 || kernel.rows % 2 === 0) {
     throw new TypeError('morphologicalGradient: The number of rows and columns of the kernel must be odd');
   }
-
   let newImage = this;
-
   for (let i = 0; i < iterations; i++) {
     let dilatedImage = newImage.dilate({
       kernel
@@ -43,6 +39,5 @@ function morphologicalGradient(options = {}) {
       absolute: true
     });
   }
-
   return newImage;
 }

package/lib/image/morphology/open.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = open;
-
 /**
  * In mathematical morphology, opening is the dilation of the erosion of a set A by a structuring element B.
  * Together with closing, the opening serves in computer vision and image processing as a basic workhorse of morphological noise removal.
@@ -28,13 +27,10 @@ function open(options = {}) {
     components: 1,
     alpha: 0
   });
-
   if (kernel.columns % 2 === 0 || kernel.rows % 2 === 0) {
     throw new TypeError('open: The number of rows and columns of the kernel must be odd');
   }
-
   let newImage = this;
-
   for (let i = 0; i < iterations; i++) {
     newImage = newImage.erode({
       kernel
@@ -43,6 +39,5 @@ function open(options = {}) {
       kernel
     });
   }
-
   return newImage;
 }

package/lib/image/morphology/topHat.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = topHat;
-
 /**
  * This function is the white top hat (also called top hat). In mathematical morphology and digital image processing,
  * top-hat transform is an operation that extracts small elements and details from given images.
@@ -28,13 +27,10 @@ function topHat(options = {}) {
     components: 1,
     alpha: 0
   });
-
   if (kernel.length % 2 === 0 || kernel[0].length % 2 === 0) {
     throw new TypeError('topHat: The number of rows and columns of the kernel must be odd');
   }
-
   let newImage = this;
-
   for (let i = 0; i < iterations; i++) {
     let openImage = newImage.open({
       kernel
@@ -43,6 +39,5 @@ function topHat(options = {}) {
       absolute: true
     });
   }
-
   return newImage;
 }

package/lib/image/operator/cannyEdge.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = cannyEdge;
-
 var _cannyEdgeDetector = _interopRequireDefault(require("canny-edge-detector"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * @memberof Image
  * @instance

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;
 }