Implement brightness, saturation and hue modulation lovell#609

lib/constructor.js

@@ -139,6 +139,9 @@ const Sharp = function (input, options) {
     gammaOut: 0,
     greyscale: false,
     normalise: 0,
+    brightness: 1,
+    saturation: 1,
+    hue: 0,
     booleanBufferIn: null,
     booleanFileIn: '',
     joinChannelIn: [],

lib/operation.js

@@ -415,6 +415,19 @@ function recomb (inputMatrix) {
   return this;
 }
 
+function modulate (input) {
+  if (is.number(input.brightness) && input.brightness >= 0) {
+    this.options.brightness = input.brightness;
+  }
+  if (is.number(input.saturation) && input.saturation >= 0) {
+    this.options.saturation = input.saturation;
+  }
+  if (is.number(input.hue)) {
+    this.options.hue = input.hue % 360;
+  }
+  return this;
+}
+
 /**
  * Decorate the Sharp prototype with operation-related functions.
  * @private
@@ -436,6 +449,7 @@ module.exports = function (Sharp) {
     threshold,
     boolean,
     linear,
-    recomb
+    recomb,
+    modulate
   });
 };

src/operations.cc

@@ -185,6 +185,12 @@ namespace sharp {
           0.0, 0.0, 0.0, 1.0));
   }
 
+  VImage Modulate(VImage image, double const brightness, double const saturation, double const hue) {
+    return image
+      .colourspace(VIPS_INTERPRETATION_LCH)
+      .linear({brightness, saturation, 1}, {0, 0, hue});
+  }
+
   /*
    * Sharpen flat and jagged areas. Use sigma of -1.0 for fast sharpen.
    */

src/operations.h

@@ -97,6 +97,11 @@ namespace sharp {
    */
   VImage Recomb(VImage image, std::unique_ptr<double[]> const &matrix);
 
+  /*
+   * Modulate brightness, saturation and hue
+   */
+  VImage Modulate(VImage image, double const brightness, double const saturation, double const hue);
+
 }  // namespace sharp
 
 #endif  // SRC_OPERATIONS_H_

src/pipeline.cc

@@ -349,6 +349,7 @@ class PipelineWorker : public Nan::AsyncWorker {
       bool const shouldSharpen = baton->sharpenSigma != 0.0;
       bool const shouldApplyMedian = baton->medianSize > 0;
       bool const shouldComposite = !baton->composite.empty();
+      bool const shouldModulate = baton->brightness != 1.0 || baton->saturation != 1.0 || baton->hue != 0.0;
 
       if (shouldComposite && !HasAlpha(image)) {
         image = sharp::EnsureAlpha(image);
@@ -528,6 +529,10 @@ class PipelineWorker : public Nan::AsyncWorker {
         image = sharp::Recomb(image, baton->recombMatrix);
       }
 
+      if (shouldModulate) {
+        image = sharp::Modulate(image, baton->brightness, baton->saturation, baton->hue);
+      }
+
       // Sharpen
       if (shouldSharpen) {
         image = sharp::Sharpen(image, baton->sharpenSigma, baton->sharpenFlat, baton->sharpenJagged);
@@ -1210,6 +1215,9 @@ NAN_METHOD(pipeline) {
   baton->flattenBackground = AttrAsRgba(options, "flattenBackground");
   baton->negate = AttrTo<bool>(options, "negate");
   baton->blurSigma = AttrTo<double>(options, "blurSigma");
+  baton->brightness = AttrTo<double>(options, "brightness");
+  baton->saturation = AttrTo<double>(options, "saturation");
+  baton->hue = AttrTo<double>(options, "hue");
   baton->medianSize = AttrTo<uint32_t>(options, "medianSize");
   baton->sharpenSigma = AttrTo<double>(options, "sharpenSigma");
   baton->sharpenFlat = AttrTo<double>(options, "sharpenFlat");

src/pipeline.h

@@ -87,6 +87,9 @@ struct PipelineBaton {
   std::vector<double> flattenBackground;
   bool negate;
   double blurSigma;
+  double brightness;
+  double saturation;
+  double hue;
   int medianSize;
   double sharpenSigma;
   double sharpenFlat;
@@ -189,6 +192,9 @@ struct PipelineBaton {
     flattenBackground{ 0.0, 0.0, 0.0 },
     negate(false),
     blurSigma(0.0),
+    brightness(1.0),
+    saturation(1.0),
+    hue(0.0),
     medianSize(0),
     sharpenSigma(0.0),
     sharpenFlat(1.0),

test/unit/modulate.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const sharp = require('../../');
+const fixtures = require('../fixtures');
+
+describe.only('Modulate', function () {
+  it('should be able to hue-rotate', function (done) {
+    sharp(fixtures.inputJpg)
+      .modulate({ hue: 120 })
+      .toBuffer(function (err, data, info) {
+        if (err) throw err;
+        fixtures.assertSimilar(fixtures.expected('modulate-hue-120.jpg'), data, { threshold: 1 }, done);
+      });
+  });
+
+  it('should be able to brighten', function (done) {
+    sharp(fixtures.inputJpg)
+      .modulate({ brightness: 2 })
+      .toBuffer(function (err, data, info) {
+        if (err) throw err;
+        fixtures.assertSimilar(fixtures.expected('modulate-brightness-2.jpg'), data, { threshold: 1 }, done);
+      });
+  });
+
+  it('should be able to unbrighten', function (done) {
+    sharp(fixtures.inputJpg)
+      .modulate({ brightness: 0.5 })
+      .toBuffer(function (err, data, info) {
+        if (err) throw err;
+        fixtures.assertSimilar(fixtures.expected('modulate-brightness-0-5.jpg'), data, { threshold: 1 }, done);
+      });
+  });
+
+  it('should be able to saturate', function (done) {
+    sharp(fixtures.inputJpg)
+      .modulate({ saturation: 2 })
+      .toBuffer(function (err, data, info) {
+        if (err) throw err;
+        fixtures.assertSimilar(fixtures.expected('modulate-saturation-2.jpg'), data, { threshold: 1 }, done);
+      });
+  });
+
+  it('should be able to desaturate', function (done) {
+    sharp(fixtures.inputJpg)
+      .modulate({ saturation: 0.5 })
+      .toBuffer(function (err, data, info) {
+        if (err) throw err;
+        fixtures.assertSimilar(fixtures.expected('modulate-saturation-0-5.jpg'), data, { threshold: 1 }, done);
+      });
+  });
+
+  it('should be able to modulate all channels', function (done) {
+    sharp(fixtures.inputJpg)
+      .modulate({ brightness: 2, saturation: 0.5, hue: 180 })
+      .toBuffer(function (err, data, info) {
+        if (err) throw err;
+        fixtures.assertSimilar(fixtures.expected('modulate-all.jpg'), data, { threshold: 1 }, done);
+      });
+  });
+});