Add a boolean operator that performs bitwise boolean operations between images

docs/api.md

@@ -500,6 +500,21 @@ sharp('input.png')
 ```
 
 In the above example if `input.png` is a 3 channel RGB image, `output.png` will be a 1 channel grayscale image where each pixel `P = R & G & B`. For example, if `I(1,1) = [247, 170, 14] = [0b11110111, 0b10101010, 0b00001111]` then `O(1,1) = 0b11110111 & 0b10101010 & 0b00001111 = 0b00000010 = 2`.
+
+#### boolean(image, operation)
+
+Perform a bitwise boolean operation with `image`.
+
+`image` is one of the following.
+
+* Buffer contianing PNG, WebP, GIF or SVG image data, or
+* String containing the path to an image file
+
+This operation creates an output image where each pixel is the result of the selected bitwise boolean `operation`, between the corresponding pixels of the input images. The boolean operation can be one of the following:
+
+ * `and` performs a bitwise and operation, like the c-operator `&`
+ * `or` performs a bitwise or operation, like the c-operator `|`
+ * `eor` performs a bitwise exclusive or operation, like the c-operator `^`
 
 ### Output
 

index.js

@@ -90,6 +90,9 @@ var Sharp = function(input, options) {
     greyscale: false,
     normalize: 0,
     bandBoolOp: null,
+    booleanOp: null,
+    booleanBufferIn: null,
+    booleanFileIn: '',
     // overlay
     overlayFileIn: '',
     overlayBufferIn: null,
@@ -348,6 +351,30 @@ Sharp.prototype.negate = function(negate) {
   return this;
 };
 
+/*
+  Bitwise boolean operations between images
+*/
+Sharp.prototype.boolean = function(operand, operator) {
+  if (isString(operand)) {
+    this.options.booleanFileIn = operand;
+  } else if (isBuffer(operand)) {
+    this.options.booleanBufferIn = operand;
+  } else {
+    throw new Error('Unsupported boolean operand ' + typeof operand);
+  }
+  if (!isString(operator)) {
+    throw new Error('Invalid boolean operation ' + operator);
+  }
+  operator = operator.toLowerCase();
+  var ops = ['and', 'or', 'eor'];
+  if(ops.indexOf(operator) == -1) {
+    throw new Error('Invalid boolean operation ' + operator);
+  }
+  this.options.booleanOp = operator;
+
+  return this;
+};
+
 /*
   Overlay with another image, using an optional gravity
 */

src/common.cc

@@ -324,4 +324,13 @@ namespace sharp {
     }
   }
 
+  /*
+    Get VIPS Boolean operatoin type from string
+  */
+  VipsOperationBoolean GetBooleanOperation(std::string opStr) {
+    return static_cast<VipsOperationBoolean>(
+      vips_enum_from_nick(nullptr, VIPS_TYPE_OPERATION_BOOLEAN, opStr.data())
+    );
+  }
+
 }  // namespace sharp

src/common.h

@@ -117,6 +117,11 @@ namespace sharp {
 
   int MaximumImageAlpha(VipsInterpretation interpretation);
 
+  /*
+    Get VIPS Boolean operatoin type from string
+  */
+  VipsOperationBoolean GetBooleanOperation(std::string opStr);
+
 
 }  // namespace sharp
 

src/operations.cc

@@ -399,4 +399,11 @@ namespace sharp {
     return image.bandbool(boolean);
   }
 
+  /*
+    Perform bitwise boolean operation between images
+  */
+  VImage Boolean(VImage image, VImage imageR, VipsOperationBoolean const boolean) {
+    return image.boolean(imageR, boolean);
+  }
+
 }  // namespace sharp

src/operations.h

@@ -87,6 +87,11 @@ namespace sharp {
   */
   VImage Bandbool(VImage image, VipsOperationBoolean const boolean);
 
+  /*
+    Perform bitwise boolean operation between images
+  */
+  VImage Boolean(VImage image, VImage imageR, VipsOperationBoolean const boolean);
+
 }  // namespace sharp
 
 #endif  // SRC_OPERATIONS_H_

src/pipeline.cc

@@ -56,6 +56,7 @@ using sharp::EntropyCrop;
 using sharp::TileCache;
 using sharp::Threshold;
 using sharp::Bandbool;
+using sharp::Boolean;
 
 using sharp::ImageType;
 using sharp::ImageTypeId;
@@ -76,19 +77,25 @@ using sharp::FreeCallback;
 using sharp::CalculateCrop;
 using sharp::counterProcess;
 using sharp::counterQueue;
+using sharp::GetBooleanOperation;
+
+typedef struct BufferContainer_t {
+  std::string name;
+  Local<Object> nodeBuf;
+  size_t length;
+} BufferContainer;
 
 class PipelineWorker : public AsyncWorker {
  public:
   PipelineWorker(Callback *callback, PipelineBaton *baton, Callback *queueListener,
-    const Local<Object> &bufferIn, const Local<Object> &overlayBufferIn) :
+                 const std::vector<BufferContainer> saveBuffers) :
     AsyncWorker(callback), baton(baton), queueListener(queueListener) {
-      if (baton->bufferInLength > 0) {
-        SaveToPersistent("bufferIn", bufferIn);
-      }
-      if (baton->overlayBufferInLength > 0) {
-        SaveToPersistent("overlayBufferIn", overlayBufferIn);
+    for (const BufferContainer b : saveBuffers) {
+      if (b.length > 0) {
+        SaveToPersistent(b.name.c_str(), b.nodeBuf);
       }
     }
+  }
   ~PipelineWorker() {}
 
   /*
@@ -777,6 +784,44 @@ class PipelineWorker : public AsyncWorker {
         }
       }
 
+      // Apply bitwise boolean operation between images
+      if (baton->booleanOp != VIPS_OPERATION_BOOLEAN_LAST &&
+          (baton->booleanBufferInLength > 0 || !baton->booleanFileIn.empty())) {
+        VImage booleanImage;
+        ImageType booleanImageType = ImageType::UNKNOWN;
+        if (baton->booleanBufferInLength > 0) {
+          // Buffer input for boolean operation
+          booleanImageType = DetermineImageType(baton->booleanBufferIn, baton->booleanBufferInLength);
+          if (booleanImageType != ImageType::UNKNOWN) {
+            try {
+              booleanImage = VImage::new_from_buffer(baton->booleanBufferIn, baton->booleanBufferInLength,
+                nullptr, VImage::option()->set("access", baton->accessMethod));
+            } catch (...) {
+              (baton->err).append("Boolean operation buffer has corrupt header");
+              booleanImageType = ImageType::UNKNOWN;
+            }
+          } else {
+            (baton->err).append("Boolean operation buffer contains unsupported image format");
+          }
+        } else if (!baton->booleanFileIn.empty()) {
+          // File input for boolean operation
+          booleanImageType = DetermineImageType(baton->booleanFileIn.data());
+          if (booleanImageType != ImageType::UNKNOWN) {
+            try {
+              booleanImage = VImage::new_from_file(baton->booleanFileIn.data(),
+                VImage::option()->set("access", baton->accessMethod));
+            } catch (...) {
+              (baton->err).append("Boolean operation file has corrupt header");
+            }
+          }
+        }
+        if (booleanImageType == ImageType::UNKNOWN) {
+          return Error();
+        }
+        // Apply the boolean operation
+        image = Boolean(image, booleanImage, baton->booleanOp);
+      }
+
       // Apply per-channel Bandbool bitwise operations after all other operations
       if (shouldBandbool) {
         image = Bandbool(image, baton->bandBoolOp);
@@ -989,6 +1034,9 @@ class PipelineWorker : public AsyncWorker {
     if (baton->overlayBufferInLength > 0) {
       GetFromPersistent("overlayBufferIn");
     }
+    if (baton->booleanBufferInLength > 0) {
+      GetFromPersistent("booleanBufferIn");
+    }
     delete baton;
 
     // Decrement processing task counter
@@ -1126,6 +1174,14 @@ NAN_METHOD(pipeline) {
     baton->overlayBufferInLength = node::Buffer::Length(overlayBufferIn);
     baton->overlayBufferIn = node::Buffer::Data(overlayBufferIn);
   }
+  // Boolean options
+  baton->booleanFileIn = attrAsStr(options, "booleanFileIn");
+  Local<Object> booleanBufferIn;
+  if (node::Buffer::HasInstance(Get(options, New("booleanBufferIn").ToLocalChecked()).ToLocalChecked())) {
+    booleanBufferIn = Get(options, New("booleanBufferIn").ToLocalChecked()).ToLocalChecked().As<Object>();
+    baton->booleanBufferInLength = node::Buffer::Length(booleanBufferIn);
+    baton->booleanBufferIn = node::Buffer::Data(booleanBufferIn);
+  }
   baton->overlayGravity = attrAs<int32_t>(options, "overlayGravity");
   baton->overlayXOffset = attrAs<int32_t>(options, "overlayXOffset");
   baton->overlayYOffset = attrAs<int32_t>(options, "overlayYOffset");
@@ -1203,14 +1259,10 @@ NAN_METHOD(pipeline) {
     }
   }
   // Bandbool operation
-  std::string opStr = attrAsStr(options, "bandBoolOp");
-  if(opStr == "and" ) {
-    baton->bandBoolOp = VIPS_OPERATION_BOOLEAN_AND;
-  } else if(opStr == "or") {
-    baton->bandBoolOp = VIPS_OPERATION_BOOLEAN_OR;
-  } else if(opStr == "eor") {
-    baton->bandBoolOp = VIPS_OPERATION_BOOLEAN_EOR;
-  }
+  baton->bandBoolOp = GetBooleanOperation(attrAsStr(options, "bandBoolOp"));
+
+  // Boolean operation
+  baton->booleanOp = GetBooleanOperation(attrAsStr(options, "booleanOp"));
 
   // Function to notify of queue length changes
   Callback *queueListener = new Callback(
@@ -1219,7 +1271,12 @@ NAN_METHOD(pipeline) {
 
   // Join queue for worker thread
   Callback *callback = new Callback(info[1].As<Function>());
-  AsyncQueueWorker(new PipelineWorker(callback, baton, queueListener, bufferIn, overlayBufferIn));
+
+  std::vector<BufferContainer> saveBuffers;
+  saveBuffers.push_back({"bufferIn", bufferIn, baton->bufferInLength});
+  saveBuffers.push_back({"overlayBufferIn", overlayBufferIn, baton->overlayBufferInLength});
+  saveBuffers.push_back({"booleanBufferIn", booleanBufferIn, baton->booleanBufferInLength});
+  AsyncQueueWorker(new PipelineWorker(callback, baton, queueListener, saveBuffers));
 
   // Increment queued task counter
   g_atomic_int_inc(&counterQueue);

src/pipeline.h

@@ -39,6 +39,9 @@ struct PipelineBaton {
   int overlayYOffset;
   bool overlayTile;
   bool overlayCutout;
+  std::string booleanFileIn;
+  char *booleanBufferIn;
+  size_t booleanBufferInLength;
   int topOffsetPre;
   int leftOffsetPre;
   int widthPre;
@@ -93,6 +96,7 @@ struct PipelineBaton {
   double convKernelScale;
   double convKernelOffset;
   VipsOperationBoolean bandBoolOp;
+  VipsOperationBoolean booleanOp;
   int tileSize;
   int tileOverlap;
   VipsForeignDzContainer tileContainer;
@@ -114,6 +118,7 @@ struct PipelineBaton {
     overlayYOffset(-1),
     overlayTile(false),
     overlayCutout(false),
+    booleanBufferInLength(0),
     topOffsetPre(-1),
     topOffsetPost(-1),
     channels(0),
@@ -153,6 +158,7 @@ struct PipelineBaton {
     convKernelScale(0.0),
     convKernelOffset(0.0),
     bandBoolOp(VIPS_OPERATION_BOOLEAN_LAST),
+    booleanOp(VIPS_OPERATION_BOOLEAN_LAST),
     tileSize(256),
     tileOverlap(0),
     tileContainer(VIPS_FOREIGN_DZ_CONTAINER_FS),

test/fixtures/index.js

@@ -95,6 +95,8 @@ module.exports = {
   inputPngStripesV: getPath('stripesV.png'),
   inputPngStripesH: getPath('stripesH.png'),
 
+  inputJpgBooleanTest: getPath('booleanTest.jpg'),
+
   outputJpg: getPath('output.jpg'),
   outputPng: getPath('output.png'),
   outputWebP: getPath('output.webp'),