image-js 0.34.1 → 0.35.0

package/index.d.ts

@@ -135,7 +135,7 @@ export declare class Image {
   // split
   // getChannel
   // combineChannels
-  // setChannel
+  setChannel(channel: any, image: Image): this;
   // getSimilarity
   // getPixelsGrid
   // getBestMatch

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.34.1",
+  "version": "0.35.0",
   "description": "Image processing and manipulation in JavaScript",
   "keywords": [
     "image",

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