@revizly/sharp 0.33.4-revizly5 → 0.33.4-revizly7

package/lib/index.d.ts

@@ -571,11 +571,11 @@ declare namespace sharp {
 
         /**
          * Recomb the image with the specified matrix.
-         * @param inputMatrix 3x3 Recombination matrix
+         * @param inputMatrix 3x3 Recombination matrix or 4x4 Recombination matrix
          * @throws {Error} Invalid parameters
          * @returns A sharp instance that can be used to chain operations
          */
-        recomb(inputMatrix: Matrix3x3): Sharp;
+        recomb(inputMatrix: Matrix3x3 | Matrix4x4): Sharp;
 
         /**
          * Transforms the image using brightness, saturation, hue rotation and lightness.
@@ -1730,6 +1730,7 @@ declare namespace sharp {
 
     type Matrix2x2 = [[number, number], [number, number]];
     type Matrix3x3 = [[number, number, number], [number, number, number], [number, number, number]];
+    type Matrix4x4 = [[number, number, number, number], [number, number, number, number], [number, number, number, number], [number, number, number, number]];
 }
 
 export = sharp;

package/lib/operation.js

@@ -787,24 +787,22 @@ function linear (a, b) {
  *     // With this example input, a sepia filter has been applied
  *   });
  *
- * @param {Array<Array<number>>} inputMatrix - 3x3 Recombination matrix
+ * @param {Array<Array<number>>} inputMatrix - 3x3 or 4x4 Recombination matrix
  * @returns {Sharp}
  * @throws {Error} Invalid parameters
  */
 function recomb (inputMatrix) {
-  if (!Array.isArray(inputMatrix) || inputMatrix.length !== 3 ||
-      inputMatrix[0].length !== 3 ||
-      inputMatrix[1].length !== 3 ||
-      inputMatrix[2].length !== 3
-  ) {
-    // must pass in a kernel
-    throw new Error('Invalid recombination matrix');
+  if (!Array.isArray(inputMatrix)) {
+    throw is.invalidParameterError('inputMatrix', 'array', inputMatrix);
+  }
+  if (inputMatrix.length !== 3 && inputMatrix.length !== 4) {
+    throw is.invalidParameterError('inputMatrix', '3x3 or 4x4 array', inputMatrix.length);
+  }
+  const recombMatrix = inputMatrix.flat().map(Number);
+  if (recombMatrix.length !== 9 && recombMatrix.length !== 16) {
+    throw is.invalidParameterError('inputMatrix', 'cardinality of 9 or 16', recombMatrix.length);
   }
-  this.options.recombMatrix = [
-    inputMatrix[0][0], inputMatrix[0][1], inputMatrix[0][2],
-    inputMatrix[1][0], inputMatrix[1][1], inputMatrix[1][2],
-    inputMatrix[2][0], inputMatrix[2][1], inputMatrix[2][2]
-  ].map(Number);
+  this.options.recombMatrix = recombMatrix;
   return this;
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@revizly/sharp",
   "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP, GIF, AVIF and TIFF images",
-  "version": "0.33.4-revizly5",
+  "version": "0.33.4-revizly7",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://sharp.pixelplumbing.com",
   "contributors": [
@@ -144,8 +144,8 @@
   "optionalDependencies": {
     "@revizly/sharp-libvips-linux-arm64": "1.0.7",
     "@revizly/sharp-libvips-linux-x64": "1.0.7",
-    "@revizly/sharp-linux-arm64": "0.33.4-revizly3",
-    "@revizly/sharp-linux-x64": "0.33.4-revizly3"
+    "@revizly/sharp-linux-arm64": "0.33.4-revizly6",
+    "@revizly/sharp-linux-x64": "0.33.4-revizly6"
   },
   "devDependencies": {
     "@emnapi/runtime": "^1.2.0",

package/src/operations.cc

@@ -164,10 +164,10 @@ namespace sharp {
    */
   VImage Convolve(VImage image, int const width, int const height,
     double const scale, double const offset,
-    std::unique_ptr<double[]> const &kernel_v
+    std::vector<double> const &kernel_v
   ) {
     VImage kernel = VImage::new_from_memory(
-      kernel_v.get(),
+      static_cast<void*>(const_cast<double*>(kernel_v.data())),
       width * height * sizeof(double),
       width,
       height,
@@ -183,19 +183,21 @@ namespace sharp {
    * Recomb with a Matrix of the given bands/channel size.
    * Eg. RGB will be a 3x3 matrix.
    */
-  VImage Recomb(VImage image, std::unique_ptr<double[]> const &matrix) {
-    double *m = matrix.get();
+  VImage Recomb(VImage image, std::vector<double> const& matrix) {
+    double* m = const_cast<double*>(matrix.data());
     image = image.colourspace(VIPS_INTERPRETATION_sRGB);
-    return image
-      .recomb(image.bands() == 3
-        ? VImage::new_from_memory(
-          m, 9 * sizeof(double), 3, 3, 1, VIPS_FORMAT_DOUBLE
-        )
-        : VImage::new_matrixv(4, 4,
-          m[0], m[1], m[2], 0.0,
-          m[3], m[4], m[5], 0.0,
-          m[6], m[7], m[8], 0.0,
-          0.0, 0.0, 0.0, 1.0));
+    if (matrix.size() == 9) {
+      return image
+        .recomb(image.bands() == 3
+          ? VImage::new_matrix(3, 3, m, 9)
+          : VImage::new_matrixv(4, 4,
+            m[0], m[1], m[2], 0.0,
+            m[3], m[4], m[5], 0.0,
+            m[6], m[7], m[8], 0.0,
+            0.0, 0.0, 0.0, 1.0));
+    } else {
+      return image.recomb(VImage::new_matrix(4, 4, m, 16));
+    }
   }
 
   VImage Modulate(VImage image, double const brightness, double const saturation,

package/src/operations.h

@@ -53,7 +53,7 @@ namespace sharp {
    * Convolution with a kernel.
    */
   VImage Convolve(VImage image, int const width, int const height,
-    double const scale, double const offset, std::unique_ptr<double[]> const &kernel_v);
+    double const scale, double const offset, std::vector<double> const &kernel_v);
 
   /*
    * Sharpen flat and jagged areas. Use sigma of -1.0 for fast sharpen.
@@ -95,7 +95,7 @@ namespace sharp {
    * Recomb with a Matrix of the given bands/channel size.
    * Eg. RGB will be a 3x3 matrix.
    */
-  VImage Recomb(VImage image, std::unique_ptr<double[]> const &matrix);
+  VImage Recomb(VImage image, std::vector<double> const &matrix);
 
   /*
    * Modulate brightness, saturation, hue and lightness

package/src/pipeline.cc

@@ -609,7 +609,7 @@ class PipelineWorker : public Napi::AsyncWorker {
       }
 
       // Recomb
-      if (baton->recombMatrix != NULL) {
+      if (!baton->recombMatrix.empty()) {
         image = sharp::Recomb(image, baton->recombMatrix);
       }
 
@@ -1606,17 +1606,18 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
     baton->convKernelScale = sharp::AttrAsDouble(kernel, "scale");
     baton->convKernelOffset = sharp::AttrAsDouble(kernel, "offset");
     size_t const kernelSize = static_cast<size_t>(baton->convKernelWidth * baton->convKernelHeight);
-    baton->convKernel = std::unique_ptr<double[]>(new double[kernelSize]);
+    baton->convKernel.resize(kernelSize);
     Napi::Array kdata = kernel.Get("kernel").As<Napi::Array>();
     for (unsigned int i = 0; i < kernelSize; i++) {
       baton->convKernel[i] = sharp::AttrAsDouble(kdata, i);
     }
   }
   if (options.Has("recombMatrix")) {
-    baton->recombMatrix = std::unique_ptr<double[]>(new double[9]);
     Napi::Array recombMatrix = options.Get("recombMatrix").As<Napi::Array>();
-    for (unsigned int i = 0; i < 9; i++) {
-       baton->recombMatrix[i] = sharp::AttrAsDouble(recombMatrix, i);
+    unsigned int matrixElements = recombMatrix.Length();
+    baton->recombMatrix.resize(matrixElements);
+    for (unsigned int i = 0; i < matrixElements; i++) {
+      baton->recombMatrix[i] = sharp::AttrAsDouble(recombMatrix, i);
     }
   }
   baton->colourspacePipeline = sharp::AttrAsEnum<VipsInterpretation>(

package/src/pipeline.h

@@ -197,7 +197,7 @@ struct PipelineBaton {
   std::unordered_map<std::string, std::string> withExif;
   bool withExifMerge;
   int timeoutSeconds;
-  std::unique_ptr<double[]> convKernel;
+  std::vector<double> convKernel;
   int convKernelWidth;
   int convKernelHeight;
   double convKernelScale;
@@ -223,7 +223,7 @@ struct PipelineBaton {
   VipsForeignDzDepth tileDepth;
   std::string tileId;
   std::string tileBasename;
-  std::unique_ptr<double[]> recombMatrix;
+  std::vector<double> recombMatrix;
 
   PipelineBaton():
     input(nullptr),