image-js 0.35.1 → 0.35.3

package/lib/image/internal/getOutputImage.js

@@ -5,13 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getOutputImage = getOutputImage;
 exports.getOutputImageOrInPlace = getOutputImageOrInPlace;
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 var _getImageParameters = _interopRequireDefault(require("./getImageParameters"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Use this function to support getting the output image of an algorithm from user-supplied
  * options.
@@ -27,7 +23,6 @@ function getOutputImage(thisImage, options, newParameters, internalOptions = {})
   const {
     out
   } = options;
-
   if (out === undefined) {
     if (internalOptions.copy) {
       return thisImage.clone();
@@ -38,18 +33,16 @@ function getOutputImage(thisImage, options, newParameters, internalOptions = {})
     if (!_Image.default.isImage(out)) {
       throw new TypeError('out must be an Image object');
     }
-
     const requirements = Object.assign((0, _getImageParameters.default)(thisImage), newParameters);
-
     for (const property in requirements) {
       if (out[property] !== requirements[property]) {
         throw new RangeError(`cannot use out. Its ${property} must be "${requirements[property]}" (found "${out[property]}")`);
       }
     }
-
     return out;
   }
 }
+
 /**
  * Same as getOutputImage but allows for an `inPlace` option.
  * @private
@@ -61,20 +54,15 @@ function getOutputImage(thisImage, options, newParameters, internalOptions = {})
  * @param {boolean} [interalOptions.copy] - If true will copy the original image instead of creating a new empty image
  * @return {Image}
  */
-
-
 function getOutputImageOrInPlace(thisImage, options, internalOptions) {
   if (options.inPlace !== undefined && typeof options.inPlace !== 'boolean') {
     throw new TypeError('inPlace option must be a boolean');
   }
-
   if (options.inPlace) {
     if (options.out !== undefined) {
       throw new TypeError('out option must not be set if inPlace option is true');
     }
-
     return thisImage;
   }
-
   return getOutputImage(thisImage, options, null, internalOptions);
 }

package/lib/image/model/model.js

@@ -4,11 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.RGB = exports.HSV = exports.HSL = exports.GREY = exports.CMYK = void 0;
-
 /**
  * Color model of an image
  * @typedef {('GREY'|'RGB'|'HSL'|'HSV'|'CMYK')} ColorModel
  */
+
 const GREY = 'GREY';
 exports.GREY = GREY;
 const RGB = 'RGB';

package/lib/image/morphology/blackHat.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = blackHat;
-
 /**
  * This function is the black top hat (also called black hat).
  * In mathematical morphology and digital image processing,
@@ -30,13 +29,10 @@ function blackHat(options = {}) {
     components: 1,
     alpha: 0
   });
-
   if (kernel.columns % 2 === 0 || kernel.rows % 2 === 0) {
     throw new TypeError('blackHat: The number of rows and columns of the kernel must be odd');
   }
-
   let newImage = this;
-
   for (let i = 0; i < iterations; i++) {
     const closeImage = newImage.close({
       kernel
@@ -45,6 +41,5 @@ function blackHat(options = {}) {
       absolute: true
     });
   }
-
   return newImage;
 }

package/lib/image/morphology/close.js

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

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