image-js 0.33.2 → 0.35.0

package/index.d.ts

@@ -32,7 +32,7 @@ export declare class Image {
   static createFrom(other: Image, options: ImageConstructorOptions): Image;
   static load(
     image: string | ArrayBuffer | Uint8Array,
-    options?: RequestInit,
+    options?: RequestInit & { ignorePalette: boolean },
   ): Promise<Image>;
 
   getRoiManager(): RoiManager;
@@ -135,7 +135,7 @@ export declare class Image {
   // split
   // getChannel
   // combineChannels
-  // setChannel
+  setChannel(channel: any, image: Image): this;
   // getSimilarity
   // getPixelsGrid
   // getBestMatch
@@ -145,14 +145,30 @@ export declare class Image {
   // extract
   // floodFill
   // paintLabels
-  // paintMasks
+  paintMasks(
+    masks: Image | Array<Image>,
+    options?: {
+      color?: Array<number> | string;
+      colors?: Array<Array<number>> | Array<string>;
+      randomColors?: boolean;
+      distinctColors?: boolean;
+      alpha?: number;
+      labels?: Array<string>;
+      labelsPosition?: Array<Array<number>>;
+      labelColor?: string;
+      labelFont?: string;
+    },
+  ): Image;
   // paintPoints
   // paintPolyline
   // paintPolylines
-  paintPolygon(points: Array<Array<number>>, options?: {
-    color?: Array<number>;
-    filled?: boolean;
-  }): Image;
+  paintPolygon(
+    points: Array<Array<number>>,
+    options?: {
+      color?: Array<number>;
+      filled?: boolean;
+    },
+  ): Image;
 
   // paintPolygons
 

package/lib/image/core/load.js

@@ -34,7 +34,10 @@ const isDataURL = /^data:[a-z]+\/(?:[a-z]+);base64,/;
  * @static
  * @param {string|ArrayBuffer|Buffer|Uint8Array} image - URL of the image (browser, can be a dataURL) or path (Node.js)
  * or buffer containing the binary data
- * @param {object} [options] - In the browser, the options object is passed to the underlying `fetch` call.
+ * @param {object} [options] - In the browser, the options object is passed to the underlying `fetch` call, along with
+ * the data URL. For binary data, the option specify decoding options.
+ * @param {boolean} [options.ignorePalette] - When set to true and loading a tiff from binary data, if the tiff is of
+ * type 3 (palette), load as single channel greyscale rather than as a pseudo-colored RGB.
  * @return {Promise<Image>}
  * @example
  * const image = await Image.load('https://example.com/image.png');
@@ -44,15 +47,15 @@ function load(image, options) {
   if (typeof image === 'string') {
     return loadURL(image, options);
   } else if (image instanceof ArrayBuffer) {
-    return Promise.resolve(loadBinary(new Uint8Array(image)));
+    return Promise.resolve(loadBinary(new Uint8Array(image), undefined, options && options.ignorePalette));
   } else if (image.buffer) {
-    return Promise.resolve(loadBinary(image));
+    return Promise.resolve(loadBinary(image, undefined, options && options.ignorePalette));
   } else {
     throw new Error('argument to "load" must be a string or buffer.');
   }
 }
 
-function loadBinary(image, base64Url) {
+function loadBinary(image, base64Url, ignorePalette) {
   const type = (0, _imageType.default)(image);
 
   if (type) {
@@ -64,7 +67,7 @@ function loadBinary(image, base64Url) {
         return loadJPEG(image);
 
       case 'image/tiff':
-        return loadTIFF(image);
+        return loadTIFF(image, ignorePalette);
 
       default:
         return loadGeneric(getBase64(type.mime));
@@ -94,7 +97,7 @@ function loadURL(url, options) {
 
   return binaryDataP.then(binaryData => {
     const uint8 = new Uint8Array(binaryData);
-    return loadBinary(uint8, dataURL ? url : undefined);
+    return loadBinary(uint8, dataURL ? url : undefined, options && options.ignorePalette);
   });
 }
 
@@ -195,13 +198,15 @@ function loadJPEG(data) {
   return image;
 }
 
-function loadTIFF(data) {
+function loadTIFF(data, ignorePalette) {
   let result = (0, _tiff.decode)(data);
 
   if (result.length === 1) {
-    return getImageFromIFD(result[0]);
+    return getImageFromIFD(result[0], ignorePalette);
   } else {
-    return new _Stack.default(result.map(getImageFromIFD));
+    return new _Stack.default(result.map(function (image) {
+      return getImageFromIFD(image, ignorePalette);
+    }));
   }
 }
 
@@ -224,8 +229,8 @@ function getMetadata(image) {
   return metadata;
 }
 
-function getImageFromIFD(image) {
-  if (image.type === 3) {
+function getImageFromIFD(image, ignorePalette) {
+  if (!ignorePalette && image.type === 3) {
     // Palette
     const data = new Uint16Array(3 * image.width * image.height);
     const palette = image.palette;

package/lib/image/transform/crop.js

@@ -32,8 +32,8 @@ function crop(options = {}) {
     width = this.width - x,
     height = this.height - y
   } = options;
-  this.checkProcessable('max', {
-    bitDepth: [8, 16]
+  this.checkProcessable('crop', {
+    bitDepth: [1, 8, 16]
   });
   x = Math.round(x);
   y = Math.round(y);
@@ -56,24 +56,63 @@ function crop(options = {}) {
     throw new RangeError(`crop: (x: ${x}, y:${y}, width:${width}, height:${height}) size is out of range`);
   }
 
-  let newImage = _Image.default.createFrom(this, {
-    width,
-    height,
-    position: [x, y]
-  });
+  let result = this;
+
+  if (this.bitDepth === 1) {
+    const newImage = new _Image.default(width, height, {
+      kind: 'BINARY',
+      parent: this
+    });
+    result = cropBinary(this, newImage, x, y, width, height);
+  } else {
+    const newImage = _Image.default.createFrom(this, {
+      width,
+      height,
+      position: [x, y]
+    });
+
+    result = cropDefault(this, newImage, x, y, width, height);
+  }
+
+  return result;
+}
 
-  let xWidth = width * this.channels;
+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 * this.channels;
+  let jLeft = x * img.channels;
 
   for (let i = y; i < y1; i++) {
-    let j = i * this.width * this.channels + jLeft;
+    let j = i * img.width * img.channels + jLeft;
     let jL = j + xWidth;
 
     for (; j < jL; j++) {
-      newImage.data[ptr++] = this.data[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;
     }
   }
 

package/lib/image/transform/rotate.js

@@ -23,6 +23,10 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @return {Image} The new rotated image
  */
 function rotate(angle, options) {
+  this.checkProcessable('rotate', {
+    bitDepth: [1, 8, 16]
+  });
+
   if (typeof angle !== 'number') {
     throw new TypeError('angle must be a number');
   }
@@ -57,22 +61,40 @@ function rotate(angle, options) {
 
 
 function rotateLeft() {
-  const newImage = _Image.default.createFrom(this, {
-    width: this.height,
-    height: this.width
-  });
+  if (this.bitDepth === 1) {
+    const newImage = new _Image.default(this.height, this.width, {
+      kind: 'BINARY',
+      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)) {
+          newImage.setBitXY(i, newMaxHeight - j);
+        }
+      }
+    }
 
-  const newMaxHeight = newImage.height - 1;
+    return newImage;
+  } else {
+    const newImage = _Image.default.createFrom(this, {
+      width: this.height,
+      height: this.width
+    });
 
-  for (let i = 0; i < this.height; i++) {
-    for (let j = 0; j < this.width; j++) {
-      for (let k = 0; k < this.channels; k++) {
-        newImage.setValueXY(i, newMaxHeight - j, k, this.getValueXY(j, i, k));
+    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++) {
+          newImage.setValueXY(i, newMaxHeight - j, k, this.getValueXY(j, i, k));
+        }
       }
     }
-  }
 
-  return newImage;
+    return newImage;
+  }
 }
 /**
  * Rotates an image clockwise
@@ -83,37 +105,74 @@ function rotateLeft() {
 
 
 function rotateRight() {
-  const newImage = _Image.default.createFrom(this, {
-    width: this.height,
-    height: this.width
-  });
+  if (this.bitDepth === 1) {
+    const newImage = new _Image.default(this.height, this.width, {
+      kind: 'BINARY',
+      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)) {
+          newImage.setBitXY(newMaxWidth - i, j);
+        }
+      }
+    }
+
+    return newImage;
+  } else {
+    const newImage = _Image.default.createFrom(this, {
+      width: this.height,
+      height: this.width
+    });
 
-  const newMaxWidth = newImage.width - 1;
+    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++) {
-        newImage.setValueXY(newMaxWidth - i, j, k, this.getValueXY(j, i, k));
+    for (let i = 0; i < this.height; i++) {
+      for (let j = 0; j < this.width; j++) {
+        for (let k = 0; k < this.channels; k++) {
+          newImage.setValueXY(newMaxWidth - i, j, k, this.getValueXY(j, i, k));
+        }
       }
     }
-  }
 
-  return newImage;
+    return newImage;
+  }
 }
 
 function rotate180() {
-  const newImage = _Image.default.createFrom(this);
+  if (this.bitDepth === 1) {
+    const newImage = new _Image.default(this.width, this.height, {
+      kind: 'BINARY',
+      parent: 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++) {
+        if (this.getBitXY(j, i)) {
+          newImage.setBitXY(newMaxWidth - j, newMaxHeight - i);
+        }
+      }
+    }
+
+    return newImage;
+  } else {
+    const newImage = _Image.default.createFrom(this);
 
-  const newMaxWidth = newImage.width - 1;
-  const newMaxHeight = newImage.height - 1;
+    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++) {
-        newImage.setValueXY(newMaxWidth - j, newMaxHeight - i, k, this.getValueXY(j, i, k));
+    for (let i = 0; i < this.height; i++) {
+      for (let j = 0; j < this.width; j++) {
+        for (let k = 0; k < this.channels; k++) {
+          newImage.setValueXY(newMaxWidth - j, newMaxHeight - i, k, this.getValueXY(j, i, k));
+        }
       }
     }
-  }
 
-  return newImage;
+    return newImage;
+  }
 }

package/lib/image/transform/rotateFree.js

@@ -26,12 +26,6 @@ function rotateFree(degrees, options = {}) {
   const radians = degrees * Math.PI / 180;
   const newWidth = Math.floor(Math.abs(width * Math.cos(radians)) + Math.abs(height * Math.sin(radians)));
   const newHeight = Math.floor(Math.abs(height * Math.cos(radians)) + Math.abs(width * Math.sin(radians)));
-
-  const newImage = _Image.default.createFrom(this, {
-    width: newWidth,
-    height: newHeight
-  });
-
   const cos = Math.cos(-radians);
   const sin = Math.sin(-radians);
   let x0 = newWidth / 2;
@@ -58,15 +52,38 @@ function rotateFree(degrees, options = {}) {
   const incrementX = Math.floor(width / 2 - x0);
   const incrementY = Math.floor(height / 2 - y0);
 
-  switch (interpolationToUse) {
-    case _checks.validInterpolations.nearestneighbor:
-      return rotateNearestNeighbor(this, newImage, incrementX, incrementY, x0, y0, cos, sin);
+  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 rotateBilinear(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}`);
+      default:
+        throw new Error(`unsupported rotate interpolation: ${interpolationToUse}`);
+    }
+  } else {
+    const newImage = _Image.default.createFrom(this, {
+      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}`);
+    }
   }
 }
 
@@ -93,6 +110,21 @@ 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;
 
@@ -125,5 +157,34 @@ 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;
+      let y = (j - y0) * cos + (i - x0) * sin + y0 + incrementY;
+      let x1 = x | 0;
+      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 {
+        let index = y1 * thisImage.width + x1;
+        let A = thisImage.getBit(index);
+        let B = thisImage.getBit(index + 1);
+        let C = thisImage.getBit(index + stride);
+        let D = thisImage.getBit(index + 1 + stride);
+        let result = A | xDiff & B - A | yDiff & C - A | xDiff & yDiff & A - B - C + D;
+        if (result > 0) newImage.setBitXY(i, j);
+      }
+    }
+  }
+
   return newImage;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "image-js",
-  "version": "0.33.2",
+  "version": "0.35.0",
   "description": "Image processing and manipulation in JavaScript",
   "keywords": [
     "image",

package/src/browser/worker/worker.js

@@ -26,6 +26,7 @@ class Worker {
     let manager;
     let url;
     let runner = {};
+
     function run(...args) {
       if (!manager) {
         this.checkUrl();
@@ -35,6 +36,7 @@ class Worker {
       }
       return method.run.call(runner, ...args);
     }
+
     run.reset = function () {
       if (manager) {
         manager.terminate();

package/src/image/core/export.js

@@ -125,10 +125,12 @@ const exportMethods = {
     }
     const { useCanvas = false, encoder: encoderOptions = undefined } = options;
     type = getType(type);
+
     function dataUrl(encoder, ctx) {
       const u8 = encoder(ctx, encoderOptions);
       return toBase64URL(u8, type);
     }
+
     if (type === 'image/bmp') {
       return dataUrl(encodeBmp, this);
     } else if (type === 'image/png' && !useCanvas) {

package/src/image/core/load.js

@@ -19,7 +19,10 @@ const isDataURL = /^data:[a-z]+\/(?:[a-z]+);base64,/;
  * @static
  * @param {string|ArrayBuffer|Buffer|Uint8Array} image - URL of the image (browser, can be a dataURL) or path (Node.js)
  * or buffer containing the binary data
- * @param {object} [options] - In the browser, the options object is passed to the underlying `fetch` call.
+ * @param {object} [options] - In the browser, the options object is passed to the underlying `fetch` call, along with
+ * the data URL. For binary data, the option specify decoding options.
+ * @param {boolean} [options.ignorePalette] - When set to true and loading a tiff from binary data, if the tiff is of
+ * type 3 (palette), load as single channel greyscale rather than as a pseudo-colored RGB.
  * @return {Promise<Image>}
  * @example
  * const image = await Image.load('https://example.com/image.png');
@@ -28,15 +31,23 @@ export default function load(image, options) {
   if (typeof image === 'string') {
     return loadURL(image, options);
   } else if (image instanceof ArrayBuffer) {
-    return Promise.resolve(loadBinary(new Uint8Array(image)));
+    return Promise.resolve(
+      loadBinary(
+        new Uint8Array(image),
+        undefined,
+        options && options.ignorePalette,
+      ),
+    );
   } else if (image.buffer) {
-    return Promise.resolve(loadBinary(image));
+    return Promise.resolve(
+      loadBinary(image, undefined, options && options.ignorePalette),
+    );
   } else {
     throw new Error('argument to "load" must be a string or buffer.');
   }
 }
 
-function loadBinary(image, base64Url) {
+function loadBinary(image, base64Url, ignorePalette) {
   const type = imageType(image);
   if (type) {
     switch (type.mime) {
@@ -45,12 +56,13 @@ function loadBinary(image, base64Url) {
       case 'image/jpeg':
         return loadJPEG(image);
       case 'image/tiff':
-        return loadTIFF(image);
+        return loadTIFF(image, ignorePalette);
       default:
         return loadGeneric(getBase64(type.mime));
     }
   }
   return loadGeneric(getBase64('application/octet-stream'));
+
   function getBase64(type) {
     if (base64Url) {
       return base64Url;
@@ -70,7 +82,11 @@ function loadURL(url, options) {
   }
   return binaryDataP.then((binaryData) => {
     const uint8 = new Uint8Array(binaryData);
-    return loadBinary(uint8, dataURL ? url : undefined);
+    return loadBinary(
+      uint8,
+      dataURL ? url : undefined,
+      options && options.ignorePalette,
+    );
   });
 }
 
@@ -159,12 +175,16 @@ function loadJPEG(data) {
   return image;
 }
 
-function loadTIFF(data) {
+function loadTIFF(data, ignorePalette) {
   let result = decodeTiff(data);
   if (result.length === 1) {
-    return getImageFromIFD(result[0]);
+    return getImageFromIFD(result[0], ignorePalette);
   } else {
-    return new Stack(result.map(getImageFromIFD));
+    return new Stack(
+      result.map(function (image) {
+        return getImageFromIFD(image, ignorePalette);
+      }),
+    );
   }
 }
 
@@ -184,8 +204,8 @@ function getMetadata(image) {
   return metadata;
 }
 
-function getImageFromIFD(image) {
-  if (image.type === 3) {
+function getImageFromIFD(image, ignorePalette) {
+  if (!ignorePalette && image.type === 3) {
     // Palette
     const data = new Uint16Array(3 * image.width * image.height);
     const palette = image.palette;

package/src/image/roi/creator/fromMask.js

@@ -151,5 +151,6 @@ export default function fromMask(mask, options = {}) {
       }
     }
   }
+
   return new RoiMap(mask, data);
 }

package/src/image/transform/crop.js

@@ -23,11 +23,9 @@ export default function crop(options = {}) {
     width = this.width - x,
     height = this.height - y,
   } = options;
-
-  this.checkProcessable('max', {
-    bitDepth: [8, 16],
+  this.checkProcessable('crop', {
+    bitDepth: [1, 8, 16],
   });
-
   x = Math.round(x);
   y = Math.round(y);
   width = Math.round(width);
@@ -40,36 +38,79 @@ export default function crop(options = {}) {
       })`,
     );
   }
+
   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 newImage = Image.createFrom(this, { width, height, position: [x, y] });
+  let result = this;
+  if (this.bitDepth === 1) {
+    const newImage = new Image(width, height, {
+      kind: 'BINARY',
+      parent: this,
+    });
+    result = cropBinary(this, newImage, x, y, width, height);
+  } else {
+    const newImage = Image.createFrom(this, {
+      width,
+      height,
+      position: [x, y],
+    });
+    result = cropDefault(this, newImage, x, y, width, height);
+  }
 
-  let xWidth = width * this.channels;
+  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 * this.channels;
+  let jLeft = x * img.channels;
 
   for (let i = y; i < y1; i++) {
-    let j = i * this.width * this.channels + jLeft;
+    let j = i * img.width * img.channels + jLeft;
     let jL = j + xWidth;
+
     for (; j < jL; j++) {
-      newImage.data[ptr++] = this.data[j];
+      if (img.getBit(j)) {
+        newImage.setBit(ptr);
+      }
+      ++ptr;
     }
   }
 

package/src/image/transform/mask/minimum.js

@@ -31,6 +31,7 @@ export default function minimum(histogram) {
   threshold = minimumBetweenPeeks(histogramCopy, max);
   return threshold;
 }
+
 function smoothed(histogram) {
   // Smooth with a 3 point running mean filter
   let auHistogram = new Array(histogram.length); // a copy of the histograma for the smoothing process
@@ -42,6 +43,7 @@ function smoothed(histogram) {
     (histogram[histogram.length - 2] + histogram[histogram.length - 1]) / 3;
   return auHistogram;
 }
+
 function minimumBetweenPeeks(histogramBimodal, max) {
   let threshold;
   for (let i = 1; i < max; i++) {
@@ -55,6 +57,7 @@ function minimumBetweenPeeks(histogramBimodal, max) {
   }
   return threshold;
 }
+
 function bimodalTest(histogram) {
   // It is responsible for determining if a histogram is bimodal
   let len = histogram.length;

package/src/image/transform/rotate.js

@@ -12,6 +12,9 @@ import rotateFree from './rotateFree';
  * @return {Image} The new rotated image
  */
 export function rotate(angle, options) {
+  this.checkProcessable('rotate', {
+    bitDepth: [1, 8, 16],
+  });
   if (typeof angle !== 'number') {
     throw new TypeError('angle must be a number');
   }
@@ -23,39 +26,64 @@ export function rotate(angle, options) {
   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.call(this, angle, options);
   }
 }
-
 /**
  * Rotates an image counter-clockwise
  * @memberof Image
  * @instance
  * @return {Image} The new rotated image
  */
+
 export function rotateLeft() {
-  const newImage = Image.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++) {
-        newImage.setValueXY(i, newMaxHeight - j, k, this.getValueXY(j, i, k));
+  if (this.bitDepth === 1) {
+    const newImage = new Image(this.height, this.width, {
+      kind: 'BINARY',
+      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)) {
+          newImage.setBitXY(i, newMaxHeight - j);
+        }
+      }
+    }
+
+    return newImage;
+  } else {
+    const newImage = Image.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++) {
+          newImage.setValueXY(i, newMaxHeight - j, k, this.getValueXY(j, i, k));
+        }
       }
     }
+
+    return newImage;
   }
-  return newImage;
 }
-
 /**
  * Rotates an image clockwise
  * @memberof Image
@@ -64,36 +92,81 @@ export function rotateLeft() {
  */
 
 export function rotateRight() {
-  const newImage = Image.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++) {
-        newImage.setValueXY(newMaxWidth - i, j, k, this.getValueXY(j, i, k));
+  if (this.bitDepth === 1) {
+    const newImage = new Image(this.height, this.width, {
+      kind: 'BINARY',
+      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)) {
+          newImage.setBitXY(newMaxWidth - i, j);
+        }
       }
     }
+
+    return newImage;
+  } else {
+    const newImage = Image.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++) {
+          newImage.setValueXY(newMaxWidth - i, j, k, this.getValueXY(j, i, k));
+        }
+      }
+    }
+
+    return newImage;
   }
-  return newImage;
 }
 
 function rotate180() {
-  const newImage = Image.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++) {
-        newImage.setValueXY(
-          newMaxWidth - j,
-          newMaxHeight - i,
-          k,
-          this.getValueXY(j, i, k),
-        );
+  if (this.bitDepth === 1) {
+    const newImage = new Image(this.width, this.height, {
+      kind: 'BINARY',
+      parent: 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++) {
+        if (this.getBitXY(j, i)) {
+          newImage.setBitXY(newMaxWidth - j, newMaxHeight - i);
+        }
+      }
+    }
+
+    return newImage;
+  } else {
+    const newImage = Image.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++) {
+          newImage.setValueXY(
+            newMaxWidth - j,
+            newMaxHeight - i,
+            k,
+            this.getValueXY(j, i, k),
+          );
+        }
       }
     }
+
+    return newImage;
   }
-  return newImage;
 }

package/src/image/transform/rotateFree.js

@@ -11,8 +11,8 @@ export default function rotateFree(degrees, options = {}) {
   if (typeof degrees !== 'number') {
     throw new TypeError('degrees must be a number');
   }
-  const interpolationToUse = checkInterpolation(interpolation);
 
+  const interpolationToUse = (0, checkInterpolation)(interpolation);
   const radians = (degrees * Math.PI) / 180;
   const newWidth = Math.floor(
     Math.abs(width * Math.cos(radians)) + Math.abs(height * Math.sin(radians)),
@@ -20,17 +20,15 @@ export default function rotateFree(degrees, options = {}) {
   const newHeight = Math.floor(
     Math.abs(height * Math.cos(radians)) + Math.abs(width * Math.sin(radians)),
   );
-  const newImage = Image.createFrom(this, {
-    width: newWidth,
-    height: newHeight,
-  });
+
   const cos = Math.cos(-radians);
   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 {
@@ -38,6 +36,7 @@ export default function rotateFree(degrees, options = {}) {
     }
   } else {
     x0 = Math.floor(x0);
+
     if (newHeight % 2 === 0) {
       y0 = y0 - 0.5;
     } else {
@@ -48,33 +47,78 @@ export default function rotateFree(degrees, options = {}) {
   const incrementX = Math.floor(width / 2 - x0);
   const incrementY = Math.floor(height / 2 - y0);
 
-  switch (interpolationToUse) {
-    case validInterpolations.nearestneighbor:
-      return rotateNearestNeighbor(
-        this,
-        newImage,
-        incrementX,
-        incrementY,
-        x0,
-        y0,
-        cos,
-        sin,
-      );
-    case validInterpolations.bilinear:
-      return rotateBilinear(
-        this,
-        newImage,
-        incrementX,
-        incrementY,
-        x0,
-        y0,
-        cos,
-        sin,
-      );
-    default:
-      throw new Error(
-        `unsupported rotate interpolation: ${interpolationToUse}`,
-      );
+  if (this.bitDepth === 1) {
+    const newImage = new Image(newWidth, newHeight, {
+      kind: 'BINARY',
+      parent: this,
+    });
+
+    switch (interpolationToUse) {
+      case validInterpolations.nearestneighbor:
+        return rotateBinaryNearestNeighbor(
+          this,
+          newImage,
+          incrementX,
+          incrementY,
+          x0,
+          y0,
+          cos,
+          sin,
+        );
+
+      case validInterpolations.bilinear:
+        return rotateBinaryBilinear(
+          this,
+          newImage,
+          incrementX,
+          incrementY,
+          x0,
+          y0,
+          cos,
+          sin,
+        );
+
+      default:
+        throw new Error(
+          `unsupported rotate interpolation: ${interpolationToUse}`,
+        );
+    }
+  } else {
+    const newImage = Image.createFrom(this, {
+      width: newWidth,
+      height: newHeight,
+    });
+
+    switch (interpolationToUse) {
+      case validInterpolations.nearestneighbor:
+        return rotateNearestNeighbor(
+          this,
+          newImage,
+          incrementX,
+          incrementY,
+          x0,
+          y0,
+          cos,
+          sin,
+        );
+
+      case validInterpolations.bilinear:
+        return rotateBilinear(
+          this,
+          newImage,
+          incrementX,
+          incrementY,
+          x0,
+          y0,
+          cos,
+          sin,
+        );
+
+      default:
+        throw new Error(
+          `unsupported rotate interpolation: ${interpolationToUse}`,
+        );
+    }
   }
 }
 
@@ -106,6 +150,37 @@ function rotateNearestNeighbor(
       }
     }
   }
+
+  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;
 }
 
@@ -120,6 +195,7 @@ function rotateBilinear(
   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;
@@ -128,6 +204,7 @@ function rotateBilinear(
       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) {
@@ -137,23 +214,63 @@ function rotateBilinear(
           }
         } else {
           let index = (y1 * thisImage.width + x1) * thisImage.channels + c;
-
           let A = thisImage.data[index];
           let B = thisImage.data[index + thisImage.channels];
           let C = thisImage.data[index + stride];
           let D = thisImage.data[index + stride + thisImage.channels];
-
           let result =
             (A +
               xDiff * (B - A) +
               yDiff * (C - A) +
               xDiff * yDiff * (A - B - C + D)) |
             0;
-
           newImage.setValueXY(i, j, c, result);
         }
       }
     }
   }
+
+  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;
+      let y = (j - y0) * cos + (i - x0) * sin + y0 + incrementY;
+      let x1 = x | 0;
+      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 {
+        let index = y1 * thisImage.width + x1;
+        let A = thisImage.getBit(index);
+        let B = thisImage.getBit(index + 1);
+        let C = thisImage.getBit(index + stride);
+        let D = thisImage.getBit(index + 1 + stride);
+        let result =
+          A |
+          (xDiff & (B - A)) |
+          (yDiff & (C - A)) |
+          (xDiff & yDiff & (A - B - C + D));
+        if (result > 0) newImage.setBitXY(i, j);
+      }
+    }
+  }
+
   return newImage;
 }