image-js 0.35.2 → 0.35.4

package/lib/image/transform/resize/resize.js

@@ -4,17 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = resize;
-
 var _converter = require("../../../util/converter");
-
 var _Image = _interopRequireDefault(require("../../Image"));
-
 var _checks = require("../../internal/checks");
-
 var _nearestNeighbor = _interopRequireDefault(require("./nearestNeighbor"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Resize an image
  * @memberof Image
@@ -36,7 +30,6 @@ function resize(options = {}) {
   const interpolationToUse = (0, _checks.checkInterpolation)(interpolation);
   let width = options.width;
   let height = options.height;
-
   if (!width) {
     if (height && preserveAspectRatio) {
       width = Math.round(height * (this.width / this.height));
@@ -44,7 +37,6 @@ function resize(options = {}) {
       width = this.width;
     }
   }
-
   if (!height) {
     if (preserveAspectRatio) {
       height = Math.round(width * (this.height / this.width));
@@ -52,36 +44,28 @@ function resize(options = {}) {
       height = this.height;
     }
   }
-
   ({
     width,
     height
   } = (0, _converter.factorDimensions)(factor, width, height));
-
   if (width === this.width && height === this.height) {
     const newImage = this.clone();
     newImage.position = [0, 0];
     return newImage;
   }
-
   let shiftX = Math.round((this.width - width) / 2);
   let shiftY = Math.round((this.height - height) / 2);
-
   const newImage = _Image.default.createFrom(this, {
     width,
     height,
     position: [shiftX, shiftY]
   });
-
   switch (interpolationToUse) {
     case _checks.validInterpolations.nearestneighbor:
       _nearestNeighbor.default.call(this, newImage, width, height);
-
       break;
-
     default:
       throw new Error(`unsupported resize interpolation: ${interpolationToUse}`);
   }
-
   return newImage;
 }

package/lib/image/transform/rgba.js

@@ -4,13 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = rgba;
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 var _model = require("../model/model");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Make a copy of the current image and convert to RGBA
  * The source image must have RGB color model, 8 or 16 bits.
@@ -28,18 +24,14 @@ function rgba() {
     alpha: [0, 1],
     colorModel: [_model.RGB]
   });
-
   if (this.colorModel === _model.RGB && this.alpha) {
     return this.clone();
   }
-
   let newImage = _Image.default.createFrom(this, {
     alpha: 1
   });
-
   let ptr = 0;
   let data = this.data;
-
   for (let i = 0; i < data.length; i += this.channels) {
     newImage.data[ptr++] = data[i];
     newImage.data[ptr++] = data[i + 1];
@@ -47,6 +39,5 @@ function rgba() {
     newImage.data[ptr++] = this.maxValue;
     ptr++;
   }
-
   return newImage;
 }

package/lib/image/transform/rgba8.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = rgba8;
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Make a copy of the current image and convert to RGBA 8 bits
  * Those images are the one that are displayed in a canvas.

package/lib/image/transform/rotate.js

@@ -6,13 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.rotate = rotate;
 exports.rotateLeft = rotateLeft;
 exports.rotateRight = rotateRight;
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 var _rotateFree = _interopRequireDefault(require("./rotateFree"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Rotates an image.
  * @memberof Image
@@ -26,28 +22,21 @@ function rotate(angle, options) {
   this.checkProcessable('rotate', {
     bitDepth: [1, 8, 16]
   });
-
   if (typeof angle !== 'number') {
     throw new TypeError('angle must be a number');
   }
-
   if (angle < 0) {
     angle = Math.ceil(-angle / 360) * 360 + angle;
   }
-
   switch (angle % 360) {
     case 0:
       return this.clone();
-
     case 90:
       return rotateRight.call(this);
-
     case 180:
       return rotate180.call(this);
-
     case 270:
       return rotateLeft.call(this);
-
     default:
       return _rotateFree.default.call(this, angle, options);
   }
@@ -59,7 +48,6 @@ function rotate(angle, options) {
  * @return {Image} The new rotated image
  */
 
-
 function rotateLeft() {
   if (this.bitDepth === 1) {
     const newImage = new _Image.default(this.height, this.width, {
@@ -67,7 +55,6 @@ function rotateLeft() {
       parent: this
     });
     const newMaxHeight = newImage.height - 1;
-
     for (let i = 0; i < this.height; i++) {
       for (let j = 0; j < this.width; j++) {
         if (this.getBitXY(j, i)) {
@@ -75,16 +62,13 @@ function rotateLeft() {
         }
       }
     }
-
     return newImage;
   } else {
     const newImage = _Image.default.createFrom(this, {
       width: this.height,
       height: this.width
     });
-
     const newMaxHeight = newImage.height - 1;
-
     for (let i = 0; i < this.height; i++) {
       for (let j = 0; j < this.width; j++) {
         for (let k = 0; k < this.channels; k++) {
@@ -92,7 +76,6 @@ function rotateLeft() {
         }
       }
     }
-
     return newImage;
   }
 }
@@ -103,7 +86,6 @@ function rotateLeft() {
  * @return {Image} The new rotated image
  */
 
-
 function rotateRight() {
   if (this.bitDepth === 1) {
     const newImage = new _Image.default(this.height, this.width, {
@@ -111,7 +93,6 @@ function rotateRight() {
       parent: this
     });
     const newMaxWidth = newImage.width - 1;
-
     for (let i = 0; i < this.height; i++) {
       for (let j = 0; j < this.width; j++) {
         if (this.getBitXY(j, i)) {
@@ -119,16 +100,13 @@ function rotateRight() {
         }
       }
     }
-
     return newImage;
   } else {
     const newImage = _Image.default.createFrom(this, {
       width: this.height,
       height: this.width
     });
-
     const newMaxWidth = newImage.width - 1;
-
     for (let i = 0; i < this.height; i++) {
       for (let j = 0; j < this.width; j++) {
         for (let k = 0; k < this.channels; k++) {
@@ -136,11 +114,9 @@ function rotateRight() {
         }
       }
     }
-
     return newImage;
   }
 }
-
 function rotate180() {
   if (this.bitDepth === 1) {
     const newImage = new _Image.default(this.width, this.height, {
@@ -149,7 +125,6 @@ function rotate180() {
     });
     const newMaxWidth = newImage.width - 1;
     const newMaxHeight = newImage.height - 1;
-
     for (let i = 0; i < this.height; i++) {
       for (let j = 0; j < this.width; j++) {
         if (this.getBitXY(j, i)) {
@@ -157,14 +132,11 @@ function rotate180() {
         }
       }
     }
-
     return newImage;
   } else {
     const newImage = _Image.default.createFrom(this);
-
     const newMaxWidth = newImage.width - 1;
     const newMaxHeight = newImage.height - 1;
-
     for (let i = 0; i < this.height; i++) {
       for (let j = 0; j < this.width; j++) {
         for (let k = 0; k < this.channels; k++) {
@@ -172,7 +144,6 @@ function rotate180() {
         }
       }
     }
-
     return newImage;
   }
 }

package/lib/image/transform/rotateFree.js

@@ -4,24 +4,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = rotateFree;
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 var _checks = require("../internal/checks");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 function rotateFree(degrees, options = {}) {
   const {
     interpolation = _checks.validInterpolations.nearestneighbor,
     width = this.width,
     height = this.height
   } = options;
-
   if (typeof degrees !== 'number') {
     throw new TypeError('degrees must be a number');
   }
-
   const interpolationToUse = (0, _checks.checkInterpolation)(interpolation);
   const radians = degrees * Math.PI / 180;
   const newWidth = Math.floor(Math.abs(width * Math.cos(radians)) + Math.abs(height * Math.sin(radians)));
@@ -30,10 +24,8 @@ function rotateFree(degrees, options = {}) {
   const sin = Math.sin(-radians);
   let x0 = newWidth / 2;
   let y0 = newHeight / 2;
-
   if (newWidth % 2 === 0) {
     x0 = x0 - 0.5;
-
     if (newHeight % 2 === 0) {
       y0 = y0 - 0.5;
     } else {
@@ -41,30 +33,24 @@ function rotateFree(degrees, options = {}) {
     }
   } else {
     x0 = Math.floor(x0);
-
     if (newHeight % 2 === 0) {
       y0 = y0 - 0.5;
     } else {
       y0 = Math.floor(y0);
     }
   }
-
   const incrementX = Math.floor(width / 2 - x0);
   const incrementY = Math.floor(height / 2 - y0);
-
   if (this.bitDepth === 1) {
     const newImage = new _Image.default(newWidth, newHeight, {
       kind: 'BINARY',
       parent: this
     });
-
     switch (interpolationToUse) {
       case _checks.validInterpolations.nearestneighbor:
         return rotateBinaryNearestNeighbor(this, newImage, incrementX, incrementY, x0, y0, cos, sin);
-
       case _checks.validInterpolations.bilinear:
         return rotateBinaryBilinear(this, newImage, incrementX, incrementY, x0, y0, cos, sin);
-
       default:
         throw new Error(`unsupported rotate interpolation: ${interpolationToUse}`);
     }
@@ -73,27 +59,22 @@ function rotateFree(degrees, options = {}) {
       width: newWidth,
       height: newHeight
     });
-
     switch (interpolationToUse) {
       case _checks.validInterpolations.nearestneighbor:
         return rotateNearestNeighbor(this, newImage, incrementX, incrementY, x0, y0, cos, sin);
-
       case _checks.validInterpolations.bilinear:
         return rotateBilinear(this, newImage, incrementX, incrementY, x0, y0, cos, sin);
-
       default:
         throw new Error(`unsupported rotate interpolation: ${interpolationToUse}`);
     }
   }
 }
-
 function rotateNearestNeighbor(thisImage, newImage, incrementX, incrementY, x0, y0, cos, sin) {
   for (let i = 0; i < newImage.width; i += 1) {
     for (let j = 0; j < newImage.height; j += 1) {
       for (let c = 0; c < thisImage.channels; c++) {
         let x = Math.round((i - x0) * cos - (j - y0) * sin + x0) + incrementX;
         let y = Math.round((j - y0) * cos + (i - x0) * sin + y0) + incrementY;
-
         if (x < 0 || x >= thisImage.width || y < 0 || y >= thisImage.height) {
           if (thisImage.alpha === 1 && c === thisImage.channels - 1) {
             newImage.setValueXY(i, j, c, 0);
@@ -106,28 +87,22 @@ function rotateNearestNeighbor(thisImage, newImage, incrementX, incrementY, x0,
       }
     }
   }
-
   return newImage;
 }
-
 function rotateBinaryNearestNeighbor(thisImage, newImage, incrementX, incrementY, x0, y0, cos, sin) {
   for (let i = 0; i < newImage.width; i += 1) {
     for (let j = 0; j < newImage.height; j += 1) {
       let x = Math.round((i - x0) * cos - (j - y0) * sin + x0) + incrementX;
       let y = Math.round((j - y0) * cos + (i - x0) * sin + y0) + incrementY;
-
       if (x < 0 || x >= thisImage.width || y < 0 || y >= thisImage.height || thisImage.getBitXY(x, y)) {
         newImage.setBitXY(i, j);
       }
     }
   }
-
   return newImage;
 }
-
 function rotateBilinear(thisImage, newImage, incrementX, incrementY, x0, y0, cos, sin) {
   let stride = thisImage.width * thisImage.channels;
-
   for (let j = 0; j < newImage.height; j++) {
     for (let i = 0; i < newImage.width; i++) {
       let x = (i - x0) * cos - (j - y0) * sin + x0 + incrementX;
@@ -136,7 +111,6 @@ function rotateBilinear(thisImage, newImage, incrementX, incrementY, x0, y0, cos
       let y1 = y | 0;
       let xDiff = x - x1;
       let yDiff = y - y1;
-
       for (let c = 0; c < thisImage.channels; c++) {
         if (x < 0 || x >= thisImage.width || y < 0 || y >= thisImage.height) {
           if (thisImage.alpha === 1 && c === thisImage.channels - 1) {
@@ -156,13 +130,10 @@ function rotateBilinear(thisImage, newImage, incrementX, incrementY, x0, y0, cos
       }
     }
   }
-
   return newImage;
 }
-
 function rotateBinaryBilinear(thisImage, newImage, incrementX, incrementY, x0, y0, cos, sin) {
   let stride = thisImage.width;
-
   for (let j = 0; j < newImage.height; j++) {
     for (let i = 0; i < newImage.width; i++) {
       let x = (i - x0) * cos - (j - y0) * sin + x0 + incrementX;
@@ -171,7 +142,6 @@ function rotateBinaryBilinear(thisImage, newImage, incrementX, incrementY, x0, y
       let y1 = y | 0;
       let xDiff = x - x1;
       let yDiff = y - y1;
-
       if (x < 0 || x >= thisImage.width || y < 0 || y >= thisImage.height) {
         newImage.setBitXY(i, j);
       } else {
@@ -185,6 +155,5 @@ function rotateBinaryBilinear(thisImage, newImage, incrementX, incrementY, x0, y
       }
     }
   }
-
   return newImage;
 }

package/lib/image/transform/warping.js

@@ -4,18 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = warpingFourPoints;
-
 var _mlMatrix = require("ml-matrix");
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 // REFERENCES :
 // https://stackoverflow.com/questions/38285229/calculating-aspect-ratio-of-perspective-transform-destination-image/38402378#38402378
 // http://www.corrmap.com/features/homography_transformation.php
 // https://ags.cs.uni-kl.de/fileadmin/inf_ags/3dcv-ws11-12/3DCV_WS11-12_lec04.pdf
 // http://graphics.cs.cmu.edu/courses/15-463/2011_fall/Lectures/morphing.pdf
+
 function order4Points(pts) {
   let tl = 0;
   let tr = 0;
@@ -23,28 +20,23 @@ function order4Points(pts) {
   let bl = 0;
   let minX = pts[0][0];
   let indexMinX = 0;
-
   for (let i = 1; i < pts.length; i++) {
     if (pts[i][0] < minX) {
       minX = pts[i][0];
       indexMinX = i;
     }
   }
-
   let minX2 = pts[(indexMinX + 1) % pts.length][0];
   let indexMinX2 = (indexMinX + 1) % pts.length;
-
   for (let i = 1; i < pts.length; i++) {
     if (pts[i][0] < minX2 && i !== indexMinX) {
       minX2 = pts[i][0];
       indexMinX2 = i;
     }
   }
-
   if (pts[indexMinX2][1] < pts[indexMinX][1]) {
     tl = pts[indexMinX2];
     bl = pts[indexMinX];
-
     if (indexMinX !== (indexMinX2 + 1) % 4) {
       tr = pts[(indexMinX2 + 1) % 4];
       br = pts[(indexMinX2 + 2) % 4];
@@ -55,7 +47,6 @@ function order4Points(pts) {
   } else {
     bl = pts[indexMinX2];
     tl = pts[indexMinX];
-
     if (indexMinX2 !== (indexMinX + 1) % 4) {
       tr = pts[(indexMinX + 1) % 4];
       br = pts[(indexMinX + 2) % 4];
@@ -64,24 +55,19 @@ function order4Points(pts) {
       br = pts[(indexMinX + 3) % 4];
     }
   }
-
   return [tl, tr, br, bl];
 }
-
 function distance2Points(p1, p2) {
   return Math.sqrt(Math.pow(p1[0] - p2[0], 2) + Math.pow(p1[1] - p2[1], 2));
 }
-
 function crossVect(u, v) {
   let result = [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]];
   return result;
 }
-
 function dotVect(u, v) {
   let result = u[0] * v[0] + u[1] * v[1] + u[2] * v[2];
   return result;
 }
-
 function computeWidthAndHeigth(tl, tr, br, bl, widthImage, heightImage) {
   let w = Math.max(distance2Points(tl, tr), distance2Points(bl, br));
   let h = Math.max(distance2Points(tl, bl), distance2Points(tr, br));
@@ -105,24 +91,18 @@ function computeWidthAndHeigth(tl, tr, br, bl, widthImage, heightImage) {
   let n32 = n3[1];
   let n33 = n3[2];
   let f = 1.0 / (n23 * n33) * (n21 * n31 - (n21 * n33 + n23 * n31) * u0 + n23 * n33 * u0 * u0 + (n22 * n32 - (n22 * n33 + n23 * n32) * v0 + n23 * n33 * v0 * v0));
-
   if (f >= 0) {
     f = Math.sqrt(f);
   } else {
     f = Math.sqrt(-f);
   }
-
   let A = new _mlMatrix.Matrix([[f, 0, u0], [0, f, v0], [0, 0, 1]]);
   let At = A.transpose();
   let Ati = (0, _mlMatrix.inverse)(At);
   let Ai = (0, _mlMatrix.inverse)(A);
-
   let n2R = _mlMatrix.Matrix.rowVector(n2);
-
   let n3R = _mlMatrix.Matrix.rowVector(n3);
-
   let arReal = Math.sqrt(dotVect(n2R.mmul(Ati).mmul(Ai).to1DArray(), n2) / dotVect(n3R.mmul(Ati).mmul(Ai).to1DArray(), n3));
-
   if (arReal === 0 || arVis === 0) {
     finalW = Math.ceil(w);
     finalH = Math.ceil(h);
@@ -133,14 +113,13 @@ function computeWidthAndHeigth(tl, tr, br, bl, widthImage, heightImage) {
     finalH = Math.ceil(h);
     finalW = Math.ceil(arReal * finalH);
   }
-
   return [finalW, finalH];
 }
-
 function projectionPoint(x, y, a, b, c, d, e, f, g, h, image, channel) {
   let [newX, newY] = [(a * x + b * y + c) / (g * x + h * y + 1), (d * x + e * y + f) / (g * x + h * y + 1)];
   return image.getValueXY(Math.floor(newX), Math.floor(newY), channel);
 }
+
 /**
  * Transform a quadrilateral into a rectangle
  * @memberof Image
@@ -155,34 +134,28 @@ function projectionPoint(x, y, a, b, c, d, e, f, g, h, image, channel) {
  * });
  */
 
-
 function warpingFourPoints(pts, options = {}) {
   let {
     calculateRatio = true
   } = options;
-
   if (pts.length !== 4) {
     throw new Error(`The array pts must have four elements, which are the four corners. Currently, pts have ${pts.length} elements`);
   }
-
   let [pt1, pt2, pt3, pt4] = pts;
   let quadrilaterial = [pt1, pt2, pt3, pt4];
   let [tl, tr, br, bl] = order4Points(quadrilaterial);
   let widthRect;
   let heightRect;
-
   if (calculateRatio) {
     [widthRect, heightRect] = computeWidthAndHeigth(tl, tr, br, bl, this.width, this.height);
   } else {
     widthRect = Math.ceil(Math.max(distance2Points(tl, tr), distance2Points(bl, br)));
     heightRect = Math.ceil(Math.max(distance2Points(tl, bl), distance2Points(tr, br)));
   }
-
   let newImage = _Image.default.createFrom(this, {
     width: widthRect,
     height: heightRect
   });
-
   let [X1, Y1] = tl;
   let [X2, Y2] = tr;
   let [X3, Y3] = br;
@@ -192,26 +165,20 @@ function warpingFourPoints(pts, options = {}) {
   let [x3, y3] = [heightRect - 1, widthRect - 1];
   let [x4, y4] = [heightRect - 1, 0];
   let S = new _mlMatrix.Matrix([[x1, y1, 1, 0, 0, 0, -x1 * X1, -y1 * X1], [x2, y2, 1, 0, 0, 0, -x2 * X2, -y2 * X2], [x3, y3, 1, 0, 0, 0, -x3 * X3, -y1 * X3], [x4, y4, 1, 0, 0, 0, -x4 * X4, -y4 * X4], [0, 0, 0, x1, y1, 1, -x1 * Y1, -y1 * Y1], [0, 0, 0, x2, y2, 1, -x2 * Y2, -y2 * Y2], [0, 0, 0, x3, y3, 1, -x3 * Y3, -y3 * Y3], [0, 0, 0, x4, y4, 1, -x4 * Y4, -y4 * Y4]]);
-
   let D = _mlMatrix.Matrix.columnVector([X1, X2, X3, X4, Y1, Y2, Y3, Y4]);
-
   let svd = new _mlMatrix.SingularValueDecomposition(S);
   let T = svd.solve(D); // solve S*T = D
-
   let [a, b, c, d, e, f, g, h] = T.to1DArray();
   let Xt = new _mlMatrix.Matrix(heightRect, widthRect);
-
   for (let channel = 0; channel < this.channels; channel++) {
     for (let i = 0; i < heightRect; i++) {
       for (let j = 0; j < widthRect; j++) {
         Xt.set(i, j, projectionPoint(i, j, a, b, c, d, e, f, g, h, this, channel));
       }
     }
-
     newImage.setMatrix(Xt, {
       channel: channel
     });
   }
-
   return newImage;
 }

package/lib/image/utility/combineChannels.js

@@ -4,13 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = combineChannels;
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 var _model = require("../model/model");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Create a new grey Image by combining the channels of the current image.
  * @memberof Image
@@ -31,33 +27,26 @@ function combineChannels(method = defaultCombineMethod, options = {}) {
   this.checkProcessable('combineChannels', {
     bitDepth: [8, 16]
   });
-
   let newImage = _Image.default.createFrom(this, {
     components: 1,
     alpha: keepAlpha,
     colorModel: _model.GREY
   });
-
   let ptr = 0;
-
   for (let i = 0; i < this.size; i++) {
     // TODO quite slow because we create a new pixel each time
     let value = method(this.getPixel(i));
-
     if (mergeAlpha) {
       newImage.data[ptr++] = value * this.data[i * this.channels + this.components] / this.maxValue;
     } else {
       newImage.data[ptr++] = value;
-
       if (keepAlpha) {
         newImage.data[ptr++] = this.data[i * this.channels + this.components];
       }
     }
   }
-
   return newImage;
 }
-
 function defaultCombineMethod(pixel) {
   return (pixel[0] + pixel[1] + pixel[2]) / 3;
 }