@basemaps/lambda-tiler 6.18.0 → 6.21.1

package/dist/node_modules/sharp/src/metadata.cc

@@ -1,271 +0,0 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <numeric>
-#include <vector>
-
-#include <napi.h>
-#include <vips/vips8>
-
-#include "common.h"
-#include "metadata.h"
-
-class MetadataWorker : public Napi::AsyncWorker {
- public:
-  MetadataWorker(Napi::Function callback, MetadataBaton *baton, Napi::Function debuglog) :
-    Napi::AsyncWorker(callback), baton(baton), debuglog(Napi::Persistent(debuglog)) {}
-  ~MetadataWorker() {}
-
-  void Execute() {
-    // Decrement queued task counter
-    g_atomic_int_dec_and_test(&sharp::counterQueue);
-
-    vips::VImage image;
-    sharp::ImageType imageType = sharp::ImageType::UNKNOWN;
-    try {
-      std::tie(image, imageType) = OpenInput(baton->input);
-    } catch (vips::VError const &err) {
-      (baton->err).append(err.what());
-    }
-    if (imageType != sharp::ImageType::UNKNOWN) {
-      // Image type
-      baton->format = sharp::ImageTypeId(imageType);
-      // VipsImage attributes
-      baton->width = image.width();
-      baton->height = image.height();
-      baton->space = vips_enum_nick(VIPS_TYPE_INTERPRETATION, image.interpretation());
-      baton->channels = image.bands();
-      baton->depth = vips_enum_nick(VIPS_TYPE_BAND_FORMAT, image.format());
-      if (sharp::HasDensity(image)) {
-        baton->density = sharp::GetDensity(image);
-      }
-      if (image.get_typeof("jpeg-chroma-subsample") == VIPS_TYPE_REF_STRING) {
-        baton->chromaSubsampling = image.get_string("jpeg-chroma-subsample");
-      }
-      if (image.get_typeof("interlaced") == G_TYPE_INT) {
-        baton->isProgressive = image.get_int("interlaced") == 1;
-      }
-      if (image.get_typeof("palette-bit-depth") == G_TYPE_INT) {
-        baton->paletteBitDepth = image.get_int("palette-bit-depth");
-      }
-      if (image.get_typeof(VIPS_META_N_PAGES) == G_TYPE_INT) {
-        baton->pages = image.get_int(VIPS_META_N_PAGES);
-      }
-      if (image.get_typeof(VIPS_META_PAGE_HEIGHT) == G_TYPE_INT) {
-        baton->pageHeight = image.get_int(VIPS_META_PAGE_HEIGHT);
-      }
-      if (image.get_typeof("loop") == G_TYPE_INT) {
-        baton->loop = image.get_int("loop");
-      }
-      if (image.get_typeof("delay") == VIPS_TYPE_ARRAY_INT) {
-        baton->delay = image.get_array_int("delay");
-      }
-      if (image.get_typeof("heif-primary") == G_TYPE_INT) {
-        baton->pagePrimary = image.get_int("heif-primary");
-      }
-      if (image.get_typeof("heif-compression") == VIPS_TYPE_REF_STRING) {
-        baton->compression = image.get_string("heif-compression");
-      }
-      if (image.get_typeof("openslide.level-count") == VIPS_TYPE_REF_STRING) {
-        int const levels = std::stoi(image.get_string("openslide.level-count"));
-        for (int l = 0; l < levels; l++) {
-          std::string prefix = "openslide.level[" + std::to_string(l) + "].";
-          int const width = std::stoi(image.get_string((prefix + "width").data()));
-          int const height = std::stoi(image.get_string((prefix + "height").data()));
-          baton->levels.push_back(std::pair<int, int>(width, height));
-        }
-      }
-      if (image.get_typeof(VIPS_META_N_SUBIFDS) == G_TYPE_INT) {
-        baton->subifds = image.get_int(VIPS_META_N_SUBIFDS);
-      }
-      baton->hasProfile = sharp::HasProfile(image);
-      // Derived attributes
-      baton->hasAlpha = sharp::HasAlpha(image);
-      baton->orientation = sharp::ExifOrientation(image);
-      // EXIF
-      if (image.get_typeof(VIPS_META_EXIF_NAME) == VIPS_TYPE_BLOB) {
-        size_t exifLength;
-        void const *exif = image.get_blob(VIPS_META_EXIF_NAME, &exifLength);
-        baton->exif = static_cast<char*>(g_malloc(exifLength));
-        memcpy(baton->exif, exif, exifLength);
-        baton->exifLength = exifLength;
-      }
-      // ICC profile
-      if (image.get_typeof(VIPS_META_ICC_NAME) == VIPS_TYPE_BLOB) {
-        size_t iccLength;
-        void const *icc = image.get_blob(VIPS_META_ICC_NAME, &iccLength);
-        baton->icc = static_cast<char*>(g_malloc(iccLength));
-        memcpy(baton->icc, icc, iccLength);
-        baton->iccLength = iccLength;
-      }
-      // IPTC
-      if (image.get_typeof(VIPS_META_IPTC_NAME) == VIPS_TYPE_BLOB) {
-        size_t iptcLength;
-        void const *iptc = image.get_blob(VIPS_META_IPTC_NAME, &iptcLength);
-        baton->iptc = static_cast<char *>(g_malloc(iptcLength));
-        memcpy(baton->iptc, iptc, iptcLength);
-        baton->iptcLength = iptcLength;
-      }
-      // XMP
-      if (image.get_typeof(VIPS_META_XMP_NAME) == VIPS_TYPE_BLOB) {
-        size_t xmpLength;
-        void const *xmp = image.get_blob(VIPS_META_XMP_NAME, &xmpLength);
-        baton->xmp = static_cast<char *>(g_malloc(xmpLength));
-        memcpy(baton->xmp, xmp, xmpLength);
-        baton->xmpLength = xmpLength;
-      }
-      // TIFFTAG_PHOTOSHOP
-      if (image.get_typeof(VIPS_META_PHOTOSHOP_NAME) == VIPS_TYPE_BLOB) {
-        size_t tifftagPhotoshopLength;
-        void const *tifftagPhotoshop = image.get_blob(VIPS_META_PHOTOSHOP_NAME, &tifftagPhotoshopLength);
-        baton->tifftagPhotoshop = static_cast<char *>(g_malloc(tifftagPhotoshopLength));
-        memcpy(baton->tifftagPhotoshop, tifftagPhotoshop, tifftagPhotoshopLength);
-        baton->tifftagPhotoshopLength = tifftagPhotoshopLength;
-      }
-    }
-
-    // Clean up
-    vips_error_clear();
-    vips_thread_shutdown();
-  }
-
-  void OnOK() {
-    Napi::Env env = Env();
-    Napi::HandleScope scope(env);
-
-    // Handle warnings
-    std::string warning = sharp::VipsWarningPop();
-    while (!warning.empty()) {
-      debuglog.Call({ Napi::String::New(env, warning) });
-      warning = sharp::VipsWarningPop();
-    }
-
-    if (baton->err.empty()) {
-      Napi::Object info = Napi::Object::New(env);
-      info.Set("format", baton->format);
-      if (baton->input->bufferLength > 0) {
-        info.Set("size", baton->input->bufferLength);
-      }
-      info.Set("width", baton->width);
-      info.Set("height", baton->height);
-      info.Set("space", baton->space);
-      info.Set("channels", baton->channels);
-      info.Set("depth", baton->depth);
-      if (baton->density > 0) {
-        info.Set("density", baton->density);
-      }
-      if (!baton->chromaSubsampling.empty()) {
-        info.Set("chromaSubsampling", baton->chromaSubsampling);
-      }
-      info.Set("isProgressive", baton->isProgressive);
-      if (baton->paletteBitDepth > 0) {
-        info.Set("paletteBitDepth", baton->paletteBitDepth);
-      }
-      if (baton->pages > 0) {
-        info.Set("pages", baton->pages);
-      }
-      if (baton->pageHeight > 0) {
-        info.Set("pageHeight", baton->pageHeight);
-      }
-      if (baton->loop >= 0) {
-        info.Set("loop", baton->loop);
-      }
-      if (!baton->delay.empty()) {
-        int i = 0;
-        Napi::Array delay = Napi::Array::New(env, static_cast<size_t>(baton->delay.size()));
-        for (int const d : baton->delay) {
-          delay.Set(i++, d);
-        }
-        info.Set("delay", delay);
-      }
-      if (baton->pagePrimary > -1) {
-        info.Set("pagePrimary", baton->pagePrimary);
-      }
-      if (!baton->compression.empty()) {
-        info.Set("compression", baton->compression);
-      }
-      if (!baton->levels.empty()) {
-        int i = 0;
-        Napi::Array levels = Napi::Array::New(env, static_cast<size_t>(baton->levels.size()));
-        for (std::pair<int, int> const &l : baton->levels) {
-          Napi::Object level = Napi::Object::New(env);
-          level.Set("width", l.first);
-          level.Set("height", l.second);
-          levels.Set(i++, level);
-        }
-        info.Set("levels", levels);
-      }
-      if (baton->subifds > 0) {
-        info.Set("subifds", baton->subifds);
-      }
-      info.Set("hasProfile", baton->hasProfile);
-      info.Set("hasAlpha", baton->hasAlpha);
-      if (baton->orientation > 0) {
-        info.Set("orientation", baton->orientation);
-      }
-      if (baton->exifLength > 0) {
-        info.Set("exif", Napi::Buffer<char>::New(env, baton->exif, baton->exifLength, sharp::FreeCallback));
-      }
-      if (baton->iccLength > 0) {
-        info.Set("icc", Napi::Buffer<char>::New(env, baton->icc, baton->iccLength, sharp::FreeCallback));
-      }
-      if (baton->iptcLength > 0) {
-        info.Set("iptc", Napi::Buffer<char>::New(env, baton->iptc, baton->iptcLength, sharp::FreeCallback));
-      }
-      if (baton->xmpLength > 0) {
-        info.Set("xmp", Napi::Buffer<char>::New(env, baton->xmp, baton->xmpLength, sharp::FreeCallback));
-      }
-      if (baton->tifftagPhotoshopLength > 0) {
-        info.Set("tifftagPhotoshop",
-          Napi::Buffer<char>::New(env, baton->tifftagPhotoshop, baton->tifftagPhotoshopLength, sharp::FreeCallback));
-      }
-      Callback().MakeCallback(Receiver().Value(), { env.Null(), info });
-    } else {
-      Callback().MakeCallback(Receiver().Value(), { Napi::Error::New(env, baton->err).Value() });
-    }
-
-    delete baton->input;
-    delete baton;
-  }
-
- private:
-  MetadataBaton* baton;
-  Napi::FunctionReference debuglog;
-};
-
-/*
-  metadata(options, callback)
-*/
-Napi::Value metadata(const Napi::CallbackInfo& info) {
-  // V8 objects are converted to non-V8 types held in the baton struct
-  MetadataBaton *baton = new MetadataBaton;
-  Napi::Object options = info[0].As<Napi::Object>();
-
-  // Input
-  baton->input = sharp::CreateInputDescriptor(options.Get("input").As<Napi::Object>());
-
-  // Function to notify of libvips warnings
-  Napi::Function debuglog = options.Get("debuglog").As<Napi::Function>();
-
-  // Join queue for worker thread
-  Napi::Function callback = info[1].As<Napi::Function>();
-  MetadataWorker *worker = new MetadataWorker(callback, baton, debuglog);
-  worker->Receiver().Set("options", options);
-  worker->Queue();
-
-  // Increment queued task counter
-  g_atomic_int_inc(&sharp::counterQueue);
-
-  return info.Env().Undefined();
-}

package/dist/node_modules/sharp/src/metadata.h

@@ -1,90 +0,0 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_METADATA_H_
-#define SRC_METADATA_H_
-
-#include <string>
-#include <napi.h>
-
-#include "./common.h"
-
-struct MetadataBaton {
-  // Input
-  sharp::InputDescriptor *input;
-  // Output
-  std::string format;
-  int width;
-  int height;
-  std::string space;
-  int channels;
-  std::string depth;
-  int density;
-  std::string chromaSubsampling;
-  bool isProgressive;
-  int paletteBitDepth;
-  int pages;
-  int pageHeight;
-  int loop;
-  std::vector<int> delay;
-  int pagePrimary;
-  std::string compression;
-  std::vector<std::pair<int, int>> levels;
-  int subifds;
-  bool hasProfile;
-  bool hasAlpha;
-  int orientation;
-  char *exif;
-  size_t exifLength;
-  char *icc;
-  size_t iccLength;
-  char *iptc;
-  size_t iptcLength;
-  char *xmp;
-  size_t xmpLength;
-  char *tifftagPhotoshop;
-  size_t tifftagPhotoshopLength;
-  std::string err;
-
-  MetadataBaton():
-    input(nullptr),
-    width(0),
-    height(0),
-    channels(0),
-    density(0),
-    isProgressive(false),
-    paletteBitDepth(0),
-    pages(0),
-    pageHeight(0),
-    loop(-1),
-    pagePrimary(-1),
-    subifds(0),
-    hasProfile(false),
-    hasAlpha(false),
-    orientation(0),
-    exif(nullptr),
-    exifLength(0),
-    icc(nullptr),
-    iccLength(0),
-    iptc(nullptr),
-    iptcLength(0),
-    xmp(nullptr),
-    xmpLength(0),
-    tifftagPhotoshop(nullptr),
-    tifftagPhotoshopLength(0) {}
-};
-
-Napi::Value metadata(const Napi::CallbackInfo& info);
-
-#endif  // SRC_METADATA_H_

package/dist/node_modules/sharp/src/operations.cc

@@ -1,285 +0,0 @@
-// Copyright 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Lovell Fuller and contributors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <algorithm>
-#include <functional>
-#include <memory>
-#include <tuple>
-#include <vector>
-
-#include <vips/vips8>
-
-#include "common.h"
-#include "operations.h"
-
-using vips::VImage;
-using vips::VError;
-
-namespace sharp {
-  /*
-   * Tint an image using the specified chroma, preserving the original image luminance
-   */
-  VImage Tint(VImage image, double const a, double const b) {
-    // Get original colourspace
-    VipsInterpretation typeBeforeTint = image.interpretation();
-    if (typeBeforeTint == VIPS_INTERPRETATION_RGB) {
-      typeBeforeTint = VIPS_INTERPRETATION_sRGB;
-    }
-    // Extract luminance
-    VImage luminance = image.colourspace(VIPS_INTERPRETATION_LAB)[0];
-    // Create the tinted version by combining the L from the original and the chroma from the tint
-    std::vector<double> chroma {a, b};
-    VImage tinted = luminance
-      .bandjoin(chroma)
-      .copy(VImage::option()->set("interpretation", VIPS_INTERPRETATION_LAB))
-      .colourspace(typeBeforeTint);
-    // Attach original alpha channel, if any
-    if (HasAlpha(image)) {
-      // Extract original alpha channel
-      VImage alpha = image[image.bands() - 1];
-      // Join alpha channel to normalised image
-      tinted = tinted.bandjoin(alpha);
-    }
-    return tinted;
-  }
-
-  /*
-   * Stretch luminance to cover full dynamic range.
-   */
-  VImage Normalise(VImage image) {
-    // Get original colourspace
-    VipsInterpretation typeBeforeNormalize = image.interpretation();
-    if (typeBeforeNormalize == VIPS_INTERPRETATION_RGB) {
-      typeBeforeNormalize = VIPS_INTERPRETATION_sRGB;
-    }
-    // Convert to LAB colourspace
-    VImage lab = image.colourspace(VIPS_INTERPRETATION_LAB);
-    // Extract luminance
-    VImage luminance = lab[0];
-    // Find luminance range
-    VImage stats = luminance.stats();
-    double min = stats(0, 0)[0];
-    double max = stats(1, 0)[0];
-    if (min != max) {
-      // Extract chroma
-      VImage chroma = lab.extract_band(1, VImage::option()->set("n", 2));
-      // Calculate multiplication factor and addition
-      double f = 100.0 / (max - min);
-      double a = -(min * f);
-      // Scale luminance, join to chroma, convert back to original colourspace
-      VImage normalized = luminance.linear(f, a).bandjoin(chroma).colourspace(typeBeforeNormalize);
-      // Attach original alpha channel, if any
-      if (HasAlpha(image)) {
-        // Extract original alpha channel
-        VImage alpha = image[image.bands() - 1];
-        // Join alpha channel to normalised image
-        return normalized.bandjoin(alpha);
-      } else {
-        return normalized;
-      }
-    }
-    return image;
-  }
-
-  /*
-   * Contrast limiting adapative histogram equalization (CLAHE)
-   */
-  VImage Clahe(VImage image, int const width, int const height, int const maxSlope) {
-    return image.hist_local(width, height, VImage::option()->set("max_slope", maxSlope));
-  }
-
-  /*
-   * Gamma encoding/decoding
-   */
-  VImage Gamma(VImage image, double const exponent) {
-    if (HasAlpha(image)) {
-      // Separate alpha channel
-      VImage alpha = image[image.bands() - 1];
-      return RemoveAlpha(image).gamma(VImage::option()->set("exponent", exponent)).bandjoin(alpha);
-    } else {
-      return image.gamma(VImage::option()->set("exponent", exponent));
-    }
-  }
-
-  /*
-   * Gaussian blur. Use sigma of -1.0 for fast blur.
-   */
-  VImage Blur(VImage image, double const sigma) {
-    if (sigma == -1.0) {
-      // Fast, mild blur - averages neighbouring pixels
-      VImage blur = VImage::new_matrixv(3, 3,
-        1.0, 1.0, 1.0,
-        1.0, 1.0, 1.0,
-        1.0, 1.0, 1.0);
-      blur.set("scale", 9.0);
-      return image.conv(blur);
-    } else {
-      // Slower, accurate Gaussian blur
-      return image.gaussblur(sigma);
-    }
-  }
-
-  /*
-   * 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
-  ) {
-    VImage kernel = VImage::new_from_memory(
-      kernel_v.get(),
-      width * height * sizeof(double),
-      width,
-      height,
-      1,
-      VIPS_FORMAT_DOUBLE);
-    kernel.set("scale", scale);
-    kernel.set("offset", offset);
-
-    return image.conv(kernel);
-  }
-
-  /*
-   * 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();
-    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));
-  }
-
-  VImage Modulate(VImage image, double const brightness, double const saturation, int const hue) {
-    if (HasAlpha(image)) {
-      // Separate alpha channel
-      VImage alpha = image[image.bands() - 1];
-      return RemoveAlpha(image)
-        .colourspace(VIPS_INTERPRETATION_LCH)
-        .linear(
-          { brightness, saturation, 1},
-          { 0.0, 0.0, static_cast<double>(hue) }
-        )
-        .colourspace(VIPS_INTERPRETATION_sRGB)
-        .bandjoin(alpha);
-    } else {
-      return image
-        .colourspace(VIPS_INTERPRETATION_LCH)
-        .linear(
-          { brightness, saturation, 1 },
-          { 0.0, 0.0, static_cast<double>(hue) }
-        )
-        .colourspace(VIPS_INTERPRETATION_sRGB);
-    }
-  }
-
-  /*
-   * Sharpen flat and jagged areas. Use sigma of -1.0 for fast sharpen.
-   */
-  VImage Sharpen(VImage image, double const sigma, double const flat, double const jagged) {
-    if (sigma == -1.0) {
-      // Fast, mild sharpen
-      VImage sharpen = VImage::new_matrixv(3, 3,
-        -1.0, -1.0, -1.0,
-        -1.0, 32.0, -1.0,
-        -1.0, -1.0, -1.0);
-      sharpen.set("scale", 24.0);
-      return image.conv(sharpen);
-    } else {
-      // Slow, accurate sharpen in LAB colour space, with control over flat vs jagged areas
-      VipsInterpretation colourspaceBeforeSharpen = image.interpretation();
-      if (colourspaceBeforeSharpen == VIPS_INTERPRETATION_RGB) {
-        colourspaceBeforeSharpen = VIPS_INTERPRETATION_sRGB;
-      }
-      return image.sharpen(
-        VImage::option()->set("sigma", sigma)->set("m1", flat)->set("m2", jagged))
-        .colourspace(colourspaceBeforeSharpen);
-    }
-  }
-
-  VImage Threshold(VImage image, double const threshold, bool const thresholdGrayscale) {
-    if (!thresholdGrayscale) {
-      return image >= threshold;
-    }
-    return image.colourspace(VIPS_INTERPRETATION_B_W) >= threshold;
-  }
-
-  /*
-    Perform boolean/bitwise operation on image color channels - results in one channel image
-  */
-  VImage Bandbool(VImage image, VipsOperationBoolean const boolean) {
-    image = image.bandbool(boolean);
-    return image.copy(VImage::option()->set("interpretation", VIPS_INTERPRETATION_B_W));
-  }
-
-  /*
-    Perform bitwise boolean operation between images
-  */
-  VImage Boolean(VImage image, VImage imageR, VipsOperationBoolean const boolean) {
-    return image.boolean(imageR, boolean);
-  }
-
-  /*
-    Trim an image
-  */
-  VImage Trim(VImage image, double const threshold) {
-    if (image.width() < 3 && image.height() < 3) {
-      throw VError("Image to trim must be at least 3x3 pixels");
-    }
-    // Top-left pixel provides the background colour
-    VImage background = image.extract_area(0, 0, 1, 1);
-    if (HasAlpha(background)) {
-      background = background.flatten();
-    }
-    int left, top, width, height;
-    left = image.find_trim(&top, &width, &height, VImage::option()
-      ->set("background", background(0, 0))
-      ->set("threshold", threshold));
-    if (width == 0 || height == 0) {
-      if (HasAlpha(image)) {
-        // Search alpha channel
-        VImage alpha = image[image.bands() - 1];
-        VImage backgroundAlpha = alpha.extract_area(0, 0, 1, 1);
-        left = alpha.find_trim(&top, &width, &height, VImage::option()
-          ->set("background", backgroundAlpha(0, 0))
-          ->set("threshold", threshold));
-      }
-      if (width == 0 || height == 0) {
-        throw VError("Unexpected error while trimming. Try to lower the tolerance");
-      }
-    }
-    return image.extract_area(left, top, width, height);
-  }
-
-  /*
-   * Calculate (a * in + b)
-   */
-  VImage Linear(VImage image, double const a, double const b) {
-    if (HasAlpha(image)) {
-      // Separate alpha channel
-      VImage alpha = image[image.bands() - 1];
-      return RemoveAlpha(image).linear(a, b).bandjoin(alpha);
-    } else {
-      return image.linear(a, b);
-    }
-  }
-}  // namespace sharp