Added resolution unit option in tiff method

lib/constructor.js

@@ -256,6 +256,7 @@ const Sharp = function (input, options) {
     tiffTileWidth: 256,
     tiffXres: 1.0,
     tiffYres: 1.0,
+    tiffResolutionUnit: 'inch',
     heifQuality: 50,
     heifLossless: false,
     heifCompression: 'av1',

lib/output.js

@@ -661,6 +661,7 @@ function trySetAnimationOptions (source, target) {
  * @param {number} [options.xres=1.0] - horizontal resolution in pixels/mm
  * @param {number} [options.yres=1.0] - vertical resolution in pixels/mm
  * @param {number} [options.bitdepth=8] - reduce bitdepth to 1, 2 or 4 bit
+ * @param {string} [options.resolutionUnit='inch'] - resolutionUnit options: inch, cm
  * @returns {Sharp}
  * @throws {Error} Invalid options
  */
@@ -733,6 +734,14 @@ function tiff (options) {
         throw is.invalidParameterError('predictor', 'one of: none, horizontal, float', options.predictor);
       }
     }
+    // resolutionUnit
+    if (is.defined(options.resolutionUnit)) {
+      if (is.string(options.resolutionUnit) && is.inArray(options.resolutionUnit, ['inch', 'cm'])) {
+        this.options.tiffResolutionUnit = options.resolutionUnit;
+      } else {
+        throw is.invalidParameterError('resolutionUnit', 'one of: inch, cm', options.resolutionUnit);
+      }
+    }
   }
   return this._updateFormatOut('tiff', options);
 }

package.json

@@ -79,7 +79,8 @@
     "Michael Nutt <[email protected]>",
     "Brad Parham <[email protected]>",
     "Taneli Vatanen <[email protected]>",
-    "Joris Dugué <[email protected]>"
+    "Joris Dugué <[email protected]>",
+    "Ompal Singh <[email protected]>"
   ],
   "scripts": {
     "install": "(node install/libvips && node install/dll-copy && prebuild-install) || (node install/can-compile && node-gyp rebuild && node install/dll-copy)",

src/pipeline.cc

@@ -888,7 +888,8 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("tile_height", baton->tiffTileHeight)
             ->set("tile_width", baton->tiffTileWidth)
             ->set("xres", baton->tiffXres)
-            ->set("yres", baton->tiffYres)));
+            ->set("yres", baton->tiffYres)
+            ->set("resunit", baton->tiffResolutionUnit)));
           baton->bufferOut = static_cast<char*>(area->data);
           baton->bufferOutLength = area->length;
           area->free_fn = nullptr;
@@ -1046,7 +1047,8 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("tile_height", baton->tiffTileHeight)
             ->set("tile_width", baton->tiffTileWidth)
             ->set("xres", baton->tiffXres)
-            ->set("yres", baton->tiffYres));
+            ->set("yres", baton->tiffYres)
+            ->set("resunit", baton->tiffResolutionUnit));
           baton->formatOut = "tiff";
         } else if (baton->formatOut == "heif" || (mightMatchInput && isHeif) ||
           (willMatchInput && inputImageType == sharp::ImageType::HEIF)) {
@@ -1506,6 +1508,11 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->tiffPredictor = static_cast<VipsForeignTiffPredictor>(
   vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_TIFF_PREDICTOR,
     sharp::AttrAsStr(options, "tiffPredictor").data()));
+  // tiff resolution unit options
+  baton->tiffResolutionUnit = static_cast<VipsForeignTiffResunit>(
+  vips_enum_from_nick(nullptr, VIPS_TYPE_FOREIGN_TIFF_RESUNIT,
+  sharp::AttrAsStr(options, "tiffResolutionUnit").data()));
+
   baton->heifQuality = sharp::AttrAsUint32(options, "heifQuality");
   baton->heifLossless = sharp::AttrAsBool(options, "heifLossless");
   baton->heifCompression = static_cast<VipsForeignHeifCompression>(
@@ -1514,6 +1521,7 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->heifSpeed = sharp::AttrAsUint32(options, "heifSpeed");
   baton->heifChromaSubsampling = sharp::AttrAsStr(options, "heifChromaSubsampling");
 
+
   // Raw output
   baton->rawDepth = static_cast<VipsBandFormat>(
     vips_enum_from_nick(nullptr, VIPS_TYPE_BAND_FORMAT,

src/pipeline.h

@@ -210,6 +210,7 @@ struct PipelineBaton {
   VipsForeignDzDepth tileDepth;
   std::string tileId;
   std::unique_ptr<double[]> recombMatrix;
+  VipsForeignTiffResunit tiffResolutionUnit;
 
   PipelineBaton():
     input(nullptr),
@@ -307,6 +308,7 @@ struct PipelineBaton {
     tiffTileWidth(256),
     tiffXres(1.0),
     tiffYres(1.0),
+    tiffResolutionUnit(VIPS_FOREIGN_TIFF_RESUNIT_INCH),
     heifQuality(50),
     heifCompression(VIPS_FOREIGN_HEIF_COMPRESSION_AV1),
     heifSpeed(5),

test/unit/tiff.js

@@ -288,6 +288,37 @@ describe('TIFF', function () {
       });
   });
 
+  it('TTIFF ccittfax4 compression with inch resolutionUnit test file', function (done) {
+    const startSize = fs.statSync(fixtures.inputTiff).size;
+    sharp(fixtures.inputTiff)
+      .toColourspace('b-w')
+      .tiff({
+        bitdepth: 1,
+        compression: 'ccittfax4',
+        resolutionUnit: 'inch'
+      })
+      .toFile(outputTiff, (err, info) => {
+        if (err) throw err;
+        console.log('info', info);
+        assert.strictEqual('tiff', info.format);
+        assert(info.size < startSize);
+        rimraf(outputTiff, done);
+      });
+  });
+
+  it('TTIFF deflate compression without resolutionUnit test file', function (done) {
+    const startSize = fs.statSync(fixtures.inputTiffUncompressed).size;
+    sharp(fixtures.inputTiffUncompressed)
+      .tiff({
+        compression: 'deflate'
+      }).toFile(outputTiff, (err, info) => {
+        if (err) throw err;
+        assert.strictEqual('tiff', info.format);
+        assert(info.size < startSize);
+        rimraf(outputTiff, done);
+      });
+  });
+
   it('TIFF deflate compression with horizontal predictor shrinks test file', function (done) {
     const startSize = fs.statSync(fixtures.inputTiffUncompressed).size;
     sharp(fixtures.inputTiffUncompressed)
@@ -383,6 +414,12 @@ describe('TIFF', function () {
     });
   });
 
+  it('TIFF invalid resolutionUnit option throws', function () {
+    assert.throws(function () {
+      sharp().tiff({ resolutionUnit: 'none' });
+    });
+  });
+
   it('TIFF horizontal predictor does not throw error', function () {
     assert.doesNotThrow(function () {
       sharp().tiff({ predictor: 'horizontal' });