image-js 0.35.1 → 0.35.3

package/lib/image/transform/cmyk.js

@@ -4,13 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = cmyk;
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 var _model = require("../model/model");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 // http://www.easyrgb.com/index.php?X=MATH&H=18#text18
 // check rgbToHsl : https://bgrins.github.io/TinyColor/docs/tinycolor.html
 
@@ -31,15 +27,12 @@ function cmyk() {
     alpha: [0, 1],
     colorModel: [_model.RGB]
   });
-
   let newImage = _Image.default.createFrom(this, {
     components: 4,
     colorModel: _model.CMYK
   });
-
   let ptr = 0;
   let data = this.data;
-
   for (let i = 0; i < data.length; i += this.channels) {
     let red = data[i];
     let green = data[i + 1];
@@ -52,11 +45,9 @@ function cmyk() {
     newImage.data[ptr++] = Math.round(magenta);
     newImage.data[ptr++] = Math.round(yellow);
     newImage.data[ptr++] = Math.round(black);
-
     if (this.alpha) {
       newImage.data[ptr++] = data[i + 3];
     }
   }
-
   return newImage;
 }

package/lib/image/transform/colorDepth.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = colorDepth;
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Change the image color depth.
  * The color depth is the number of bits that is assigned to each point of a channel.
@@ -25,19 +22,15 @@ function colorDepth(newColorDepth = 8) {
   this.checkProcessable('colorDepth', {
     bitDepth: [1, 8, 16]
   });
-
   if (![8, 16].includes(newColorDepth)) {
     throw Error('You need to specify the new colorDepth as 8 or 16');
   }
-
   if (this.bitDepth === newColorDepth) {
     return this.clone();
   }
-
   let newImage = _Image.default.createFrom(this, {
     bitDepth: newColorDepth
   });
-
   switch (newColorDepth) {
     case 8:
       if (this.bitDepth === 1) {
@@ -51,9 +44,7 @@ function colorDepth(newColorDepth = 8) {
           newImage.data[i] = this.data[i] >> 8;
         }
       }
-
       break;
-
     case 16:
       if (this.bitDepth === 1) {
         for (let i = 0; i < this.size; i++) {
@@ -66,12 +57,9 @@ function colorDepth(newColorDepth = 8) {
           newImage.data[i] = this.data[i] << 8 | this.data[i];
         }
       }
-
       break;
-
     default:
       throw new Error('colorDepth conversion unexpected case');
   }
-
   return newImage;
 }

package/lib/image/transform/crop.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = crop;
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Crops the image
  * @memberof Image
@@ -39,25 +36,19 @@ function crop(options = {}) {
   y = Math.round(y);
   width = Math.round(width);
   height = Math.round(height);
-
   if (x > this.width - 1 || y > this.height - 1) {
     throw new RangeError(`crop: origin (x:${x}, y:${y}) out of range (${this.width - 1}; ${this.height - 1})`);
   }
-
   if (width <= 0 || height <= 0) {
     throw new RangeError(`crop: width and height (width:${width}; height:${height}) must be positive numbers`);
   }
-
   if (x < 0 || y < 0) {
     throw new RangeError(`crop: x and y (x:${x}, y:${y}) must be positive numbers`);
   }
-
   if (width > this.width - x || height > this.height - y) {
     throw new RangeError(`crop: (x: ${x}, y:${y}, width:${width}, height:${height}) size is out of range`);
   }
-
   let result = this;
-
   if (this.bitDepth === 1) {
     const newImage = new _Image.default(width, height, {
       kind: 'BINARY',
@@ -70,51 +61,40 @@ function crop(options = {}) {
       height,
       position: [x, y]
     });
-
     result = cropDefault(this, newImage, x, y, width, height);
   }
-
   return result;
 }
-
 function cropDefault(img, newImage, x, y, width, height) {
   let xWidth = width * img.channels;
   let y1 = y + height;
   let ptr = 0; // pointer for new array
 
   let jLeft = x * img.channels;
-
   for (let i = y; i < y1; i++) {
     let j = i * img.width * img.channels + jLeft;
     let jL = j + xWidth;
-
     for (; j < jL; j++) {
       newImage.data[ptr++] = img.data[j];
     }
   }
-
   return newImage;
 }
-
 function cropBinary(img, newImage, x, y, width, height) {
   let xWidth = width * img.channels;
   let y1 = y + height;
   let ptr = 0; // pointer for new array
 
   let jLeft = x * img.channels;
-
   for (let i = y; i < y1; i++) {
     let j = i * img.width * img.channels + jLeft;
     let jL = j + xWidth;
-
     for (; j < jL; j++) {
       if (img.getBit(j)) {
         newImage.setBit(ptr);
       }
-
       ++ptr;
     }
   }
-
   return newImage;
 }

package/lib/image/transform/cropAlpha.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = cropAlpha;
-
 /**
  * Crops the image based on the alpha channel
  * This removes lines and columns where the alpha channel is lower than a threshold value.
@@ -22,11 +21,9 @@ function cropAlpha(options = {}) {
     threshold = this.maxValue
   } = options;
   let left = findLeft(this, threshold, this.components);
-
   if (left === -1) {
     throw new Error('Could not find new dimensions. Threshold may be too high.');
   }
-
   let top = findTop(this, threshold, this.components, left);
   let bottom = findBottom(this, threshold, this.components, left);
   let right = findRight(this, threshold, this.components, left, top, bottom);
@@ -37,7 +34,6 @@ function cropAlpha(options = {}) {
     height: bottom - top + 1
   });
 }
-
 function findLeft(image, threshold, channel) {
   for (let x = 0; x < image.width; x++) {
     for (let y = 0; y < image.height; y++) {
@@ -46,10 +42,8 @@ function findLeft(image, threshold, channel) {
       }
     }
   }
-
   return -1;
 }
-
 function findTop(image, threshold, channel, left) {
   for (let y = 0; y < image.height; y++) {
     for (let x = left; x < image.width; x++) {
@@ -58,10 +52,8 @@ function findTop(image, threshold, channel, left) {
       }
     }
   }
-
   return -1;
 }
-
 function findBottom(image, threshold, channel, left) {
   for (let y = image.height - 1; y >= 0; y--) {
     for (let x = left; x < image.width; x++) {
@@ -70,10 +62,8 @@ function findBottom(image, threshold, channel, left) {
       }
     }
   }
-
   return -1;
 }
-
 function findRight(image, threshold, channel, left, top, bottom) {
   for (let x = image.width - 1; x >= left; x--) {
     for (let y = top; y <= bottom; y++) {
@@ -82,6 +72,5 @@ function findRight(image, threshold, channel, left, top, bottom) {
       }
     }
   }
-
   return -1;
 }

package/lib/image/transform/grey.js

@@ -4,15 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = grey;
-
 var _clamp = require("../internal/clamp");
-
 var _getOutputImage = require("../internal/getOutputImage");
-
 var _model = require("../model/model");
-
 var _greyAlgorithms = require("./greyAlgorithms");
-
 /**
  * Call back that converts the RGB channels to grey. It will be clamped after.
  * @callback GreyAlgorithmCallback
@@ -44,57 +39,46 @@ function grey(options = {}) {
     keepAlpha = false,
     mergeAlpha = true
   } = options;
-
   if (typeof algorithm !== 'string' && typeof algorithm !== 'function') {
     throw new TypeError('algorithm must be a string or a function');
   }
-
   this.checkProcessable('grey', {
     bitDepth: [8, 16],
     alpha: [0, 1]
   });
-
   if (this.components === 1) {
     algorithm = 'red'; // actually we just take the first channel if it is a grey image
   }
 
   keepAlpha &= this.alpha;
   mergeAlpha &= this.alpha;
-
   if (keepAlpha) {
     mergeAlpha = false;
   }
-
   let newImage = (0, _getOutputImage.getOutputImage)(this, options, {
     components: 1,
     alpha: keepAlpha,
     colorModel: _model.GREY
   });
   let method;
-
   if (typeof algorithm === 'function') {
     method = algorithm;
   } else {
     method = _greyAlgorithms.methods[algorithm.toLowerCase()];
-
     if (!method) {
       throw new Error(`unsupported grey algorithm: ${algorithm}`);
     }
   }
-
   let ptr = 0;
-
   for (let i = 0; i < this.data.length; i += this.channels) {
     if (mergeAlpha) {
       newImage.data[ptr++] = (0, _clamp.clamp)(method(this.data[i], this.data[i + 1], this.data[i + 2], this) * this.data[i + this.components] / this.maxValue, this);
     } else {
       newImage.data[ptr++] = (0, _clamp.clamp)(method(this.data[i], this.data[i + 1], this.data[i + 2], this), this);
-
       if (newImage.alpha) {
         newImage.data[ptr++] = this.data[i + this.components];
       }
     }
   }
-
   return newImage;
 }

package/lib/image/transform/greyAlgorithms.js

@@ -4,10 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.names = exports.methods = void 0;
-
 /**
  * @typedef {('luma709'|'luma601'|'maximum'|'minimum'|'average'|'minmax'|'red'|'green'|'blue'|'cyan'|'magenta'|'yellow'|'black'|'hue'|'saturation'|'lightness')} GreyAlgorithm
  */
+
 const methods = {
   luma709(red, green, blue) {
     // sRGB
@@ -19,91 +19,70 @@ const methods = {
     // Same result, > 10% faster on the full grey conversion
     return red * 6966 + green * 23436 + blue * 2366 >> 15;
   },
-
   luma601(red, green, blue) {
     // NTSC
     // return this.red * 0.299 + green * 0.587 + blue * 0.114;
     return red * 9798 + green * 19235 + blue * 3735 >> 15;
   },
-
   maximum(red, green, blue) {
     return Math.max(red, green, blue);
   },
-
   minimum(red, green, blue) {
     return Math.min(red, green, blue);
   },
-
   average(red, green, blue) {
     return (red + green + blue) / 3 >> 0;
   },
-
   minmax(red, green, blue) {
     return (Math.max(red, green, blue) + Math.min(red, green, blue)) / 2;
   },
-
   red(red) {
     return red;
   },
-
   green(red, green) {
     return green;
   },
-
   blue(red, green, blue) {
     return blue;
   },
-
   cyan(red, green, blue, image) {
     let black = methods.black(red, green, blue, image);
     return (image.maxValue - red - black) / (1 - black / image.maxValue) >> 0;
   },
-
   magenta(red, green, blue, image) {
     let black = methods.black(red, green, blue, image);
     return (image.maxValue - green - black) / (1 - black / image.maxValue) >> 0;
   },
-
   yellow(red, green, blue, image) {
     let black = methods.black(red, green, blue, image);
     return (image.maxValue - blue - black) / (1 - black / image.maxValue) >> 0;
   },
-
   black(red, green, blue, image) {
     return Math.min(image.maxValue - red, image.maxValue - green, image.maxValue - blue);
   },
-
   hue(red, green, blue, image) {
     let min = methods.min(red, green, blue);
     let max = methods.max(red, green, blue);
-
     if (max === min) {
       return 0;
     }
-
     let hue = 0;
     let delta = max - min;
-
     switch (max) {
       case red:
         hue = (green - blue) / delta + (green < blue ? 6 : 0);
         break;
-
       case green:
         hue = (blue - red) / delta + 2;
         break;
-
       case blue:
         hue = (red - green) / delta + 4;
         break;
-
       default:
         throw new Error('unreachable');
     }
-
     return hue / 6 * image.maxValue >> 0;
   },
-
   saturation(red, green, blue, image) {
     // from HSV model
     let min = methods.min(red, green, blue);
@@ -111,13 +90,11 @@ const methods = {
     let delta = max - min;
     return max === 0 ? 0 : delta / max * image.maxValue;
   },
-
   lightness(red, green, blue) {
     let min = methods.min(red, green, blue);
     let max = methods.max(red, green, blue);
     return (max + min) / 2;
   }
-
 };
 exports.methods = methods;
 Object.defineProperty(methods, 'luminosity', {

package/lib/image/transform/hsl.js

@@ -4,13 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = hsl;
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 var _model = require("../model/model");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 // http://www.easyrgb.com/index.php?X=MATH&H=18#text18
 // check rgbToHsl : https://bgrins.github.io/TinyColor/docs/tinycolor.html
 
@@ -31,15 +27,12 @@ function hsl() {
     alpha: [0, 1],
     colorModel: [_model.RGB]
   });
-
   let newImage = _Image.default.createFrom(this, {
     colorModel: _model.HSL
   });
-
   let threshold = Math.floor(this.maxValue / 2);
   let ptr = 0;
   let data = this.data;
-
   for (let i = 0; i < data.length; i += this.channels) {
     let red = data[i];
     let green = data[i + 1];
@@ -49,39 +42,30 @@ function hsl() {
     let hue = 0;
     let saturation = 0;
     let luminance = (max + min) / 2;
-
     if (max !== min) {
       let delta = max - min;
       saturation = luminance > threshold ? delta / (2 - max - min) : delta / (max + min);
-
       switch (max) {
         case red:
           hue = (green - blue) / delta + (green < blue ? 6 : 0);
           break;
-
         case green:
           hue = (blue - red) / delta + 2;
           break;
-
         case blue:
           hue = (red - green) / delta + 4;
           break;
-
         default:
           throw new Error('unreachable');
       }
-
       hue /= 6;
     }
-
     newImage.data[ptr++] = hue * this.maxValue;
     newImage.data[ptr++] = saturation * this.maxValue;
     newImage.data[ptr++] = luminance;
-
     if (this.alpha) {
       newImage.data[ptr++] = data[i + 3];
     }
   }
-
   return newImage;
 }

package/lib/image/transform/hsv.js

@@ -4,13 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = hsv;
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 var _model = require("../model/model");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 // based on https://bgrins.github.io/TinyColor/docs/tinycolor.html
 
 /**
@@ -30,14 +26,11 @@ function hsv() {
     alpha: [0, 1],
     colorModel: [_model.RGB]
   });
-
   let newImage = _Image.default.createFrom(this, {
     colorModel: _model.HSV
   });
-
   let ptr = 0;
   let data = this.data;
-
   for (let i = 0; i < data.length; i += this.channels) {
     let red = data[i];
     let green = data[i + 1];
@@ -48,36 +41,28 @@ function hsv() {
     let hue = 0;
     let saturation = max === 0 ? 0 : delta / max;
     let value = max;
-
     if (max !== min) {
       switch (max) {
         case red:
           hue = (green - blue) / delta + (green < blue ? 6 : 0);
           break;
-
         case green:
           hue = (blue - red) / delta + 2;
           break;
-
         case blue:
           hue = (red - green) / delta + 4;
           break;
-
         default:
           throw new Error('unreachable');
       }
-
       hue /= 6;
     }
-
     newImage.data[ptr++] = hue * this.maxValue;
     newImage.data[ptr++] = saturation * this.maxValue;
     newImage.data[ptr++] = value;
-
     if (this.alpha) {
       newImage.data[ptr++] = data[i + 3];
     }
   }
-
   return newImage;
 }

package/lib/image/transform/insert.js

@@ -4,13 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = insert;
-
 var _getImageParameters = _interopRequireDefault(require("../internal/getImageParameters"));
-
 var _getOutputImage = require("../internal/getOutputImage");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Inserts an image within another image.
  * @memberof Image
@@ -34,7 +30,6 @@ function insert(toInsert, options = {}) {
   });
   const maxY = Math.min(out.height, y + toInsert.height);
   const maxX = Math.min(out.width, x + toInsert.width);
-
   if (out.bitDepth === 1) {
     for (let j = y; j < maxY; j++) {
       for (let i = x; i < maxX; i++) {
@@ -49,6 +44,5 @@ function insert(toInsert, options = {}) {
       }
     }
   }
-
   return out;
 }

package/lib/image/transform/mask/huang.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = huang;
-
 /*
  *
  * see http://rsb.info.nih.gov/ij/developer/source/ij/process/AutoThresholder.java.html.
@@ -12,82 +11,68 @@ exports.default = huang;
  * "Image thresholding by minimizing the measure of fuzziness", Pattern Recognition 28(1): 41-51
  *
  */
+
 function huang(histogram) {
   /* Determine the first non-zero bin */
   let firstBin = 0;
-
   for (let ih = 0; ih < histogram.length; ih++) {
     if (histogram[ih] !== 0) {
       firstBin = ih;
       break;
     }
   }
-  /* Determine the last non-zero bin */
-
 
+  /* Determine the last non-zero bin */
   let lastBin = histogram.length - 1;
-
   for (let ih = histogram.length - 1; ih >= firstBin; ih--) {
     if (histogram[ih] !== 0) {
       lastBin = ih;
       break;
     }
   }
-
   let term = 1.0 / (lastBin - firstBin);
   let mu0 = new Array(histogram.length);
   let sumPix = 0;
   let numPix = 0;
-
   for (let ih = firstBin; ih < histogram.length; ih++) {
     sumPix += ih * histogram[ih];
     numPix += histogram[ih];
     mu0[ih] = sumPix / numPix;
   }
-
   let mu1 = new Array(histogram.length);
   sumPix = numPix = 0;
-
   for (let ih = lastBin; ih > 0; ih--) {
     sumPix += ih * histogram[ih];
     numPix += histogram[ih];
     mu1[ih - 1] = sumPix / numPix;
   }
-  /* Determine the threshold that minimizes the fuzzy entropy*/
-
 
+  /* Determine the threshold that minimizes the fuzzy entropy*/
   let threshold = -1;
   let minEnt = Number.MAX_VALUE;
-
   for (let it = 0; it < histogram.length; it++) {
     let ent = 0;
     let muX;
-
     for (let ih = 0; ih <= it; ih++) {
       /* Equation (4) in Ref. 1 */
       muX = 1 / (1 + term * Math.abs(ih - mu0[it]));
-
       if (!(muX < 1e-6 || muX > 0.999999)) {
         /* Equation (6) & (8) in Ref. 1 */
         ent += histogram[ih] * (-muX * Math.log(muX) - (1 - muX) * Math.log(1 - muX));
       }
     }
-
     for (let ih = it + 1; ih < histogram.length; ih++) {
       /* Equation (4) in Ref. 1 */
       muX = 1 / (1 + term * Math.abs(ih - mu1[it]));
-
       if (!(muX < 1e-6 || muX > 0.999999)) {
         /* Equation (6) & (8) in Ref. 1 */
         ent += histogram[ih] * (-muX * Math.log(muX) - (1 - muX) * Math.log(1 - muX));
       }
     }
-
     if (ent < minEnt) {
       minEnt = ent;
       threshold = it;
     }
   }
-
   return threshold;
 }