Erode / dilate preliminary implementation.

docs/api-operation.md

@@ -108,6 +108,32 @@ When a `sigma` is provided, performs a slower, more accurate Gaussian blur.
 -   `sigma` **[Number][1]?** a value between 0.3 and 1000 representing the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
 
 
+-   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp** 
+
+## dilate
+
+Dilate the image.
+
+### Parameters
+
+-   `width` **[Number][1]?** dilate width.
+
+
+-   Throws **[Error][5]** Invalid parameters
+
+Returns **Sharp** 
+
+## erode
+
+Erode the image.
+
+### Parameters
+
+-   `width` **[Number][1]?** erode width.
+
+
 -   Throws **[Error][5]** Invalid parameters
 
 Returns **Sharp** 

lib/constructor.js

@@ -153,6 +153,8 @@ const Sharp = function (input, options) {
     threshold: 0,
     thresholdGrayscale: true,
     trimThreshold: 0,
+    dilateWidth: 0,
+    erodeWidth: 0,
     gamma: 0,
     gammaOut: 0,
     greyscale: false,

lib/operation.js

@@ -170,6 +170,44 @@ function blur (sigma) {
   return this;
 }
 
+/**
+ * Dilate the image.
+ * @param {Number} [width] dilate width.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function dilate (width) {
+  if (!is.defined(width)) {
+    // No arguments: default to 1px dilation (3x3 mask)
+    this.options.dilateWidth = 1;
+  } else if (is.integer(width) && width > 0) {
+    // Numeric argument: specific width
+    this.options.dilateWidth = width;
+  } else {
+    throw new Error('Invalid dilation width (positive integer) ' + width);
+  }
+  return this;
+}
+
+/**
+ * Erode the image.
+ * @param {Number} [width] erode width.
+ * @returns {Sharp}
+ * @throws {Error} Invalid parameters
+ */
+function erode (width) {
+  if (!is.defined(width)) {
+    // No arguments: default to 1px erosion (3x3 mask)
+    this.options.erodeWidth = 1;
+  } else if (is.integer(width) && width > 0) {
+    // Numeric argument: specific width
+    this.options.erodeWidth = width;
+  } else {
+    throw new Error('Invalid erosion width  (positive integer) ' + width);
+  }
+  return this;
+}
+
 /**
  * Merge alpha transparency channel, if any, with a background.
  * @param {Object} [options]
@@ -479,6 +517,8 @@ module.exports = function (Sharp) {
     flip,
     flop,
     sharpen,
+    erode,
+    dilate,
     median,
     blur,
     flatten,

package.json

@@ -60,6 +60,7 @@
     "Julian Aubourg <j@ubourg.net>",
     "Keith Belovay <keith@picthrive.com>",
     "Michael B. Klein <mbklein@gmail.com>",
+    "Wilbert van de Ridder <wilbert.ridder@gmail.com>",
     "Jordan Prudhomme <jordan@raboland.fr>",
     "Ilya Ovdin <iovdin@gmail.com>",
     "Andargor <andargor@yahoo.com>"

src/operations.cc

@@ -280,4 +280,28 @@ namespace sharp {
       return image.linear(a, b);
     }
   }
+
+  /*
+   * Dilate an image
+   */
+  VImage Dilate(VImage image, int const width) {
+    int maskWidth = 2*width + 1;
+    VImage mask = VImage::new_matrix(maskWidth, maskWidth);
+
+    return image.morph(
+      mask,
+      VIPS_OPERATION_MORPHOLOGY_DILATE).invert();
+  }
+
+  /*
+   * Dilate an image
+   */
+  VImage Erode(VImage image, int const width) {
+    int maskWidth = 2*width + 1;
+    VImage mask = VImage::new_matrix(maskWidth, maskWidth);
+
+    return image.morph(
+      mask,
+      VIPS_OPERATION_MORPHOLOGY_ERODE).invert();
+  }
 }  // namespace sharp

src/operations.h

@@ -102,6 +102,16 @@ namespace sharp {
    */
   VImage Modulate(VImage image, double const brightness, double const saturation, int const hue);
 
+  /*
+   * Dilate an image
+   */
+  VImage Dilate(VImage image, int const maskWidth);
+
+  /*
+   * Erode an image
+   */
+  VImage Erode(VImage image, int const maskWidth);
+
 }  // namespace sharp
 
 #endif  // SRC_OPERATIONS_H_

src/pipeline.cc

@@ -521,6 +521,16 @@ class PipelineWorker : public Nan::AsyncWorker {
         image = sharp::Threshold(image, baton->threshold, baton->thresholdGrayscale);
       }
 
+      // Dilate - must happen before blurring, due to the utility of dilating after thresholding
+      if (baton->dilateWidth != 0) {
+        image = sharp::Dilate(image, baton->dilateWidth);
+      }
+
+      // Erode - must happen before blurring, due to the utility of eroding after thresholding
+      if (baton->erodeWidth != 0) {
+        image = sharp::Erode(image, baton->erodeWidth);
+      }
+
       // Blur
       if (shouldBlur) {
         image = sharp::Blur(image, baton->blurSigma);
@@ -1271,6 +1281,8 @@ NAN_METHOD(pipeline) {
   baton->gammaOut = AttrTo<double>(options, "gammaOut");
   baton->linearA = AttrTo<double>(options, "linearA");
   baton->linearB = AttrTo<double>(options, "linearB");
+  baton->dilateWidth = AttrTo<int32_t>(options, "dilateWidth");
+  baton->erodeWidth = AttrTo<int32_t>(options, "erodeWidth");
   baton->greyscale = AttrTo<bool>(options, "greyscale");
   baton->normalise = AttrTo<bool>(options, "normalise");
   baton->useExifOrientation = AttrTo<bool>(options, "useExifOrientation");

src/pipeline.h

@@ -102,6 +102,8 @@ struct PipelineBaton {
   int trimOffsetTop;
   double linearA;
   double linearB;
+  int dilateWidth;
+  int erodeWidth;
   double gamma;
   double gammaOut;
   bool greyscale;
@@ -213,6 +215,8 @@ struct PipelineBaton {
     trimOffsetTop(0),
     linearA(1.0),
     linearB(0.0),
+    dilateWidth(0),
+    erodeWidth(0),
     gamma(0.0),
     greyscale(false),
     normalise(false),

test/fixtures/index.js

@@ -103,6 +103,8 @@ module.exports = {
 
   inputJPGBig: getPath('flowers.jpeg'),
 
+  inputPngDotAndLines: getPath('dot-and-lines.png'),
+
   inputPngStripesV: getPath('stripesV.png'),
   inputPngStripesH: getPath('stripesH.png'),
 

test/unit/dilate.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const assert = require('assert');
+
+const sharp = require('../../');
+const fixtures = require('../fixtures');
+
+describe('Dilate', function () {
+  it('dilate 1 png', function (done) {
+    sharp(fixtures.inputPngDotAndLines)
+      .dilate(1)
+      .toBuffer(function (err, data, info) {
+        if (err) throw err;
+        assert.strictEqual('png', info.format);
+        assert.strictEqual(100, info.width);
+        assert.strictEqual(100, info.height);
+        fixtures.assertSimilar(fixtures.expected('dilate-1.png'), data, done);
+      });
+  });
+
+  it('dilate 1 png - default width', function (done) {
+    sharp(fixtures.inputPngDotAndLines)
+      .dilate()
+      .toBuffer(function (err, data, info) {
+        if (err) throw err;
+        assert.strictEqual('png', info.format);
+        assert.strictEqual(100, info.width);
+        assert.strictEqual(100, info.height);
+        fixtures.assertSimilar(fixtures.expected('dilate-1.png'), data, done);
+      });
+  });
+
+  it('invalid dilation width', function () {
+    assert.throws(function () {
+      sharp(fixtures.inputJpg).dilate(-1);
+    });
+  });
+});

test/unit/erode.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const assert = require('assert');
+
+const sharp = require('../../');
+const fixtures = require('../fixtures');
+
+describe('Erode', function () {
+  it('erode 1 png', function (done) {
+    sharp(fixtures.inputPngDotAndLines)
+      .erode(1)
+      .toBuffer(function (err, data, info) {
+        if (err) throw err;
+        assert.strictEqual('png', info.format);
+        assert.strictEqual(100, info.width);
+        assert.strictEqual(100, info.height);
+        fixtures.assertSimilar(fixtures.expected('erode-1.png'), data, done);
+      });
+  });
+
+  it('erode 1 png - default width', function (done) {
+    sharp(fixtures.inputPngDotAndLines)
+      .erode()
+      .toBuffer(function (err, data, info) {
+        if (err) throw err;
+        assert.strictEqual('png', info.format);
+        assert.strictEqual(100, info.width);
+        assert.strictEqual(100, info.height);
+        fixtures.assertSimilar(fixtures.expected('erode-1.png'), data, done);
+      });
+  });
+
+  it('invalid erosion width', function () {
+    assert.throws(function () {
+      sharp(fixtures.inputJpg).erode(-1);
+    });
+  });
+});