sharp 0.20.5 → 0.21.0

package/src/common.cc

@@ -37,6 +37,14 @@ namespace sharp {
   std::string AttrAsStr(v8::Handle<v8::Object> obj, std::string attr) {
     return *Nan::Utf8String(Nan::Get(obj, Nan::New(attr).ToLocalChecked()).ToLocalChecked());
   }
+  std::vector<double> AttrAsRgba(v8::Handle<v8::Object> obj, std::string attr) {
+    v8::Local<v8::Object> background = AttrAs<v8::Object>(obj, attr);
+    std::vector<double> rgba(4);
+    for (unsigned int i = 0; i < 4; i++) {
+      rgba[i] = AttrTo<double>(background, i);
+    }
+    return rgba;
+  }
 
   // Create an InputDescriptor instance from a v8::Object describing an input image
   InputDescriptor* CreateInputDescriptor(
@@ -55,7 +63,7 @@ namespace sharp {
     descriptor->failOnError = AttrTo<bool>(input, "failOnError");
     // Density for vector-based input
     if (HasAttr(input, "density")) {
-      descriptor->density = AttrTo<uint32_t>(input, "density");
+      descriptor->density = AttrTo<double>(input, "density");
     }
     // Raw pixel input
     if (HasAttr(input, "rawChannels")) {
@@ -72,10 +80,7 @@ namespace sharp {
       descriptor->createChannels = AttrTo<uint32_t>(input, "createChannels");
       descriptor->createWidth = AttrTo<uint32_t>(input, "createWidth");
       descriptor->createHeight = AttrTo<uint32_t>(input, "createHeight");
-      v8::Local<v8::Object> createBackground = AttrAs<v8::Object>(input, "createBackground");
-      for (unsigned int i = 0; i < 4; i++) {
-        descriptor->createBackground[i] = AttrTo<double>(createBackground, i);
-      }
+      descriptor->createBackground = AttrAsRgba(input, "createBackground");
     }
     return descriptor;
   }
@@ -228,7 +233,7 @@ namespace sharp {
               ->set("access", accessMethod)
               ->set("fail", descriptor->failOnError);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
-              option->set("dpi", static_cast<double>(descriptor->density));
+              option->set("dpi", descriptor->density);
             }
             if (imageType == ImageType::MAGICK) {
               option->set("density", std::to_string(descriptor->density).data());
@@ -270,7 +275,7 @@ namespace sharp {
               ->set("access", accessMethod)
               ->set("fail", descriptor->failOnError);
             if (imageType == ImageType::SVG || imageType == ImageType::PDF) {
-              option->set("dpi", static_cast<double>(descriptor->density));
+              option->set("dpi", descriptor->density);
             }
             if (imageType == ImageType::MAGICK) {
               option->set("density", std::to_string(descriptor->density).data());
@@ -355,8 +360,8 @@ namespace sharp {
   /*
     Set pixels/mm resolution based on a pixels/inch density.
   */
-  void SetDensity(VImage image, const int density) {
-    const double pixelsPerMm = static_cast<double>(density) / 25.4;
+  void SetDensity(VImage image, const double density) {
+    const double pixelsPerMm = density / 25.4;
     image.set("Xres", pixelsPerMm);
     image.set("Yres", pixelsPerMm);
     image.set(VIPS_META_RESOLUTION_UNIT, "in");
@@ -370,10 +375,6 @@ namespace sharp {
       if (image.width() > 65535 || image.height() > 65535) {
         throw vips::VError("Processed image is too large for the JPEG format");
       }
-    } else if (imageType == ImageType::PNG) {
-      if (image.width() > 2147483647 || image.height() > 2147483647) {
-        throw vips::VError("Processed image is too large for the PNG format");
-      }
     } else if (imageType == ImageType::WEBP) {
       if (image.width() > 16383 || image.height() > 16383) {
         throw vips::VError("Processed image is too large for the WebP format");
@@ -606,4 +607,40 @@ namespace sharp {
     }
   }
 
+  /*
+    Apply the alpha channel to a given colour
+  */
+  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour) {
+    // Scale up 8-bit values to match 16-bit input image
+    double const multiplier = sharp::Is16Bit(image.interpretation()) ? 256.0 : 1.0;
+    // Create alphaColour colour
+    std::vector<double> alphaColour;
+    if (image.bands() > 2) {
+      alphaColour = {
+        multiplier * colour[0],
+        multiplier * colour[1],
+        multiplier * colour[2]
+      };
+    } else {
+      // Convert sRGB to greyscale
+      alphaColour = { multiplier * (
+        0.2126 * colour[0] +
+        0.7152 * colour[1] +
+        0.0722 * colour[2])
+      };
+    }
+    // Add alpha channel to alphaColour colour
+    if (colour[3] < 255.0 || HasAlpha(image)) {
+      alphaColour.push_back(colour[3] * multiplier);
+    }
+    // Ensure alphaColour colour uses correct colourspace
+    alphaColour = sharp::GetRgbaAsColourspace(alphaColour, image.interpretation());
+    // Add non-transparent alpha channel, if required
+    if (colour[3] < 255.0 && !HasAlpha(image)) {
+      image = image.bandjoin(
+        VImage::new_matrix(image.width(), image.height()).new_from_image(255 * multiplier));
+    }
+    return std::make_tuple(image, alphaColour);
+  }
+
 }  // namespace sharp

package/src/common.h

@@ -49,7 +49,7 @@ namespace sharp {
     char *buffer;
     bool failOnError;
     size_t bufferLength;
-    int density;
+    double density;
     int rawChannels;
     int rawWidth;
     int rawHeight;
@@ -57,30 +57,27 @@ namespace sharp {
     int createChannels;
     int createWidth;
     int createHeight;
-    double createBackground[4];
+    std::vector<double> createBackground;
 
     InputDescriptor():
       buffer(nullptr),
       failOnError(FALSE),
       bufferLength(0),
-      density(72),
+      density(72.0),
       rawChannels(0),
       rawWidth(0),
       rawHeight(0),
       page(0),
       createChannels(0),
       createWidth(0),
-      createHeight(0) {
-        createBackground[0] = 0.0;
-        createBackground[1] = 0.0;
-        createBackground[2] = 0.0;
-        createBackground[3] = 255.0;
-      }
+      createHeight(0),
+      createBackground{ 0.0, 0.0, 0.0, 255.0 } {}
   };
 
   // Convenience methods to access the attributes of a v8::Object
   bool HasAttr(v8::Handle<v8::Object> obj, std::string attr);
   std::string AttrAsStr(v8::Handle<v8::Object> obj, std::string attr);
+  std::vector<double> AttrAsRgba(v8::Handle<v8::Object> obj, std::string attr);
   template<typename T> v8::Local<T> AttrAs(v8::Handle<v8::Object> obj, std::string attr) {
     return Nan::Get(obj, Nan::New(attr).ToLocalChecked()).ToLocalChecked().As<T>();
   }
@@ -186,7 +183,7 @@ namespace sharp {
   /*
     Set pixels/mm resolution based on a pixels/inch density.
   */
-  void SetDensity(VImage image, const int density);
+  void SetDensity(VImage image, const double density);
 
   /*
     Check the proposed format supports the current dimensions.
@@ -255,6 +252,11 @@ namespace sharp {
   */
   std::vector<double> GetRgbaAsColourspace(std::vector<double> const rgba, VipsInterpretation const interpretation);
 
+  /*
+    Apply the alpha channel to a given colour
+   */
+  std::tuple<VImage, std::vector<double>> ApplyAlpha(VImage image, std::vector<double> colour);
+
 }  // namespace sharp
 
 #endif  // SRC_COMMON_H_