Release v0.15.1

Switch param validation to use internal functions

.jshintrc

@@ -2,7 +2,7 @@
   "strict": true,
   "node": true,
   "maxparams": 4,
-  "maxcomplexity": 13,
+  "maxcomplexity": 14,
   "globals": {
     "beforeEach": true,
     "afterEach": true,

.npmignore

@@ -13,3 +13,4 @@ mkdocs.yml
 lib
 include
 packaging
+preinstall.sh

.travis.yml

@@ -3,7 +3,10 @@ node_js:
   - "0.10"
   - "0.12"
   - "4"
-  - "5"
+  - "6"
+os:
+  - linux
+  - osx
 sudo: false
 addons:
   apt:
@@ -11,7 +14,9 @@ addons:
     - ubuntu-toolchain-r-test
     packages:
     - g++-4.8
-env:
+osx_image: xcode7.3
-  CXX=g++-4.8
+before_install:
+  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then export CXX=g++-4.8; fi
+  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install homebrew/science/vips; fi
 after_success:
   - cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js

CONTRIBUTING.md

@@ -41,9 +41,8 @@ Any change that modifies the existing public API should be added to the relevant
 
 | Release | WIP branch |
 | ------: | :--------- |
-| v0.14.0 | needle     |
-| v0.15.0 | outfit     |
 | v0.16.0 | pencil     |
+| v0.17.0 | quill      |
 
 Please squash your changes into a single commit using a command like `git rebase -i upstream/<wip-branch>`.
 

README.md

@@ -1,14 +1,14 @@
 # sharp
 
 The typical use case for this high speed Node.js module
-is to convert large images of many formats to
+is to convert large images in common formats to
 smaller, web-friendly JPEG, PNG and WebP images of varying dimensions.
 
-Resizing an image is typically 4x faster than using the
+Resizing an image is typically 4x-5x faster than using the
 quickest ImageMagick and GraphicsMagick settings.
 
 Colour spaces, embedded ICC profiles and alpha transparency channels are all handled correctly.
-Bicubic interpolation with Lanczos anti-alias filtering ensures quality is not sacrificed for speed.
+Lanczos resampling ensures quality is not sacrificed for speed.
 
 As well as image resizing, operations such as
 rotation, extraction, compositing and gamma correction are available.

appveyor.yml

@@ -1,4 +1,4 @@
-os: Visual Studio 2015
+os: Previous Visual Studio 2015
 version: "{build}"
 build: off
 platform: x64
@@ -7,7 +7,7 @@ environment:
   matrix:
   - nodejs_version: "0.12"
   - nodejs_version: "4"
-  - nodejs_version: "5"
+  - nodejs_version: "6"
 install:
   - ps: Install-Product node $env:nodejs_version x64
   - npm install

binding.gyp

@@ -9,7 +9,8 @@
           'download_vips': '<!(node -e "require(\'./binding\').download_vips()")'
         },
         'defines': [
-          'VIPS_CPLUSPLUS_EXPORTS'
+          'VIPS_CPLUSPLUS_EXPORTS',
+          '_ALLOW_KEYWORD_MACROS'
         ],
         'sources': [
           'src/libvips/cplusplus/VError.cpp',
@@ -50,6 +51,7 @@
     ],
     # Nested variables "pattern" borrowed from http://src.chromium.org/viewvc/chrome/trunk/src/build/common.gypi
     'variables': {
+      'sharp_cxx11%': '0',
       'variables': {
         'variables': {
           'conditions': [
@@ -91,7 +93,8 @@
       'src/utilities.cc'
     ],
     'defines': [
-      '_GLIBCXX_USE_CXX11_ABI=0'
+      '_GLIBCXX_USE_CXX11_ABI=<(sharp_cxx11)',
+      '_ALLOW_KEYWORD_MACROS'
     ],
     'include_dirs': [
       '<!(node -e "require(\'nan\')")'
@@ -132,23 +135,33 @@
               '<(module_root_dir)/lib/libglib-2.0.so',
               '<(module_root_dir)/lib/libgobject-2.0.so',
               # Dependencies of dependencies, included for openSUSE support
-              '<(module_root_dir)/lib/libGraphicsMagick.so',
+              '<(module_root_dir)/lib/libcairo.so',
-              '<(module_root_dir)/lib/libGraphicsMagickWand.so',
+              '<(module_root_dir)/lib/libcroco-0.6.so',
               '<(module_root_dir)/lib/libexif.so',
+              '<(module_root_dir)/lib/libffi.so',
+              '<(module_root_dir)/lib/libfontconfig.so',
+              '<(module_root_dir)/lib/libfreetype.so',
+              '<(module_root_dir)/lib/libgdk_pixbuf-2.0.so',
+              '<(module_root_dir)/lib/libgif.so',
               '<(module_root_dir)/lib/libgio-2.0.so',
               '<(module_root_dir)/lib/libgmodule-2.0.so',
               '<(module_root_dir)/lib/libgsf-1.so',
+              '<(module_root_dir)/lib/libgthread-2.0.so',
+              '<(module_root_dir)/lib/libharfbuzz.so',
               '<(module_root_dir)/lib/libjpeg.so',
+              '<(module_root_dir)/lib/liblcms2.so',
+              '<(module_root_dir)/lib/liborc-0.4.so',
+              '<(module_root_dir)/lib/libpango-1.0.so',
+              '<(module_root_dir)/lib/libpangocairo-1.0.so',
+              '<(module_root_dir)/lib/libpangoft2-1.0.so',
+              '<(module_root_dir)/lib/libpixman-1.so',
               '<(module_root_dir)/lib/libpng.so',
+              '<(module_root_dir)/lib/libpng16.so',
+              '<(module_root_dir)/lib/librsvg-2.so',
               '<(module_root_dir)/lib/libtiff.so',
               '<(module_root_dir)/lib/libwebp.so',
-              '<(module_root_dir)/lib/libz.so',
-              '<(module_root_dir)/lib/libffi.so',
-              '<(module_root_dir)/lib/libgthread-2.0.so',
-              '<(module_root_dir)/lib/liblcms2.so',
-              '<(module_root_dir)/lib/libpng16.so',
               '<(module_root_dir)/lib/libxml2.so',
-              '<(module_root_dir)/lib/liborc-0.4.so',
+              '<(module_root_dir)/lib/libz.so',
               # Ensure runtime linking is relative to sharp.node
               '-Wl,-rpath=\'$${ORIGIN}/../../lib\''
             ]
@@ -167,6 +180,7 @@
       'CLANG_CXX_LIBRARY': 'libc++',
       'MACOSX_DEPLOYMENT_TARGET': '10.7',
       'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+      'GCC_ENABLE_CPP_RTTI': 'YES',
       'OTHER_CPLUSPLUSFLAGS': [
         '-fexceptions',
         '-Wall',
@@ -198,12 +212,11 @@
           'destination': '<(module_root_dir)/build/Release',
           'files': [
             '<(module_root_dir)/lib/GNU.Gettext.dll',
-            '<(module_root_dir)/lib/libMagickCore-6.Q16-2.dll',
-            '<(module_root_dir)/lib/libMagickWand-6.Q16-2.dll',
             '<(module_root_dir)/lib/libasprintf-0.dll',
             '<(module_root_dir)/lib/libcairo-2.dll',
             '<(module_root_dir)/lib/libcairo-gobject-2.dll',
             '<(module_root_dir)/lib/libcairo-script-interpreter-2.dll',
+            '<(module_root_dir)/lib/libcroco-0.6-3.dll',
             '<(module_root_dir)/lib/libexif-12.dll',
             '<(module_root_dir)/lib/libexpat-1.dll',
             '<(module_root_dir)/lib/libffi-6.dll',
@@ -212,6 +225,7 @@
             '<(module_root_dir)/lib/libfreetype-6.dll',
             '<(module_root_dir)/lib/libgcc_s_seh-1.dll',
             '<(module_root_dir)/lib/libgdk_pixbuf-2.0-0.dll',
+            '<(module_root_dir)/lib/libgif-4.dll',
             '<(module_root_dir)/lib/libgio-2.0-0.dll',
             '<(module_root_dir)/lib/libglib-2.0-0.dll',
             '<(module_root_dir)/lib/libgmodule-2.0-0.dll',
@@ -221,18 +235,18 @@
             '<(module_root_dir)/lib/libintl-8.dll',
             '<(module_root_dir)/lib/libjpeg-62.dll',
             '<(module_root_dir)/lib/liblcms2-2.dll',
-            '<(module_root_dir)/lib/libopenjpeg-1.dll',
-            '<(module_root_dir)/lib/libopenslide-0.dll',
             '<(module_root_dir)/lib/libpango-1.0-0.dll',
             '<(module_root_dir)/lib/libpangocairo-1.0-0.dll',
             '<(module_root_dir)/lib/libpangowin32-1.0-0.dll',
             '<(module_root_dir)/lib/libpixman-1-0.dll',
             '<(module_root_dir)/lib/libpng16-16.dll',
             '<(module_root_dir)/lib/libquadmath-0.dll',
-            '<(module_root_dir)/lib/libsqlite3-0.dll',
+            '<(module_root_dir)/lib/librsvg-2-2.dll',
             '<(module_root_dir)/lib/libssp-0.dll',
+            '<(module_root_dir)/lib/libstdc++-6.dll',
             '<(module_root_dir)/lib/libtiff-5.dll',
             '<(module_root_dir)/lib/libvips-42.dll',
+            '<(module_root_dir)/lib/libwebp-6.dll',
             '<(module_root_dir)/lib/libxml2-2.dll',
             '<(module_root_dir)/lib/zlib1.dll'
           ]

binding.js

@@ -12,6 +12,9 @@ var tmp = require('os').tmpdir();
 
 var distBaseUrl = 'https://dl.bintray.com/lovell/sharp/';
 
+// Use NPM-provided environment variable where available, falling back to require-based method for Electron
+var minimumLibvipsVersion = process.env.npm_package_config_libvips || require('./package.json').config.libvips;
+
 var vipsHeaderPath = path.join(__dirname, 'include', 'vips', 'vips.h');
 
 // -- Helpers
@@ -75,7 +78,7 @@ module.exports.download_vips = function() {
     }
     // Arch/platform-specific .tar.gz
     var platform = (process.arch === 'arm') ? 'arm' : process.platform.substr(0, 3);
-    var tarFilename = ['libvips', process.env.npm_package_config_libvips, platform].join('-') + '.tar.gz';
+    var tarFilename = ['libvips', minimumLibvipsVersion, platform].join('-') + '.tar.gz';
     var tarPath = path.join(__dirname, 'packaging', tarFilename);
     if (isFile(tarPath)) {
       unpack(tarPath);
@@ -114,13 +117,13 @@ module.exports.use_global_vips = function() {
   if (globalVipsVersion) {
     useGlobalVips = semver.gte(
       globalVipsVersion,
-      process.env.npm_package_config_libvips
+      minimumLibvipsVersion
     );
   }
   if (process.platform === 'darwin' && !useGlobalVips) {
     if (globalVipsVersion) {
       error(
-        'Found libvips ' + globalVipsVersion + ' but require ' + process.env.npm_package_config_libvips +
+        'Found libvips ' + globalVipsVersion + ' but require ' + minimumLibvipsVersion +
         '\nPlease upgrade libvips by running: brew update && brew upgrade'
       );
     } else {

docs/api.md

@@ -13,7 +13,7 @@ Constructor to which further methods are chained.
 `input`, if present, can be one of:
 
 * Buffer containing JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data, or
-* String containing the path to an image file, with most major formats supported.
+* String containing the path to an JPEG, PNG, WebP, GIF, SVG or TIFF image file.
 
 JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data
 can be streamed into the object when `input` is `null` or `undefined`.
@@ -27,6 +27,7 @@ The object returned by the constructor implements the
 [stream.Duplex](http://nodejs.org/api/stream.html#stream_class_stream_duplex) class.
 
 JPEG, PNG or WebP format image data can be streamed out from this object.
+When using Stream based output, derived attributes are available from the `info` event.
 
 ```javascript
 sharp('input.jpg')
@@ -37,17 +38,31 @@ sharp('input.jpg')
   });
 ```
 
+```javascript
+// Read image data from readableStream,
+// resize to 300 pixels wide,
+// emit an 'info' event with calculated dimensions
+// and finally write image data to writableStream
+var transformer = sharp()
+  .resize(300)
+  .on('info', function(info) {
+    console.log('Image height is ' + info.height);
+  });
+readableStream.pipe(transformer).pipe(writableStream);
+```
+
 #### metadata([callback])
 
 Fast access to image metadata without decoding any compressed image data.
 
 `callback`, if present, gets the arguments `(err, metadata)` where `metadata` has the attributes:
 
-* `format`: Name of decoder to be used to decompress image data e.g. `jpeg`, `png`, `webp` (for file-based input additionally `tiff`, `magick`, `openslide`, `ppm`, `fits`)
+* `format`: Name of decoder used to decompress image data e.g. `jpeg`, `png`, `webp`, `gif`, `svg`
 * `width`: Number of pixels wide
 * `height`: Number of pixels high
 * `space`: Name of colour space interpretation e.g. `srgb`, `rgb`, `scrgb`, `cmyk`, `lab`, `xyz`, `b-w` [...](https://github.com/jcupitt/libvips/blob/master/libvips/iofuncs/enumtypes.c#L522)
 * `channels`: Number of bands e.g. `3` for sRGB, `4` for CMYK
+* `density`: Number of pixels per inch (DPI), if present
 * `hasProfile`: Boolean indicating the presence of an embedded ICC profile
 * `hasAlpha`: Boolean indicating the presence of an alpha transparency channel
 * `orientation`: Number value of the EXIF Orientation header, if present
@@ -98,11 +113,12 @@ This will reduce memory usage and can improve performance on some systems.
 
 Do not process input images where the number of pixels (width * height) exceeds this limit.
 
-`pixels` is the integral Number of pixels, with a value between 1 and the default 268402689 (0x3FFF * 0x3FFF).
+`pixels` is either an integral Number of pixels, with a value between 1 and the default 268402689 (0x3FFF * 0x3FFF) or
+ a boolean. `false` will disable checking while `true` will revert to the default limit.
 
 ### Resizing
 
-#### resize([width], [height])
+#### resize([width], [height], [options])
 
 Scale output to `width` x `height`. By default, the resized image is cropped to the exact size specified.
 
@@ -110,23 +126,73 @@ Scale output to `width` x `height`. By default, the resized image is cropped to
 
 `height` is the integral Number of pixels high the resultant image should be, between 1 and 16383. Use `null` or `undefined` to auto-scale the height to match the width.
 
-#### crop([gravity])
+`options` is an optional Object. If present, it can contain one or more of:
+
+* `options.kernel`, the kernel to use for image reduction, defaulting to `lanczos3`.
+* `options.interpolator`, the interpolator to use for image enlargement, defaulting to `bicubic`.
+
+Possible kernels are:
+
+* `cubic`: Use a [Catmull-Rom spline](https://en.wikipedia.org/wiki/Centripetal_Catmull%E2%80%93Rom_spline).
+* `lanczos2`: Use a [Lanczos kernel](https://en.wikipedia.org/wiki/Lanczos_resampling#Lanczos_kernel) with `a=2`.
+* `lanczos3`: Use a Lanczos kernel with `a=3` (the default).
+
+Possible interpolators are:
+
+* `nearest`: Use [nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation).
+* `bilinear`: Use [bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation), faster than bicubic but with less smooth results.
+* `vertexSplitQuadraticBasisSpline`: Use the smoother [VSQBS interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/vsqbs.cpp#L48) to prevent "staircasing" when enlarging.
+* `bicubic`: Use [bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation) (the default).
+* `locallyBoundedBicubic`: Use [LBB interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/lbb.cpp#L100), which prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" but typically reduces performance by a factor of 2.
+* `nohalo`: Use [Nohalo interpolation](http://eprints.soton.ac.uk/268086/), which prevents acutance but typically reduces performance by a factor of 3.
+
+```javascript
+sharp(inputBuffer)
+  .resize(200, 300, {
+    kernel: sharp.kernel.lanczos2,
+    interpolator: sharp.interpolator.nohalo
+  })
+  .background('white')
+  .embed()
+  .toFile('output.tiff')
+  .then(function() {
+    // output.tiff is a 200 pixels wide and 300 pixels high image
+    // containing a lanczos2/nohalo scaled version, embedded on a white canvas,
+    // of the image data in inputBuffer
+  });
+```
+
+#### crop([option])
 
 Crop the resized image to the exact size specified, the default behaviour.
 
-`gravity`, if present, is a String or an attribute of the `sharp.gravity` Object e.g. `sharp.gravity.north`.
+`option`, if present, is an attribute of:
 
-Possible values are `north`, `northeast`, `east`, `southeast`, `south`, `southwest`, `west`, `northwest`, `center` and `centre`.
+* `sharp.gravity` e.g. `sharp.gravity.north`, to crop to an edge or corner, or
-The default gravity is `center`/`centre`.
+* `sharp.strategy` e.g. `sharp.strategy.entropy`, to crop dynamically.
+
+Possible attributes of `sharp.gravity` are
+`north`, `northeast`, `east`, `southeast`, `south`,
+`southwest`, `west`, `northwest`, `center` and `centre`.
+
+Possible attributes of the experimental `sharp.strategy` are:
+
+* `entropy`: resize so one dimension is at its target size
+then repeatedly remove pixels from the edge with the lowest
+[Shannon entropy](https://en.wikipedia.org/wiki/Entropy_%28information_theory%29)
+until it too reaches the target size.
+
+The default crop option is a `center`/`centre` gravity.
 
 ```javascript
 var transformer = sharp()
-  .resize(300, 200)
+  .resize(200, 200)
-  .crop(sharp.gravity.north)
+  .crop(sharp.strategy.entropy)
   .on('error', function(err) {
     console.log(err);
   });
-// Read image data from readableStream, resize and write image data to writableStream
+// Read image data from readableStream
+// Write 200px square auto-cropped image data to writableStream
 readableStream.pipe(transformer).pipe(writableStream);
 ```
 
@@ -202,37 +268,6 @@ if its width or height exceeds the geometry specification*".
 
 Ignoring the aspect ratio of the input, stretch the image to the exact `width` and/or `height` provided via `resize`.
 
-#### interpolateWith(interpolator)
-
-Use the given interpolator for image resizing, where `interpolator` is an attribute of the `sharp.interpolator` Object e.g. `sharp.interpolator.bicubic`.
-
-The default interpolator is `bicubic`, providing a general-purpose interpolator that is both fast and of good quality.
-
-Possible interpolators, in order of performance, are:
-
-* `nearest`: Use [nearest neighbour interpolation](http://en.wikipedia.org/wiki/Nearest-neighbor_interpolation), suitable for image enlargement only.
-* `bilinear`: Use [bilinear interpolation](http://en.wikipedia.org/wiki/Bilinear_interpolation), faster than bicubic but with less smooth results.
-* `vertexSplitQuadraticBasisSpline`: Use the smoother [VSQBS interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/vsqbs.cpp#L48) to prevent "staircasing" when enlarging.
-* `bicubic`: Use [bicubic interpolation](http://en.wikipedia.org/wiki/Bicubic_interpolation) (the default).
-* `locallyBoundedBicubic`: Use [LBB interpolation](https://github.com/jcupitt/libvips/blob/master/libvips/resample/lbb.cpp#L100), which prevents some "[acutance](http://en.wikipedia.org/wiki/Acutance)" but typically reduces performance by a factor of 2.
-* `nohalo`: Use [Nohalo interpolation](http://eprints.soton.ac.uk/268086/), which prevents acutance but typically reduces performance by a factor of 3.
-
-[Compare the output of these interpolators](https://github.com/lovell/sharp/tree/master/test/interpolators)
-
-```javascript
-sharp(inputBuffer)
-  .resize(200, 300)
-  .interpolateWith(sharp.interpolator.nohalo)
-  .background('white')
-  .embed()
-  .toFile('output.tiff')
-  .then(function() {
-    // output.tiff is a 200 pixels wide and 300 pixels high image
-    // containing a nohalo scaled version, embedded on a white canvas,
-    // of the image data in inputBuffer
-  });
-```
-
 ### Operations
 
 #### extract({ left: left, top: top, width: width, height: height })
@@ -263,9 +298,15 @@ sharp(input)
   });
 ```
 
+#### trim([tolerance])
+
+Trim "boring" pixels from all edges that contain values within a percentage similarity of the top-left pixel.
+
+* `tolerance`, if present, is an integral Number between 1 and 99 representing the percentage similarity, defaulting to 10.
+
 #### background(rgba)
 
-Set the background for the `embed` and `flatten` operations.
+Set the background for the `embed`, `flatten` and `extend` operations.
 
 `rgba` is parsed by the [color](https://www.npmjs.org/package/color) module to extract values for red, green, blue and alpha.
 
@@ -277,6 +318,25 @@ The default background is `{r: 0, g: 0, b: 0, a: 1}`, black without transparency
 
 Merge alpha transparency channel, if any, with `background`.
 
+#### extend(extension)
+
+Extends/pads the edges of the image with `background`, where `extension` is one of:
+
+* a Number representing the pixel count to add to each edge, or
+* an Object containing `top`, `left`, `bottom` and `right` attributes, each a Number of pixels to add to that edge.
+
+This operation will always occur after resizing and extraction, if any.
+
+```javascript
+// Resize to 140 pixels wide, then add 10 transparent pixels
+// to the top, left and right edges and 20 to the bottom edge
+sharp(input)
+  .resize(140)
+  .background({r: 0, g: 0, b: 0, a: 0})
+  .extend({top: 10, bottom: 20, left: 10, right: 10})
+  ...
+```
+
 #### negate()
 
 Produces the "negative" of the image.  White => Black, Black => White, Blue => Yellow, etc.
@@ -325,23 +385,49 @@ When used without parameters, performs a fast, mild blur of the output image. Th
 
 When a `sigma` is provided, performs a slower, more accurate Gaussian blur. This typically reduces performance by 25%.
 
-* `sigma`, if present, is a Number between 0.3 and 1000 representing the approximate blur radius in pixels.
+* `sigma`, if present, is a Number between 0.3 and 1000 representing the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
 
-#### sharpen([radius], [flat], [jagged])
+#### convolve(kernel)
+
+Convolve the image with the specified `kernel`, an Object with the following attributes:
+
+* `width` is an integral Number representing the width of the kernel in pixels.
+* `height` is an integral Number representing the width of the kernel in pixels.
+* `kernel` is an Array of length `width*height` containing the kernel values.
+* `scale`, if present, is a Number representing the scale of the kernel in pixels, defaulting to the sum of the kernel's values.
+* `offset`, if present, is a Number representing the offset of the kernel in pixels, defaulting to 0.
+
+```javascript
+sharp(input)
+  .convolve({
+    width: 3,
+    height: 3,
+    kernel: [-1, 0, 1, -2, 0, 2, -1, 0, 1]
+  })
+  .raw()
+  .toBuffer(function(err, data, info) {
+    // data contains the raw pixel data representing the convolution
+    // of the input image with the horizontal Sobel operator
+  });
+```
+
+#### sharpen([sigma], [flat], [jagged])
 
 When used without parameters, performs a fast, mild sharpen of the output image. This typically reduces performance by 10%.
 
-When a `radius` is provided, performs a slower, more accurate sharpen of the L channel in the LAB colour space. Separate control over the level of sharpening in "flat" and "jagged" areas is available. This typically reduces performance by 50%.
+When a `sigma` is provided, performs a slower, more accurate sharpen of the L channel in the LAB colour space. Separate control over the level of sharpening in "flat" and "jagged" areas is available. This typically reduces performance by 50%.
 
-* `radius`, if present, is an integral Number representing the sharpen mask radius in pixels.
+* `sigma`, if present, is a Number representing the sigma of the Gaussian mask, where `sigma = 1 + radius / 2`.
 * `flat`, if present, is a Number representing the level of sharpening to apply to "flat" areas, defaulting to a value of 1.0.
 * `jagged`, if present, is a Number representing the level of sharpening to apply to "jagged" areas, defaulting to a value of 2.0.
 
-#### threshold([threshold])
+#### threshold([threshold], [options])
 
-Converts all pixels in the image to greyscale white or black.  Any pixel greather-than-or-equal-to the threshold (0..255) will be white.  All others will be black.
+Any pixel value greather than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
+By default, the image will be converted to single channel greyscale before thresholding.
 
-* `threshold`, if present, is a Number, representing the level above which pixels will be forced to white.
+* `threshold`, if present, is a Number between 0 and 255, representing the level at which the threshold will be applied. The default threshold is 128.
+* `options`, if present, is an Object containing a Boolean `greyscale` (or `grayscale`). When `false` each channel will have the threshold applied independently.
 
 #### gamma([gamma])
 
@@ -365,13 +451,24 @@ The output image will still be web-friendly sRGB and contain three (identical) c
 
 Enhance output image contrast by stretching its luminance to cover the full dynamic range. This typically reduces performance by 30%.
 
-#### overlayWith(path)
+#### overlayWith(image, [options])
 
-_Experimental_
+Overlay (composite) a image containing an alpha channel over the processed (resized, extracted etc.) image.
 
-Alpha composite image at `path` over the processed (resized, extracted) image. The dimensions of the two images must match.
+`image` is one of the following, and must be the same size or smaller than the processed image:
 
-* `path` is a String containing the path to an image file with an alpha channel.
+* Buffer containing PNG, WebP, GIF or SVG image data, or
+* String containing the path to an image file, with most major transparency formats supported.
+
+`options`, if present, is an Object with the following optional attributes:
+
+* `gravity` is a String or an attribute of the `sharp.gravity` Object e.g. `sharp.gravity.north` at which to place the overlay, defaulting to `center`/`centre`.
+* `top` is an integral Number representing the pixel offset from the top edge.
+* `left` is an integral Number representing the pixel offset from the left edge.
+* `tile` is a Boolean, defaulting to `false`. When set to `true` repeats the overlay image across the entire image with the given `gravity`.
+* `cutout` is a Boolean, defaulting to `false`. When set to `true` applies only the alpha channel of the overlay image to the image to be overlaid, giving the appearance of one image being cut out of another.
+
+If both `top` and `left` are provided, they take precedence over `gravity`.
 
 ```javascript
 sharp('input.png')
@@ -379,7 +476,7 @@ sharp('input.png')
   .resize(300)
   .flatten()
   .background('#ff6600')
-  .overlayWith('overlay.png')
+  .overlayWith('overlay.png', { gravity: sharp.gravity.southeast } )
   .sharpen()
   .withMetadata()
   .quality(90)
@@ -387,18 +484,66 @@ sharp('input.png')
   .toBuffer()
   .then(function(outputBuffer) {
     // outputBuffer contains upside down, 300px wide, alpha channel flattened
-    // onto orange background, composited with overlay.png, sharpened,
+    // onto orange background, composited with overlay.png with SE gravity,
-    // with metadata, 90% quality WebP image data. Phew!
+    // sharpened, with metadata, 90% quality WebP image data. Phew!
   });
 ```
 
+#### extractChannel(channel)
+
+Extract a single channel from a multi-channel image.
+
+* `channel` is a zero-indexed integral Number representing the band number to extract. `red`, `green` or `blue` are also accepted as an alternative to `0`, `1` or `2` respectively.
+
+```javascript
+sharp(input)
+  .extractChannel('green')
+  .toFile('input_green.jpg', function(err, info) {
+    // info.channels === 1
+    // input_green.jpg contains the green channel of the input image
+   });
+```
+
+#### bandbool(operation)
+
+Perform a bitwise boolean operation on all input image channels (bands) to produce a single channel output image.
+
+`operation` is a string containing the name of the bitwise operator to be appled to image channels, which can be one of:
+
+* `and` performs a bitwise and operation, like the c-operator `&`.
+* `or` performs a bitwise or operation, like the c-operator `|`.
+* `eor` performs a bitwise exclusive or operation, like the c-operator `^`.
+
+```javascript
+sharp('input.png')
+  .bandbool(sharp.bool.and)
+  .toFile('output.png')
+```
+
+In the above example if `input.png` is a 3 channel RGB image, `output.png` will be a 1 channel grayscale image where each pixel `P = R & G & B`.
+For example, if `I(1,1) = [247, 170, 14] = [0b11110111, 0b10101010, 0b00001111]` then `O(1,1) = 0b11110111 & 0b10101010 & 0b00001111 = 0b00000010 = 2`.
+
+#### boolean(image, operation)
+
+Perform a bitwise boolean operation with `image`, where `image` is one of the following:
+
+* Buffer containing PNG, WebP, GIF or SVG image data, or
+* String containing the path to an image file
+
+This operation creates an output image where each pixel is the result of the selected bitwise boolean `operation` between the corresponding pixels of the input images.
+The boolean operation can be one of the following:
+
+* `and` performs a bitwise and operation, like the c-operator `&`.
+* `or` performs a bitwise or operation, like the c-operator `|`.
+* `eor` performs a bitwise exclusive or operation, like the c-operator `^`.
+
 ### Output
 
 #### toFile(path, [callback])
 
 `path` is a String containing the path to write the image data to.
 
-If an explicit output format is not selected, it will be inferred from the extension, with JPEG, PNG, WebP, TIFF and DZI supported.
+If an explicit output format is not selected, it will be inferred from the extension, with JPEG, PNG, WebP, TIFF, DZI, and VIPS V format supported. Note that RAW format is only supported for buffer output.
 
 `callback`, if present, is called with two arguments `(err, info)` where:
 
@@ -409,7 +554,7 @@ A Promises/A+ promise is returned when `callback` is not provided.
 
 #### toBuffer([callback])
 
-Write image data to a Buffer, the format of which will match the input image by default. JPEG, PNG and WebP are supported.
+Write image data to a Buffer, the format of which will match the input image by default. JPEG, PNG, WebP, and RAW are supported.
 
 `callback`, if present, gets three arguments `(err, buffer, info)` where:
 
@@ -466,22 +611,32 @@ This will also convert to and add the latest web-friendly v2 sRGB ICC profile.
 The optional `metadata` parameter, if present, is an Object with the attributes to update.
 New attributes cannot be inserted, only existing attributes updated.
 
-* `orientation` is an integral Number between 0 and 7, used to update the value of the EXIF `Orientation` tag.
+* `orientation` is an integral Number between 1 and 8, used to update the value of the EXIF `Orientation` tag.
 This has no effect if the input image does not have an EXIF `Orientation` tag.
 
 The default behaviour, when `withMetadata` is not used, is to strip all metadata and convert to the device-independent sRGB colour space.
 
-#### tile([size], [overlap])
+#### tile(options)
 
-The size and overlap, in pixels, of square Deep Zoom image pyramid tiles.
+The size, overlap, container and directory layout to use when generating square Deep Zoom image pyramid tiles.
+
+`options` is an Object with one or more of the following attributes:
 
 * `size` is an integral Number between 1 and 8192. The default value is 256 pixels.
 * `overlap` is an integral Number between 0 and 8192. The default value is 0 pixels.
+* `container` is a String, with value `fs` or `zip`. The default value is `fs`.
+* `layout` is a String, with value `dz`, `zoomify` or `google`. The default value is `dz`.
+
+You can also use the file extension `.zip` or `.szi` to write to a compressed archive file format.
 
 ```javascript
-sharp('input.tiff').tile(256).toFile('output.dzi', function(err, info) {
+sharp('input.tiff')
-  // The output.dzi file is the XML format Deep Zoom definition
+  .tile({
-  // The output_files directory contains 256x256 pixel tiles grouped by zoom level
+    size: 512
+  })
+  .toFile('output.dzi', function(err, info) {
+    // output.dzi is the Deep Zoom XML definition
+    // output_files contains 512x512 tiles grouped by zoom level
   });
 ```
 
@@ -551,9 +706,6 @@ for example:
   tiff: { id: 'tiff',
     input: { file: true, buffer: true, stream: true },
     output: { file: true, buffer: false, stream: false } },
-  magick: { id: 'magick',
-    input: { file: true, buffer: true, stream: true },
-    output: { file: false, buffer: false, stream: false } },
   raw: { id: 'raw',
     input: { file: false, buffer: false, stream: false },
     output: { file: false, buffer: true, stream: true } } }
@@ -577,22 +729,7 @@ sharp.queue.on('change', function(queueLength) {
 An Object containing the version numbers of libvips and, on Linux, its dependencies.
 
 ```javascript
-> console.log(sharp.versions);
+console.log(sharp.versions);
-
-{ zlib: '1.2.8',
-  ffi: '3.2.1',
-  glib: '2.46.2',
-  xml: '2.9.2',
-  gsf: '1.14.34',
-  exif: '0.6.21',
-  jpeg: '1.4.2',
-  png: '1.6.19',
-  lcms: '2.7',
-  webp: '0.4.4',
-  tiff: '4.0.6',
-  magick: '6.9.2-6',
-  orc: '0.4.24',
-  vips: '8.1.1' }
 ```
 
 ### Utilities
@@ -607,6 +744,8 @@ If `options` is provided, sets the limits of _libvips'_ operation cache.
 
 `options` can also be a boolean, where `true` enables the default cache settings and `false` disables all caching.
 
+Existing entries in the cache will be trimmed after any change in limits.
+
 This method always returns cache statistics, useful for determining how much working memory is required for a particular task.
 
 ```javascript

docs/changelog.md

@@ -1,7 +1,168 @@
 # Changelog
 
+### v0.15 - "*outfit*"
+
+Requires libvips v8.3.1
+
+#### v0.15.1 - 12<sup>th</sup> July 2016
+
+* Concat Stream-based input in single operation for ~+3% perf and less GC.
+  [#429](https://github.com/lovell/sharp/issues/429)
+  [@papandreou](https://github.com/papandreou)
+
+* Add alpha channel, if required, before extend operation.
+  [#439](https://github.com/lovell/sharp/pull/439)
+  [@frulo](https://github.com/frulo)
+
+* Allow overlay image to be repeated across entire image via tile option.
+  [#443](https://github.com/lovell/sharp/pull/443)
+  [@lemnisk8](https://github.com/lemnisk8)
+
+* Add cutout option to overlayWith feature, applies only the alpha channel of the overlay image.
+  [#448](https://github.com/lovell/sharp/pull/448)
+  [@kleisauke](https://github.com/kleisauke)
+
+* Ensure scaling factors are calculated independently to prevent rounding errors.
+  [#452](https://github.com/lovell/sharp/issues/452)
+  [@puzrin](https://github.com/puzrin)
+
+* Add --sharp-cxx11 flag to compile with gcc's new C++11 ABI.
+  [#456](https://github.com/lovell/sharp/pull/456)
+  [@kapouer](https://github.com/kapouer)
+
+* Add top/left offset support to overlayWith operation.
+  [#473](https://github.com/lovell/sharp/pull/473)
+  [@rnanwani](https://github.com/rnanwani)
+
+* Add convolve operation for kernel-based convolution.
+  [#479](https://github.com/lovell/sharp/pull/479)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add greyscale option to threshold operation for colourspace conversion control.
+  [#480](https://github.com/lovell/sharp/pull/480)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Ensure ICC profiles are licenced for distribution.
+  [#486](https://github.com/lovell/sharp/issues/486)
+  [@kapouer](https://github.com/kapouer)
+
+* Allow images with an alpha channel to work with LAB-colourspace based sharpen.
+  [#490](https://github.com/lovell/sharp/issues/490)
+  [@jwagner](https://github.com/jwagner)
+
+* Add trim operation to remove "boring" edges.
+  [#492](https://github.com/lovell/sharp/pull/492)
+  [@kleisauke](https://github.com/kleisauke)
+
+* Add bandbool feature for channel-wise boolean operations.
+  [#496](https://github.com/lovell/sharp/pull/496)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add extractChannel operation to extract a channel from an image.
+  [#497](https://github.com/lovell/sharp/pull/497)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add ability to read and write native libvips .v files.
+  [#500](https://github.com/lovell/sharp/pull/500)
+  [@mhirsch](https://github.com/mhirsch)
+
+* Add boolean feature for bitwise image operations.
+  [#501](https://github.com/lovell/sharp/pull/501)
+  [@mhirsch](https://github.com/mhirsch)
+
+#### v0.15.0 - 21<sup>st</sup> May 2016
+
+* Use libvips' new Lanczos 3 kernel as default for image reduction.
+  Deprecate interpolateWith method, now provided as a resize option.
+  [#310](https://github.com/lovell/sharp/issues/310)
+  [@jcupitt](https://github.com/jcupitt)
+
+* Take advantage of libvips v8.3 features.
+  Add support for libvips' new GIF and SVG loaders.
+  Pre-built binaries now include giflib and librsvg, exclude *magick.
+  Use shrink-on-load for WebP input.
+  Break existing sharpen API to accept sigma and improve precision.
+  [#369](https://github.com/lovell/sharp/issues/369)
+
+* Remove unnecessary (un)premultiply operations when not resizing/compositing.
+  [#413](https://github.com/lovell/sharp/issues/413)
+  [@jardakotesovec](https://github.com/jardakotesovec)
+
+### v0.14 - "*needle*"
+
+Requires libvips v8.2.3
+
+#### v0.14.1 - 16<sup>th</sup> April 2016
+
+* Allow removal of limitation on input pixel count via limitInputPixels. Use with care.
+  [#250](https://github.com/lovell/sharp/issues/250)
+  [#316](https://github.com/lovell/sharp/pull/316)
+  [@anandthakker](https://github.com/anandthakker)
+  [@kentongray](https://github.com/kentongray)
+
+* Use final output image for metadata passed to callback.
+  [#399](https://github.com/lovell/sharp/pull/399)
+  [@salzhrani](https://github.com/salzhrani)
+
+* Add support for writing tiled images to a zip container.
+  [#402](https://github.com/lovell/sharp/pull/402)
+  [@felixbuenemann](https://github.com/felixbuenemann)
+
+* Allow use of embed with 1 and 2 channel images.
+  [#411](https://github.com/lovell/sharp/issues/411)
+  [@janaz](https://github.com/janaz)
+
+* Improve Electron compatibility by allowing node-gyp rebuilds without npm.
+  [#412](https://github.com/lovell/sharp/issues/412)
+  [@nouh](https://github.com/nouh)
+
+#### v0.14.0 - 2<sup>nd</sup> April 2016
+
+* Add ability to extend (pad) the edges of an image.
+  [#128](https://github.com/lovell/sharp/issues/128)
+  [@blowsie](https://github.com/blowsie)
+
+* Add support for Zoomify and Google tile layouts. Breaks existing tile API.
+  [#223](https://github.com/lovell/sharp/issues/223)
+  [@bdunnette](https://github.com/bdunnette)
+
+* Improvements to overlayWith: differing sizes/formats, gravity, buffer input.
+  [#239](https://github.com/lovell/sharp/issues/239)
+  [@chrisriley](https://github.com/chrisriley)
+
+* Add entropy-based crop strategy to remove least interesting edges.
+  [#295](https://github.com/lovell/sharp/issues/295)
+  [@rightaway](https://github.com/rightaway)
+
+* Expose density metadata; set density of images from vector input.
+  [#338](https://github.com/lovell/sharp/issues/338)
+  [@lookfirst](https://github.com/lookfirst)
+
+* Emit post-processing 'info' event for Stream output.
+  [#367](https://github.com/lovell/sharp/issues/367)
+  [@salzhrani](https://github.com/salzhrani)
+
+* Ensure output image EXIF Orientation values are within 1-8 range.
+  [#385](https://github.com/lovell/sharp/pull/385)
+  [@jtobinisaniceguy](https://github.com/jtobinisaniceguy)
+
+* Ensure ratios are not swapped when rotating 90/270 and ignoring aspect.
+  [#387](https://github.com/lovell/sharp/issues/387)
+  [@kleisauke](https://github.com/kleisauke)
+
+* Remove deprecated style of calling extract API. Breaks calls using positional arguments.
+  [#276](https://github.com/lovell/sharp/issues/276)
+
 ### v0.13 - "*mind*"
 
+Requires libvips v8.2.2
+
+#### v0.13.1 - 27<sup>th</sup> February 2016
+
+* Fix embedding onto transparent backgrounds; regression introduced in v0.13.0.
+  [#366](https://github.com/lovell/sharp/issues/366)
+  [@diegocsandrim](https://github.com/diegocsandrim)
+
 #### v0.13.0 - 15<sup>th</sup> February 2016
 
 * Improve vector image support by allowing control of density/DPI.
@@ -49,6 +210,8 @@
 
 ### v0.12 - "*look*"
 
+Requires libvips v8.2.0
+
 #### v0.12.2 - 16<sup>th</sup> January 2016
 
 * Upgrade libvips to v8.2.0 for improved vips_shrink.

docs/index.md

@@ -1,14 +1,14 @@
 # sharp
 
 The typical use case for this high speed Node.js module
-is to convert large images of many formats to
+is to convert large images in common formats to
 smaller, web-friendly JPEG, PNG and WebP images of varying dimensions.
 
-Resizing an image is typically 4x faster than using the
+Resizing an image is typically 4x-5x faster than using the
 quickest ImageMagick and GraphicsMagick settings.
 
 Colour spaces, embedded ICC profiles and alpha transparency channels are all handled correctly.
-Bicubic interpolation with Lanczos anti-alias filtering ensures quality is not sacrificed for speed.
+Lanczos resampling ensures quality is not sacrificed for speed.
 
 As well as image resizing, operations such as
 rotation, extraction, compositing and gamma correction are available.
@@ -23,8 +23,7 @@ to install the libvips dependency.
 
 ### Formats
 
-This module supports reading JPEG, PNG, WebP, TIFF, OpenSlide,
+This module supports reading JPEG, PNG, WebP, TIFF, GIF and SVG images.
-GIF and most other libmagick-supported formats.
 
 Output images can be in JPEG, PNG and WebP formats as well as uncompressed raw pixel data.
 
@@ -89,12 +88,21 @@ the help and code contributions of the following people:
 * [Alaric Holloway](https://github.com/skedastik)
 * [Bernhard K. Weisshuhn](https://github.com/bkw)
 * [David A. Carley](https://github.com/dacarley)
+* [John Tobin](https://github.com/jtobinisaniceguy)
+* [Kenton Gray](https://github.com/kentongray)
+* [Felix Bünemann](https://github.com/felixbuenemann)
+* [Samy Al Zahrani](https://github.com/salzhrani)
+* [Chintan Thakkar](https://github.com/lemnisk8)
+* [F. Orlando Galashan](https://github.com/frulo)
+* [Kleis Auke Wolthuizen](https://github.com/kleisauke)
+* [Matt Hirsch](https://github.com/mhirsch)
+* [Rahul Nanwani](https://github.com/rnanwani)
 
 Thank you!
 
 ### Licence
 
-Copyright 2013, 2014, 2015 Lovell Fuller and contributors.
+Copyright 2013, 2014, 2015, 2016 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.

docs/install.md

@@ -6,7 +6,7 @@ npm install sharp
 
 ### Prerequisites
 
-* C++11 compatible compiler such as gcc 4.6+ (Node v4+ requires gcc 4.8+), clang 3.0+ or MSVC 2013
+* C++11 compatible compiler such as gcc 4.8+, clang 3.0+ or MSVC 2013+
 * [node-gyp](https://github.com/TooTallNate/node-gyp#installation)
 
 ### Linux
@@ -14,30 +14,47 @@ npm install sharp
 [![Ubuntu 14.04 Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
 [![Linux Build Status](https://circleci.com/gh/lovell/sharp.svg?style=svg&circle-token=6cb6d1d287a51af83722b19ed8885377fbc85e5c)](https://circleci.com/gh/lovell/sharp)
 
-libvips and its dependencies are fetched and stored within `node_modules/sharp` during `npm install`.
+libvips and its dependencies are fetched and stored within `node_modules/sharp/lib` during `npm install`.
-This involves an automated HTTPS download of approximately 6MB.
+This involves an automated HTTPS download of approximately 6.7MB.
 
 Most recent Linux-based operating systems with glibc running on x64 and ARMv6+ CPUs should "just work", e.g.:
 
 * Debian 7, 8
-* Ubuntu 12.04, 14.04, 14.10, 15.04, 15.10
+* Ubuntu 12.04, 14.04, 15.10, 16.04
 * Centos 7
-* Fedora 21, 22, 23
+* Fedora 22, 23
 * openSUSE 13.2
 * Archlinux 2015.06.01
 * Raspbian Jessie
+* Amazon Linux 2015.03, 2015.09
+
+To use your own version of libvips instead of the provided binaries, make sure it is
+at least the version listed under `config.libvips` in the `package.json` file,
+that it can be located using `pkg-config --modversion vips-cpp`.
+
+There are [changes in the C++11 ABI](https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_dual_abi.html)
+when using v5.1+ of the `g++` compiler.
+If you have installed `libvips-dev` via package manager on an OS such as Debian testing/unstable,
+you can pass the required value of the `_GLIBCXX_USE_CXX11_ABI` macro using the `--sharp-cxx11` flag.
+
+```sh
+npm install --sharp-cxx11=1
+```
+
+If you are using non-stadard paths (anything other than `/usr` or `/usr/local`),
+you might need to set `PKG_CONFIG_PATH` during `npm install`
+and `LD_LIBRARY_PATH` at runtime.
 
-Preference will be given to an existing globally-installed (via `pkg-config`)
-version of libvips that meets the minimum version requirement.
 This allows the use of newer versions of libvips with older versions of sharp.
 
-For older Linux-based operating systems and 32-bit Intel CPUs,
+For 32-bit Intel CPUs and older Linux-based operating systems such as Centos 6,
 a system-wide installation of the most suitable version of
 libvips and its dependencies can be achieved by running
 the following command as a user with `sudo` access
 (requires `curl` and `pkg-config`):
 
 ```sh
+# WARNING: This script is deprecated. You probably don't need to run it. Please read above.
 curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | sudo bash -
 ```
 
@@ -47,7 +64,7 @@ via `sharp.cache(false)` to avoid a stack overflow.
 
 ### Mac OS
 
-[![OS X 10.9.5 Build Status](https://travis-ci.org/lovell/sharp-osx-ci.png?branch=master)](https://travis-ci.org/lovell/sharp-osx-ci)
+[![OS X 10.9.5 Build Status](https://travis-ci.org/lovell/sharp.png?branch=master)](https://travis-ci.org/lovell/sharp)
 
 libvips must be installed before `npm install` is run.
 This can be achieved via homebrew:
@@ -56,10 +73,10 @@ This can be achieved via homebrew:
 brew install homebrew/science/vips
 ```
 
-For GIF input and WebP output suppport use:
+For WebP suppport use:
 
 ```sh
-brew install homebrew/science/vips --with-imagemagick --with-webp
+brew install homebrew/science/vips --with-webp
 ```
 
 A missing or incorrectly configured _Xcode Command Line Tools_ installation
@@ -80,7 +97,6 @@ libvips and its dependencies are fetched and stored within `node_modules\sharp`
 This involves an automated HTTPS download of approximately 9MB.
 
 Only 64-bit (x64) `node.exe` is supported.
-The WebP format is currently unavailable on Windows.
 
 ### FreeBSD
 
@@ -113,7 +129,113 @@ docker pull marcbachmann/libvips
 docker pull wjordan/libvips
 ```
 
+### AWS Lambda
+
+In order to use sharp on AWS Lambda, you need to [create a deployment package](http://docs.aws.amazon.com/lambda/latest/dg/nodejs-create-deployment-pkg.html). Because sharp
+downloads and links libraries for the current platform during `npm install` you have to
+do this on a system similar to the [Lambda Execution Environment](http://docs.aws.amazon.com/lambda/latest/dg/current-supported-versions.html). The easiest ways to do this, is to setup a
+small t2.micro instance using the AMI ID listed in the previous link, ssh into it as ec2-user
+and follow the instructions below.
+
+Install dependencies:
+
+```sh
+curl -s https://rpm.nodesource.com/setup_4.x | sudo bash -
+sudo yum install -y gcc-c++ nodejs
+```
+
+Copy your code and package.json to the instance using `scp` and create a deployment package:
+
+```sh
+cd sharp-lambda-example
+npm install
+zip -ur9 ../sharp-lambda-example.zip index.js node_modules
+```
+
+You can now download your deployment ZIP using `scp` and upload it to Lambda. Be sure to set your Lambda runtime to Node.js 4.3.
+
+**Performance Tip:** To get the best performance on Lambda choose the largest memory available because this also gives you the most cpu time (a 1536 MB function is 12x faster than a 128 MB function).
+
 ### Build tools
 
 * [gulp-responsive](https://www.npmjs.com/package/gulp-responsive)
 * [grunt-sharp](https://www.npmjs.com/package/grunt-sharp)
+
+### Security
+
+Many users of this module process untrusted, user-supplied images,
+but there are aspects of security to consider when doing so.
+
+It is possible to compile libvips with support for various third-party image loaders.
+Each of these libraries has undergone differing levels of security testing.
+
+Whilst tools such as [American Fuzzy Lop](http://lcamtuf.coredump.cx/afl/)
+and [Valgrind](http://valgrind.org/) have been used to test
+the most popular web-based formats, as well as libvips itself,
+you are advised to perform your own testing and sandboxing.
+
+ImageMagick in particular has a relatively large attack surface,
+which can be partially mitigated with a
+[policy.xml](http://www.imagemagick.org/script/resources.php)
+configuration file to prevent the use of coders known to be vulnerable.
+
+```xml
+<policymap>
+  <policy domain="coder" rights="none" pattern="EPHEMERAL" />
+  <policy domain="coder" rights="none" pattern="URL" />
+  <policy domain="coder" rights="none" pattern="HTTPS" />
+  <policy domain="coder" rights="none" pattern="MVG" />
+  <policy domain="coder" rights="none" pattern="MSL" />
+  <policy domain="coder" rights="none" pattern="TEXT" />
+  <policy domain="coder" rights="none" pattern="SHOW" />
+  <policy domain="coder" rights="none" pattern="WIN" />
+  <policy domain="coder" rights="none" pattern="PLT" />
+</policymap>
+```
+
+Set the `MAGICK_CONFIGURE_PATH` environment variable
+to the directory containing the `policy.xml` file.
+
+### Licences
+
+If a global installation of libvips that meets the
+minimum version requirement cannot be found,
+this module will download a pre-compiled bundle of libvips
+and its dependencies on Linux and Windows machines.
+
+Should you need to manually download and inspect these files,
+you can do so via https://dl.bintray.com/lovell/sharp/
+
+This module is licensed under the terms of the
+[Apache 2.0 Licence](https://github.com/lovell/sharp/blob/master/LICENSE).
+
+The libraries downloaded and used by this module
+are done so under the terms of the following licences,
+all of which are compatible with the Apache 2.0 Licence.
+
+Use of libraries under the terms of the LGPLv3 is via the
+"any later version" clause of the LGPLv2 or LGPLv2.1.
+
+| Library       | Used under the terms of                                                                                  |
+|---------------|----------------------------------------------------------------------------------------------------------|
+| cairo         | Mozilla Public License 2.0                                                                               |
+| fontconfig    | [fontconfig Licence](https://cgit.freedesktop.org/fontconfig/tree/COPYING) (BSD-like)                    |
+| freetype      | [freetype Licence](http://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/docs/FTL.TXT) (BSD-like) |
+| giflib        | MIT Licence                                                                                              |
+| glib          | LGPLv3                                                                                                   |
+| harfbuzz      | MIT Licence                                                                                              |
+| lcms          | MIT Licence                                                                                              |
+| libcroco      | LGPLv3                                                                                                   |
+| libexif       | LGPLv3                                                                                                   |
+| libffi        | MIT Licence                                                                                              |
+| libgsf        | LGPLv3                                                                                                   |
+| libjpeg-turbo | [zlib License, IJG License](https://github.com/libjpeg-turbo/libjpeg-turbo/blob/master/LICENSE.md)       |
+| libpng        | [libpng License](http://www.libpng.org/pub/png/src/libpng-LICENSE.txt)                                   |
+| librsvg       | LGPLv3                                                                                                   |
+| libtiff       | [libtiff License](http://www.libtiff.org/misc.html) (BSD-like)                                           |
+| libvips       | LGPLv3                                                                                                   |
+| libwebp       | New BSD License                                                                                          |
+| libxml2       | MIT Licence                                                                                              |
+| pango         | LGPLv3                                                                                                   |
+| pixman        | MIT Licence                                                                                              |
+| zlib          | [zlib Licence](https://github.com/madler/zlib/blob/master/zlib.h)                                        |

docs/performance.md

@@ -3,41 +3,44 @@
 ### Test environment
 
 * AWS EC2 [c4.xlarge](http://aws.amazon.com/ec2/instance-types/#c4) (4x E5-2666 v3 @ 2.90GHz)
-* Amazon Linux 2015.09.1
+* Amazon Linux AMI 2016.03.1 (HVM), SSD Volume Type
-* Node.js v5.5.0
+* Node.js v6.2.0
 
 ### The contenders
 
-* [jimp](https://www.npmjs.com/package/jimp) v0.2.20 - Image processing in pure JavaScript. Bilinear interpolation only.
+* [jimp](https://www.npmjs.com/package/jimp) v0.2.24 - Image processing in pure JavaScript. Bilinear interpolation only.
-* [lwip](https://www.npmjs.com/package/lwip) v0.0.8 - Wrapper around CImg, compiles dependencies from source.
+* [lwip](https://www.npmjs.com/package/lwip) v0.0.9 - Wrapper around CImg, compiles dependencies from source.
-* [imagemagick-native](https://www.npmjs.com/package/imagemagick-native) @47c7329 - Wrapper around libmagick++, supports Buffers only.
+* [imagemagick-native](https://www.npmjs.com/package/imagemagick-native) v1.9.2 - Wrapper around libmagick++, supports Buffers only.
 * [imagemagick](https://www.npmjs.com/package/imagemagick) v0.1.3 - Supports filesystem only and "*has been unmaintained for a long time*".
-* [gm](https://www.npmjs.com/package/gm) v1.21.0 - Fully featured wrapper around GraphicsMagick's `gm` command line utility.
+* [gm](https://www.npmjs.com/package/gm) v1.22.0 - Fully featured wrapper around GraphicsMagick's `gm` command line utility.
-* sharp v0.13.0 / libvips v8.2.2 - Caching within libvips disabled to ensure a fair comparison.
+* sharp v0.15.0 / libvips v8.3.1 - Caching within libvips disabled to ensure a fair comparison.
 
 ### The task
 
-Decompress a 2725x2225 JPEG image, resize to 720x480 using bicubic interpolation (where available), then compress to JPEG.
+Decompress a 2725x2225 JPEG image,
+resize to 720x480 using Lanczos 3 resampling (where available),
+then compress to JPEG.
 
 ### Results
 
 | Module             | Input  | Output | Ops/sec | Speed-up |
 | :----------------- | :----- | :----- | ------: | -------: |
-| jimp (bilinear)    | file   | file   |    1.04 |      1.0 |
+| jimp (bilinear)    | file   | file   |    0.94 |      1.0 |
-| jimp (bilinear)    | buffer | buffer |    1.07 |      1.0 |
+| jimp (bilinear)    | buffer | buffer |    0.98 |      1.0 |
-| lwip               | file   | file   |    1.13 |      1.1 |
+| lwip               | file   | file   |    1.14 |      1.2 |
-| lwip               | buffer | buffer |    1.13 |      1.1 |
+| lwip               | buffer | buffer |    1.14 |      1.2 |
-| imagemagick-native | buffer | buffer |    1.65 |      1.6 |
+| imagemagick-native | buffer | buffer |    1.66 |      1.8 |
-| imagemagick        | file   | file   |    5.02 |      4.8 |
+| imagemagick        | file   | file   |    5.08 |      5.4 |
-| gm                 | buffer | buffer |    5.36 |      5.2 |
+| gm                 | buffer | buffer |    5.43 |      5.7 |
-| gm                 | file   | file   |    5.39 |      5.2 |
+| gm                 | file   | file   |    5.46 |      5.8 |
-| sharp              | stream | stream |   22.00 |     21.2 |
+| sharp              | stream | stream |   26.52 |     28.2 |
-| sharp              | file   | file   |   22.87 |     22.0 |
+| sharp              | file   | file   |   28.16 |     30.0 |
-| sharp              | file   | buffer |   23.03 |     22.1 |
+| sharp              | file   | buffer |   28.27 |     30.1 |
-| sharp              | buffer | file   |   23.10 |     22.2 |
+| sharp              | buffer | file   |   28.42 |     30.2 |
-| sharp              | buffer | buffer |   23.21 |     22.3 |
+| sharp              | buffer | buffer |   28.42 |     30.2 |
 
-Greater performance can be expected with caching enabled (default) and using 8+ core machines.
+Greater libvips performance can be expected with caching enabled (default)
+and using 8+ core machines, especially those with larger L1/L2 CPU caches.
 
 The I/O limits of the relevant (de)compression library will generally determine maximum throughput.
 

index.js

@@ -42,11 +42,11 @@ var Sharp = function(input, options) {
   stream.Duplex.call(this);
   this.options = {
     // input options
-    bufferIn: null,
+    bufferIn: [],
     streamIn: false,
     sequentialRead: false,
     limitInputPixels: maximum.pixels,
-    density: '72',
+    density: 72,
     rawWidth: 0,
     rawHeight: 0,
     rawChannels: 0,
@@ -64,27 +64,44 @@ var Sharp = function(input, options) {
     width: -1,
     height: -1,
     canvas: 'crop',
-    gravity: 0,
+    crop: 0,
     angle: 0,
     rotateBeforePreExtract: false,
     flip: false,
     flop: false,
+    extendTop: 0,
+    extendBottom: 0,
+    extendLeft: 0,
+    extendRight: 0,
     withoutEnlargement: false,
+    kernel: 'lanczos3',
     interpolator: 'bicubic',
     // operations
     background: [0, 0, 0, 255],
     flatten: false,
     negate: false,
     blurSigma: 0,
-    sharpenRadius: 0,
+    sharpenSigma: 0,
     sharpenFlat: 1,
     sharpenJagged: 2,
     threshold: 0,
+    thresholdGrayscale: true,
+    trimTolerance: 0,
     gamma: 0,
     greyscale: false,
     normalize: 0,
+    bandBoolOp: null,
+    booleanOp: null,
+    booleanBufferIn: null,
+    booleanFileIn: '',
     // overlay
-    overlayPath: '',
+    overlayFileIn: '',
+    overlayBufferIn: null,
+    overlayGravity: 0,
+    overlayXOffset : -1,
+    overlayYOffset : -1,
+    overlayTile: false,
+    overlayCutout: false,
     // output options
     formatOut: 'input',
     fileOut: '',
@@ -101,18 +118,19 @@ var Sharp = function(input, options) {
     withMetadataOrientation: -1,
     tileSize: 256,
     tileOverlap: 0,
+    extractChannel: -1,
     // Function to notify of queue length changes
     queueListener: function(queueLength) {
       module.exports.queue.emit('change', queueLength);
     }
   };
-  if (typeof input === 'string') {
+  if (isString(input)) {
     // input=file
     this.options.fileIn = input;
-  } else if (typeof input === 'object' && input instanceof Buffer) {
+  } else if (isBuffer(input)) {
     // input=buffer
     this.options.bufferIn = input;
-  } else if (typeof input === 'undefined' || input === null) {
+  } else if (!isDefined(input)) {
     // input=stream
     this.options.streamIn = true;
   } else {
@@ -148,12 +166,27 @@ var isDefined = function(val) {
 var isObject = function(val) {
   return typeof val === 'object';
 };
+var isBoolean = function(val) {
+  return typeof val === 'boolean';
+};
+var isBuffer = function(val) {
+  return typeof val === 'object' && val instanceof Buffer;
+};
+var isString = function(val) {
+  return typeof val === 'string' && val.length > 0;
+};
+var isNumber = function(val) {
+  return typeof val === 'number' && !Number.isNaN(val);
+};
 var isInteger = function(val) {
-  return typeof val === 'number' && !Number.isNaN(val) && val % 1 === 0;
+  return isNumber(val) && val % 1 === 0;
 };
 var inRange = function(val, min, max) {
   return val >= min && val <= max;
 };
+var contains = function(val, list) {
+  return list.indexOf(val) !== -1;
+};
 
 /*
   Set input-related options
@@ -164,7 +197,7 @@ Sharp.prototype._inputOptions = function(options) {
     // Density
     if (isDefined(options.density)) {
       if (isInteger(options.density) && inRange(options.density, 1, 2400)) {
-        this.options.density = options.density.toString();
+        this.options.density = options.density;
       } else {
         throw new Error('Invalid density (1 to 2400) ' + options.density);
       }
@@ -195,18 +228,8 @@ Sharp.prototype._inputOptions = function(options) {
 Sharp.prototype._write = function(chunk, encoding, callback) {
   /*jslint unused: false */
   if (this.options.streamIn) {
-    if (typeof chunk === 'object' && chunk instanceof Buffer) {
+    if (isBuffer(chunk)) {
-      if (this.options.bufferIn instanceof Buffer) {
+      this.options.bufferIn.push(chunk);
-        // Append to existing Buffer
-        this.options.bufferIn = Buffer.concat(
-          [this.options.bufferIn, chunk],
-          this.options.bufferIn.length + chunk.length
-        );
-      } else {
-        // Create new Buffer
-        this.options.bufferIn = new Buffer(chunk.length);
-        chunk.copy(this.options.bufferIn);
-      }
       callback();
     } else {
       callback(new Error('Non-Buffer data on Writable Stream'));
@@ -216,48 +239,62 @@ Sharp.prototype._write = function(chunk, encoding, callback) {
   }
 };
 
-// Crop this part of the resized image (Center/Centre, North, East, South, West)
+/*
-module.exports.gravity = {
+  Flattens the array of chunks in bufferIn
-  'center': 0,
+*/
-  'centre': 0,
+Sharp.prototype._flattenBufferIn = function() {
-  'north': 1,
+  if (Array.isArray(this.options.bufferIn)) {
-  'east': 2,
+    this.options.bufferIn = Buffer.concat(this.options.bufferIn);
-  'south': 3,
+  }
-  'west': 4,
-  'northeast': 5,
-  'southeast': 6,
-  'southwest': 7,
-  'northwest': 8
 };
 
-Sharp.prototype.crop = function(gravity) {
+// Weighting to apply to image crop
+module.exports.gravity = {
+  center: 0,
+  centre: 0,
+  north: 1,
+  east: 2,
+  south: 3,
+  west: 4,
+  northeast: 5,
+  southeast: 6,
+  southwest: 7,
+  northwest: 8
+};
+
+// Strategies for automagic behaviour
+module.exports.strategy = {
+  entropy: 16
+};
+
+/*
+  What part of the image should be retained when cropping?
+*/
+Sharp.prototype.crop = function(crop) {
   this.options.canvas = 'crop';
-  if (typeof gravity === 'undefined') {
+  if (!isDefined(crop)) {
-    this.options.gravity = module.exports.gravity.center;
+    // Default
-  } else if (typeof gravity === 'number' && !Number.isNaN(gravity) && gravity >= 0 && gravity <= 8) {
+    this.options.crop = module.exports.gravity.center;
-    this.options.gravity = gravity;
+  } else if (isInteger(crop) && inRange(crop, 0, 8)) {
-  } else if (typeof gravity === 'string' && typeof module.exports.gravity[gravity] === 'number') {
+    // Gravity (numeric)
-    this.options.gravity = module.exports.gravity[gravity];
+    this.options.crop = crop;
+  } else if (isString(crop) && isInteger(module.exports.gravity[crop])) {
+    // Gravity (string)
+    this.options.crop = module.exports.gravity[crop];
+  } else if (isInteger(crop) && crop === module.exports.strategy.entropy) {
+    // Strategy
+    this.options.crop = crop;
   } else {
-    throw new Error('Unsupported crop gravity ' + gravity);
+    throw new Error('Unsupported crop ' + crop);
   }
   return this;
 };
 
 Sharp.prototype.extract = function(options) {
-  if (!options || typeof options !== 'object') {
-    // Legacy extract(top,left,width,height) syntax
-    options = {
-      left: arguments[1],
-      top: arguments[0],
-      width: arguments[2],
-      height: arguments[3]
-    };
-  }
   var suffix = this.options.width === -1 && this.options.height === -1 ? 'Pre' : 'Post';
   ['left', 'top', 'width', 'height'].forEach(function (name) {
     var value = options[name];
-    if (typeof value === 'number' && !Number.isNaN(value) && value % 1 === 0 && value >= 0) {
+    if (isInteger(value) && value >= 0) {
       this.options[name + (name === 'left' || name === 'top' ? 'Offset' : '') + suffix] = value;
     } else {
       throw new Error('Non-integer value for ' + name + ' of ' + value);
@@ -270,6 +307,21 @@ Sharp.prototype.extract = function(options) {
   return this;
 };
 
+Sharp.prototype.extractChannel = function(channel) {
+  if (channel === 'red')
+    channel = 0;
+  else if (channel === 'green')
+    channel = 1;
+  else if (channel === 'blue')
+    channel = 2;
+  if(isInteger(channel) && inRange(channel,0,4)) {
+    this.options.extractChannel = channel;
+  } else {
+    throw new Error('Cannot extract invalid channel ' + channel);
+  }
+  return this;
+};
+
 /*
   Set the background colour for embed and flatten operations.
   Delegates to the 'Color' module, which can throw an Error
@@ -307,23 +359,81 @@ Sharp.prototype.ignoreAspectRatio = function() {
 };
 
 Sharp.prototype.flatten = function(flatten) {
-  this.options.flatten = (typeof flatten === 'boolean') ? flatten : true;
+  this.options.flatten = isBoolean(flatten) ? flatten : true;
   return this;
 };
 
 Sharp.prototype.negate = function(negate) {
-  this.options.negate = (typeof negate === 'boolean') ? negate : true;
+  this.options.negate = isBoolean(negate) ? negate : true;
   return this;
 };
 
-Sharp.prototype.overlayWith = function(overlayPath) {
+/*
-  if (typeof overlayPath !== 'string') {
+  Bitwise boolean operations between images
-    throw new Error('The overlay path must be a string');
+*/
+Sharp.prototype.boolean = function(operand, operator) {
+  if (isString(operand)) {
+    this.options.booleanFileIn = operand;
+  } else if (isBuffer(operand)) {
+    this.options.booleanBufferIn = operand;
+  } else {
+    throw new Error('Unsupported boolean operand ' + typeof operand);
+  }
+  if (isString(operator) && contains(operator, ['and', 'or', 'eor'])) {
+    this.options.booleanOp = operator;
+  } else {
+    throw new Error('Invalid boolean operation ' + operator);
+  }
+  return this;
+};
+
+/*
+  Overlay with another image, using an optional gravity
+*/
+Sharp.prototype.overlayWith = function(overlay, options) {
+  if (isString(overlay)) {
+    this.options.overlayFileIn = overlay;
+  } else if (isBuffer(overlay)) {
+    this.options.overlayBufferIn = overlay;
+  } else {
+    throw new Error('Unsupported overlay ' + typeof overlay);
+  }
+  if (isObject(options)) {
+    if (isDefined(options.tile)) {
+      if (isBoolean(options.tile)) {
+        this.options.overlayTile = options.tile;
+      } else {
+        throw new Error('Invalid overlay tile ' + options.tile);
+      }
+    }
+    if (isDefined(options.cutout)) {
+      if (isBoolean(options.cutout)) {
+        this.options.overlayCutout = options.cutout;
+      } else {
+        throw new Error('Invalid overlay cutout ' + options.cutout);
+      }
+    }
+    if (isDefined(options.left) || isDefined(options.top)) {
+      if (
+        isInteger(options.left) && inRange(options.left, 0, maximum.width) &&
+        isInteger(options.top) && inRange(options.top, 0, maximum.height)
+      ) {
+        this.options.overlayXOffset = options.left;
+        this.options.overlayYOffset = options.top;
+      } else {
+        throw new Error('Invalid overlay left ' + options.left + ' and/or top ' + options.top);
+      }
+    }
+    if (isDefined(options.gravity)) {
+      if(isInteger(options.gravity) && inRange(options.gravity, 0, 8)) {
+        this.options.overlayGravity = options.gravity;
+      } else if (isString(options.gravity) && isInteger(module.exports.gravity[options.gravity])) {
+        this.options.overlayGravity = module.exports.gravity[options.gravity];
+      } else {
+        throw new Error('Unsupported overlay gravity ' + options.gravity);
+      }
     }
-  if (overlayPath === '') {
-    throw new Error('The overlay path cannot be empty');
   }
-  this.options.overlayPath = overlayPath;
   return this;
 };
 
@@ -332,9 +442,9 @@ Sharp.prototype.overlayWith = function(overlayPath) {
   Auto-rotation based on the EXIF Orientation tag is represented by an angle of -1
 */
 Sharp.prototype.rotate = function(angle) {
-  if (typeof angle === 'undefined') {
+  if (!isDefined(angle)) {
     this.options.angle = -1;
-  } else if (!Number.isNaN(angle) && [0, 90, 180, 270].indexOf(angle) !== -1) {
+  } else if (isInteger(angle) && contains(angle, [0, 90, 180, 270])) {
     this.options.angle = angle;
   } else {
     throw new Error('Unsupported angle (0, 90, 180, 270) ' + angle);
@@ -346,7 +456,7 @@ Sharp.prototype.rotate = function(angle) {
   Flip the image vertically, about the Y axis
 */
 Sharp.prototype.flip = function(flip) {
-  this.options.flip = (typeof flip === 'boolean') ? flip : true;
+  this.options.flip = isBoolean(flip) ? flip : true;
   return this;
 };
 
@@ -354,7 +464,7 @@ Sharp.prototype.flip = function(flip) {
   Flop the image horizontally, about the X axis
 */
 Sharp.prototype.flop = function(flop) {
-  this.options.flop = (typeof flop === 'boolean') ? flop : true;
+  this.options.flop = isBoolean(flop) ? flop : true;
   return this;
 };
 
@@ -364,7 +474,7 @@ Sharp.prototype.flop = function(flop) {
     "change the dimensions of the image only if its width or height exceeds the geometry specification"
 */
 Sharp.prototype.withoutEnlargement = function(withoutEnlargement) {
-  this.options.withoutEnlargement = (typeof withoutEnlargement === 'boolean') ? withoutEnlargement : true;
+  this.options.withoutEnlargement = isBoolean(withoutEnlargement) ? withoutEnlargement : true;
   return this;
 };
 
@@ -374,97 +484,117 @@ Sharp.prototype.withoutEnlargement = function(withoutEnlargement) {
   Call with a sigma to use a slower, more accurate Gaussian blur.
 */
 Sharp.prototype.blur = function(sigma) {
-  if (typeof sigma === 'undefined') {
+  if (!isDefined(sigma)) {
     // No arguments: default to mild blur
     this.options.blurSigma = -1;
-  } else if (typeof sigma === 'boolean') {
+  } else if (isBoolean(sigma)) {
     // Boolean argument: apply mild blur?
     this.options.blurSigma = sigma ? -1 : 0;
-  } else if (typeof sigma === 'number' && !Number.isNaN(sigma) && sigma >= 0.3 && sigma <= 1000) {
+  } else if (isNumber(sigma) && inRange(sigma, 0.3, 1000)) {
     // Numeric argument: specific sigma
     this.options.blurSigma = sigma;
   } else {
-    throw new Error('Invalid blur sigma (0.3 to 1000.0) ' + sigma);
+    throw new Error('Invalid blur sigma (0.3 - 1000.0) ' + sigma);
   }
   return this;
 };
 
+/*
+  Convolve the image with a kernel.
+*/
+Sharp.prototype.convolve = function(kernel) {
+  if (!isDefined(kernel) || !isDefined(kernel.kernel) ||
+      !isDefined(kernel.width) || !isDefined(kernel.height) ||
+      !inRange(kernel.width,3,1001) || !inRange(kernel.height,3,1001) ||
+      kernel.height * kernel.width != kernel.kernel.length
+     ) {
+    // must pass in a kernel
+    throw new Error('Invalid convolution kernel');
+  }
+  if(!isDefined(kernel.scale)) {
+    var sum = 0;
+    kernel.kernel.forEach(function(e) {
+      sum += e;
+    });
+    kernel.scale = sum;
+  }
+  if(!isDefined(kernel.offset)) {
+    kernel.offset = 0;
+  }
+  this.options.convKernel = kernel;
+  return this;
+};
+
 /*
   Sharpen the output image.
   Call without a radius to use a fast, mild sharpen.
   Call with a radius to use a slow, accurate sharpen using the L of LAB colour space.
-    radius - size of mask in pixels, must be integer
+    sigma - sigma of mask
     flat - level of "flat" area sharpen, default 1
     jagged - level of "jagged" area sharpen, default 2
 */
-Sharp.prototype.sharpen = function(radius, flat, jagged) {
+Sharp.prototype.sharpen = function(sigma, flat, jagged) {
-  if (typeof radius === 'undefined') {
+  if (!isDefined(sigma)) {
     // No arguments: default to mild sharpen
-    this.options.sharpenRadius = -1;
+    this.options.sharpenSigma = -1;
-  } else if (typeof radius === 'boolean') {
+  } else if (isBoolean(sigma)) {
     // Boolean argument: apply mild sharpen?
-    this.options.sharpenRadius = radius ? -1 : 0;
+    this.options.sharpenSigma = sigma ? -1 : 0;
-  } else if (typeof radius === 'number' && !Number.isNaN(radius) && (radius % 1 === 0) && radius >= 1) {
+  } else if (isNumber(sigma) && inRange(sigma, 0.01, 10000)) {
-    // Numeric argument: specific radius
+    // Numeric argument: specific sigma
-    this.options.sharpenRadius = radius;
+    this.options.sharpenSigma = sigma;
     // Control over flat areas
-    if (typeof flat !== 'undefined' && flat !== null) {
+    if (isDefined(flat)) {
-      if (typeof flat === 'number' && !Number.isNaN(flat) && flat >= 0) {
+      if (isNumber(flat) && inRange(flat, 0, 10000)) {
         this.options.sharpenFlat = flat;
       } else {
-        throw new Error('Invalid sharpen level for flat areas ' + flat + ' (expected >= 0)');
+        throw new Error('Invalid sharpen level for flat areas (0 - 10000) ' + flat);
       }
     }
     // Control over jagged areas
-    if (typeof jagged !== 'undefined' && jagged !== null) {
+    if (isDefined(jagged)) {
-      if (typeof jagged === 'number' && !Number.isNaN(jagged) && jagged >= 0) {
+      if (isNumber(jagged) && inRange(jagged, 0, 10000)) {
         this.options.sharpenJagged = jagged;
       } else {
-        throw new Error('Invalid sharpen level for jagged areas ' + jagged + ' (expected >= 0)');
+        throw new Error('Invalid sharpen level for jagged areas (0 - 10000) ' + jagged);
       }
     }
   } else {
-    throw new Error('Invalid sharpen radius ' + radius + ' (expected integer >= 1)');
+    throw new Error('Invalid sharpen sigma (0.01 - 10000) ' + sigma);
   }
   return this;
 };
 
-Sharp.prototype.threshold = function(threshold) {
+Sharp.prototype.threshold = function(threshold, options) {
-  if (typeof threshold === 'undefined') {
+  if (!isDefined(threshold)) {
     this.options.threshold = 128;
-  } else if (typeof threshold === 'boolean') {
+  } else if (isBoolean(threshold)) {
     this.options.threshold = threshold ? 128 : 0;
-  } else if (typeof threshold === 'number' && !Number.isNaN(threshold) && (threshold % 1 === 0) && threshold >= 0 && threshold <= 255) {
+  } else if (isInteger(threshold) && inRange(threshold, 0, 255)) {
     this.options.threshold = threshold;
   } else {
     throw new Error('Invalid threshold (0 to 255) ' + threshold);
   }
+  if (!isObject(options) || options.greyscale === true || options.grayscale === true) {
+    this.options.thresholdGrayscale = true;
+  } else {
+    this.options.thresholdGrayscale = false;
+  }
   return this;
 };
 
 /*
-  Set the interpolator to use for the affine transformation
+  Automatically remove "boring" image edges.
+    tolerance - if present, is a percentaged tolerance level between 0 and 100 to trim away similar color values
+      Defaulting to 10 when no tolerance is given.
  */
-module.exports.interpolator = {
+Sharp.prototype.trim = function(tolerance) {
-  nearest: 'nearest',
+  if (!isDefined(tolerance)) {
-  bilinear: 'bilinear',
+    this.options.trimTolerance = 10;
-  bicubic: 'bicubic',
+  } else if (isInteger(tolerance) && inRange(tolerance, 1, 99)) {
-  nohalo: 'nohalo',
+    this.options.trimTolerance = tolerance;
-  locallyBoundedBicubic: 'lbb',
-  vertexSplitQuadraticBasisSpline: 'vsqbs'
-};
-Sharp.prototype.interpolateWith = function(interpolator) {
-  var isValid = false;
-  for (var key in module.exports.interpolator) {
-    if (module.exports.interpolator[key] === interpolator) {
-      isValid = true;
-      break;
-    }
-  }
-  if (isValid) {
-    this.options.interpolator = interpolator;
   } else {
-    throw new Error('Invalid interpolator ' + interpolator);
+    throw new Error('Invalid trim tolerance (1 to 99) ' + tolerance);
   }
   return this;
 };
@@ -474,10 +604,10 @@ Sharp.prototype.interpolateWith = function(interpolator) {
   Improves brightness of resized image in non-linear colour spaces.
 */
 Sharp.prototype.gamma = function(gamma) {
-  if (typeof gamma === 'undefined') {
+  if (!isDefined(gamma)) {
     // Default gamma correction of 2.2 (sRGB)
     this.options.gamma = 2.2;
-  } else if (!Number.isNaN(gamma) && gamma >= 1 && gamma <= 3) {
+  } else if (isNumber(gamma) && inRange(gamma, 1, 3)) {
     this.options.gamma = gamma;
   } else {
     throw new Error('Invalid gamma correction (1.0 to 3.0) ' + gamma);
@@ -489,32 +619,44 @@ Sharp.prototype.gamma = function(gamma) {
   Enhance output image contrast by stretching its luminance to cover the full dynamic range
 */
 Sharp.prototype.normalize = function(normalize) {
-  this.options.normalize = (typeof normalize === 'boolean') ? normalize : true;
+  this.options.normalize = isBoolean(normalize) ? normalize : true;
   return this;
 };
 Sharp.prototype.normalise = Sharp.prototype.normalize;
 
+/*
+  Perform boolean/bitwise operation on image color channels - results in one channel image
+*/
+Sharp.prototype.bandbool = function(boolOp) {
+  if (isString(boolOp) && contains(boolOp, ['and', 'or', 'eor'])) {
+    this.options.bandBoolOp = boolOp;
+  } else {
+    throw new Error('Invalid bandbool operation ' + boolOp);
+  }
+  return this;
+};
+
 /*
   Convert to greyscale
 */
 Sharp.prototype.greyscale = function(greyscale) {
-  this.options.greyscale = (typeof greyscale === 'boolean') ? greyscale : true;
+  this.options.greyscale = isBoolean(greyscale) ? greyscale : true;
   return this;
 };
 Sharp.prototype.grayscale = Sharp.prototype.greyscale;
 
 Sharp.prototype.progressive = function(progressive) {
-  this.options.progressive = (typeof progressive === 'boolean') ? progressive : true;
+  this.options.progressive = isBoolean(progressive) ? progressive : true;
   return this;
 };
 
 Sharp.prototype.sequentialRead = function(sequentialRead) {
-  this.options.sequentialRead = (typeof sequentialRead === 'boolean') ? sequentialRead : true;
+  this.options.sequentialRead = isBoolean(sequentialRead) ? sequentialRead : true;
   return this;
 };
 
 Sharp.prototype.quality = function(quality) {
-  if (!Number.isNaN(quality) && quality >= 1 && quality <= 100 && quality % 1 === 0) {
+  if (isInteger(quality) && inRange(quality, 1, 100)) {
     this.options.quality = quality;
   } else {
     throw new Error('Invalid quality (1 to 100) ' + quality);
@@ -526,7 +668,7 @@ Sharp.prototype.quality = function(quality) {
   zlib compression level for PNG output
 */
 Sharp.prototype.compressionLevel = function(compressionLevel) {
-  if (!Number.isNaN(compressionLevel) && compressionLevel >= 0 && compressionLevel <= 9) {
+  if (isInteger(compressionLevel) && inRange(compressionLevel, 0, 9)) {
     this.options.compressionLevel = compressionLevel;
   } else {
     throw new Error('Invalid compressionLevel (0 to 9) ' + compressionLevel);
@@ -538,7 +680,7 @@ Sharp.prototype.compressionLevel = function(compressionLevel) {
   Disable the use of adaptive row filtering for PNG output
 */
 Sharp.prototype.withoutAdaptiveFiltering = function(withoutAdaptiveFiltering) {
-  this.options.withoutAdaptiveFiltering = (typeof withoutAdaptiveFiltering === 'boolean') ? withoutAdaptiveFiltering : true;
+  this.options.withoutAdaptiveFiltering = isBoolean(withoutAdaptiveFiltering) ? withoutAdaptiveFiltering : true;
   return this;
 };
 
@@ -546,7 +688,7 @@ Sharp.prototype.withoutAdaptiveFiltering = function(withoutAdaptiveFiltering) {
   Disable the use of chroma subsampling for JPEG output
 */
 Sharp.prototype.withoutChromaSubsampling = function(withoutChromaSubsampling) {
-  this.options.withoutChromaSubsampling = (typeof withoutChromaSubsampling === 'boolean') ? withoutChromaSubsampling : true;
+  this.options.withoutChromaSubsampling = isBoolean(withoutChromaSubsampling) ? withoutChromaSubsampling : true;
   return this;
 };
 
@@ -554,7 +696,7 @@ Sharp.prototype.withoutChromaSubsampling = function(withoutChromaSubsampling) {
   Apply trellis quantisation to JPEG output - requires mozjpeg 3.0+
 */
 Sharp.prototype.trellisQuantisation = function(trellisQuantisation) {
-  this.options.trellisQuantisation = (typeof trellisQuantisation === 'boolean') ? trellisQuantisation : true;
+  this.options.trellisQuantisation = isBoolean(trellisQuantisation) ? trellisQuantisation : true;
   return this;
 };
 Sharp.prototype.trellisQuantization = Sharp.prototype.trellisQuantisation;
@@ -563,7 +705,7 @@ Sharp.prototype.trellisQuantization = Sharp.prototype.trellisQuantisation;
   Apply overshoot deringing to JPEG output - requires mozjpeg 3.0+
 */
 Sharp.prototype.overshootDeringing = function(overshootDeringing) {
-  this.options.overshootDeringing = (typeof overshootDeringing === 'boolean') ? overshootDeringing : true;
+  this.options.overshootDeringing = isBoolean(overshootDeringing) ? overshootDeringing : true;
   return this;
 };
 
@@ -571,7 +713,7 @@ Sharp.prototype.overshootDeringing = function(overshootDeringing) {
   Optimise scans in progressive JPEG output - requires mozjpeg 3.0+
 */
 Sharp.prototype.optimiseScans = function(optimiseScans) {
-  this.options.optimiseScans = (typeof optimiseScans === 'boolean') ? optimiseScans : true;
+  this.options.optimiseScans = isBoolean(optimiseScans) ? optimiseScans : true;
   if (this.options.optimiseScans) {
     this.progressive();
   }
@@ -585,19 +727,13 @@ Sharp.prototype.optimizeScans = Sharp.prototype.optimiseScans;
     orientation: numeric value for EXIF Orientation tag
 */
 Sharp.prototype.withMetadata = function(withMetadata) {
-  this.options.withMetadata = (typeof withMetadata === 'boolean') ? withMetadata : true;
+  this.options.withMetadata = isBoolean(withMetadata) ? withMetadata : true;
-  if (typeof withMetadata === 'object') {
+  if (isObject(withMetadata)) {
-    if ('orientation' in withMetadata) {
+    if (isDefined(withMetadata.orientation)) {
-      if (
+      if (isInteger(withMetadata.orientation) && inRange(withMetadata.orientation, 1, 8)) {
-        typeof withMetadata.orientation === 'number' &&
-        !Number.isNaN(withMetadata.orientation) &&
-        withMetadata.orientation % 1 === 0 &&
-        withMetadata.orientation >= 0 &&
-        withMetadata.orientation <= 7
-      ) {
         this.options.withMetadataOrientation = withMetadata.orientation;
       } else {
-        throw new Error('Invalid orientation (0 to 7) ' + withMetadata.orientation);
+        throw new Error('Invalid orientation (1 to 8) ' + withMetadata.orientation);
       }
     }
   }
@@ -605,59 +741,164 @@ Sharp.prototype.withMetadata = function(withMetadata) {
 };
 
 /*
-  Tile size and overlap for Deep Zoom output
+  Tile-based deep zoom output options: size, overlap, layout
 */
-Sharp.prototype.tile = function(size, overlap) {
+Sharp.prototype.tile = function(tile) {
+  if (isObject(tile)) {
     // Size of square tiles, in pixels
-  if (typeof size !== 'undefined' && size !== null) {
+    if (isDefined(tile.size)) {
-    if (!Number.isNaN(size) && size % 1 === 0 && size >= 1 && size <= 8192) {
+      if (isInteger(tile.size) && inRange(tile.size, 1, 8192)) {
-      this.options.tileSize = size;
+        this.options.tileSize = tile.size;
       } else {
-      throw new Error('Invalid tile size (1 to 8192) ' + size);
+        throw new Error('Invalid tile size (1 to 8192) ' + tile.size);
       }
     }
     // Overlap of tiles, in pixels
-  if (typeof overlap !== 'undefined' && overlap !== null) {
+    if (isDefined(tile.overlap)) {
-    if (!Number.isNaN(overlap) && overlap % 1 === 0 && overlap >= 0 && overlap <= 8192) {
+      if (isInteger(tile.overlap) && inRange(tile.overlap, 0, 8192)) {
-      if (overlap > this.options.tileSize) {
+        if (tile.overlap > this.options.tileSize) {
-        throw new Error('Tile overlap ' + overlap + ' cannot be larger than tile size ' + this.options.tileSize);
+          throw new Error('Tile overlap ' + tile.overlap + ' cannot be larger than tile size ' + this.options.tileSize);
         }
-      this.options.tileOverlap = overlap;
+        this.options.tileOverlap = tile.overlap;
       } else {
-      throw new Error('Invalid tile overlap (0 to 8192) ' + overlap);
+        throw new Error('Invalid tile overlap (0 to 8192) ' + tile.overlap);
+      }
+    }
+    // Container
+    if (isDefined(tile.container)) {
+      if (isString(tile.container) && contains(tile.container, ['fs', 'zip'])) {
+        this.options.tileContainer = tile.container;
+      } else {
+        throw new Error('Invalid tile container ' + tile.container);
+      }
+    }
+    // Layout
+    if (isDefined(tile.layout)) {
+      if (isString(tile.layout) && contains(tile.layout, ['dz', 'google', 'zoomify'])) {
+        this.options.tileLayout = tile.layout;
+      } else {
+        throw new Error('Invalid tile layout ' + tile.layout);
+      }
     }
   }
   return this;
 };
 
-Sharp.prototype.resize = function(width, height) {
+/*
-  if (!width) {
+  Extend edges
-    this.options.width = -1;
+*/
+Sharp.prototype.extend = function(extend) {
+  if (isInteger(extend) && extend > 0) {
+    this.options.extendTop = extend;
+    this.options.extendBottom = extend;
+    this.options.extendLeft = extend;
+    this.options.extendRight = extend;
+  } else if (
+    isObject(extend) &&
+    isInteger(extend.top) && extend.top >= 0 &&
+    isInteger(extend.bottom) && extend.bottom >= 0 &&
+    isInteger(extend.left) && extend.left >= 0 &&
+    isInteger(extend.right) && extend.right >= 0
+  ) {
+    this.options.extendTop = extend.top;
+    this.options.extendBottom = extend.bottom;
+    this.options.extendLeft = extend.left;
+    this.options.extendRight = extend.right;
   } else {
-    if (typeof width === 'number' && !Number.isNaN(width) && width % 1 === 0 && width > 0 && width <= maximum.width) {
+    throw new Error('Invalid edge extension ' + extend);
+  }
+  return this;
+};
+
+// Kernels for reduction
+module.exports.kernel = {
+  cubic: 'cubic',
+  lanczos2: 'lanczos2',
+  lanczos3: 'lanczos3'
+};
+// Interpolators for enlargement
+module.exports.interpolator = {
+  nearest: 'nearest',
+  bilinear: 'bilinear',
+  bicubic: 'bicubic',
+  nohalo: 'nohalo',
+  lbb: 'lbb',
+  locallyBoundedBicubic: 'lbb',
+  vsqbs: 'vsqbs',
+  vertexSplitQuadraticBasisSpline: 'vsqbs'
+};
+// Boolean operations for bandbool
+module.exports.bool = {
+  and: 'and',
+  or: 'or',
+  eor: 'eor'
+};
+
+/*
+  Resize image to width x height pixels
+  options.kernel is the kernel to use for reductions, default 'lanczos3'
+  options.interpolator is the interpolator to use for enlargements, default 'bicubic'
+*/
+Sharp.prototype.resize = function(width, height, options) {
+  if (isDefined(width)) {
+    if (isInteger(width) && inRange(width, 1, maximum.width)) {
       this.options.width = width;
     } else {
       throw new Error('Invalid width (1 to ' + maximum.width + ') ' + width);
     }
-  }
-  if (!height) {
-    this.options.height = -1;
   } else {
-    if (typeof height === 'number' && !Number.isNaN(height) && height % 1 === 0 && height > 0 && height <= maximum.height) {
+    this.options.width = -1;
+  }
+  if (isDefined(height)) {
+    if (isInteger(height) && inRange(height, 1, maximum.height)) {
       this.options.height = height;
     } else {
       throw new Error('Invalid height (1 to ' + maximum.height + ') ' + height);
     }
+  } else {
+    this.options.height = -1;
+  }
+  if (isObject(options)) {
+    // Kernel
+    if (isDefined(options.kernel)) {
+      if (isString(module.exports.kernel[options.kernel])) {
+        this.options.kernel = module.exports.kernel[options.kernel];
+      } else {
+        throw new Error('Invalid kernel ' + options.kernel);
+      }
+    }
+    // Interpolator
+    if (isDefined(options.interpolator)) {
+      if (isString(module.exports.interpolator[options.interpolator])) {
+        this.options.interpolator = module.exports.interpolator[options.interpolator];
+      } else {
+        throw new Error('Invalid interpolator ' + options.interpolator);
+      }
+    }
   }
   return this;
 };
+Sharp.prototype.interpolateWith = util.deprecate(function(interpolator) {
+  return this.resize(
+    this.options.width > 0 ? this.options.width : null,
+    this.options.height > 0 ? this.options.height : null,
+    { interpolator: interpolator }
+  );
+}, 'interpolateWith: Please use resize(w, h, { interpolator: ... }) instead');
 
 /*
   Limit the total number of pixels for input images
-  Assumes the image dimensions contained in the file header can be trusted
+  Assumes the image dimensions contained in the file header can be trusted.
+  Alternatively can use boolean to disable or reset to default (maximum pixels)
 */
 Sharp.prototype.limitInputPixels = function(limit) {
-  if (typeof limit === 'number' && !Number.isNaN(limit) && limit % 1 === 0 && limit > 0) {
+  //if we pass in false we represent the integer as 0 to disable
+  if(limit === false) {
+    limit = 0;
+  } else if(limit === true) {
+    limit = maximum.pixels;
+  }
+  if (typeof limit === 'number' && !Number.isNaN(limit) && limit % 1 === 0 && limit >= 0) {
     this.options.limitInputPixels = limit;
   } else {
     throw new Error('Invalid pixel limit (1 to ' + maximum.pixels + ') ' + limit);
@@ -736,12 +977,11 @@ Sharp.prototype.raw = function() {
   @param format is either the id as a String or an Object with an 'id' attribute
 */
 Sharp.prototype.toFormat = function(formatOut) {
-  if (isObject(formatOut) && isDefined(formatOut.id)) {
+  if (isObject(formatOut) && isString(formatOut.id)) {
-    formatOut = formatOut.id;
+    this.options.formatOut = formatOut.id;
-  }
+  } else if (
-  if (
+    isString(formatOut) &&
-    isDefined(formatOut) &&
+    contains(formatOut, ['jpeg', 'png', 'webp', 'raw', 'tiff', 'dz', 'input'])
-    ['jpeg', 'png', 'webp', 'raw', 'tiff', 'dz', 'input'].indexOf(formatOut) !== -1
   ) {
     this.options.formatOut = formatOut;
   } else {
@@ -771,6 +1011,7 @@ Sharp.prototype._pipeline = function(callback) {
     if (this.options.streamIn) {
       // output=file/buffer, input=stream
       this.on('finish', function() {
+        that._flattenBufferIn();
         sharp.pipeline(that.options, callback);
       });
     } else {
@@ -783,10 +1024,12 @@ Sharp.prototype._pipeline = function(callback) {
     if (this.options.streamIn) {
       // output=stream, input=stream
       this.on('finish', function() {
-        sharp.pipeline(that.options, function(err, data) {
+        that._flattenBufferIn();
+        sharp.pipeline(that.options, function(err, data, info) {
           if (err) {
             that.emit('error', err);
           } else {
+            that.emit('info', info);
             that.push(data);
           }
           that.push(null);
@@ -794,10 +1037,11 @@ Sharp.prototype._pipeline = function(callback) {
       });
     } else {
       // output=stream, input=file/buffer
-      sharp.pipeline(this.options, function(err, data) {
+      sharp.pipeline(this.options, function(err, data, info) {
         if (err) {
           that.emit('error', err);
         } else {
+          that.emit('info', info);
           that.push(data);
         }
         that.push(null);
@@ -810,6 +1054,7 @@ Sharp.prototype._pipeline = function(callback) {
       // output=promise, input=stream
       return new BluebirdPromise(function(resolve, reject) {
         that.on('finish', function() {
+          that._flattenBufferIn();
           sharp.pipeline(that.options, function(err, data) {
             if (err) {
               reject(err);
@@ -843,6 +1088,7 @@ Sharp.prototype.metadata = function(callback) {
   if (typeof callback === 'function') {
     if (this.options.streamIn) {
       this.on('finish', function() {
+        that._flattenBufferIn();
         sharp.metadata(that.options, callback);
       });
     } else {
@@ -853,6 +1099,7 @@ Sharp.prototype.metadata = function(callback) {
     if (this.options.streamIn) {
       return new BluebirdPromise(function(resolve, reject) {
         that.on('finish', function() {
+          that._flattenBufferIn();
           sharp.metadata(that.options, function(err, metadata) {
             if (err) {
               reject(err);
@@ -881,14 +1128,15 @@ Sharp.prototype.metadata = function(callback) {
   Cloned instances share the same input.
 */
 Sharp.prototype.clone = function() {
+  var that = this;
   // Clone existing options
   var clone = new Sharp();
   util._extend(clone.options, this.options);
-  clone.streamIn = false;
   // Pass 'finish' event to clone for Stream-based input
   this.on('finish', function() {
     // Clone inherits input data
-    clone.options.bufferIn = this.options.bufferIn;
+    that._flattenBufferIn();
+    clone.options.bufferIn = that.options.bufferIn;
     clone.emit('finish');
   });
   return clone;

mkdocs.yml

@@ -1,7 +1,7 @@
 site_name: sharp
 site_url: http://sharp.dimens.io/
 repo_url: https://github.com/lovell/sharp
-site_description: The fastest Node.js module for resizing JPEG, PNG, WebP and TIFF images. Uses the libvips library.
+site_description: High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP and TIFF images
 copyright: <a href="https://dimens.io/">dimens.io</a>
 google_analytics: ['UA-13034748-12', 'sharp.dimens.io']
 theme: readthedocs

package.json

@@ -1,6 +1,6 @@
 {
   "name": "sharp",
-  "version": "0.13.0",
+  "version": "0.15.1",
   "author": "Lovell Fuller <npm@lovell.info>",
   "contributors": [
     "Pierre Inglebert <pierre.inglebert@gmail.com>",
@@ -18,13 +18,21 @@
     "Alaric Holloway <alaric.holloway@gmail.com>",
     "Bernhard K. Weisshuhn <bkw@codingforce.com>",
     "Chris Riley <criley@primedia.com>",
-    "David Carley <dacarley@gmail.com>"
+    "David Carley <dacarley@gmail.com>",
+    "John Tobin <john@limelightmobileinc.com>",
+    "Kenton Gray <kentongray@gmail.com>",
+    "Felix Bünemann <Felix.Buenemann@gmail.com>",
+    "Samy Al Zahrani <samyalzahrany@gmail.com>",
+    "Chintan Thakkar <lemnisk8@gmail.com>",
+    "F. Orlando Galashan <frulo@gmx.de>",
+    "Kleis Auke Wolthuizen <info@kleisauke.nl>",
+    "Matt Hirsch <mhirsch@media.mit.edu>"
   ],
-  "description": "High performance Node.js module to resize JPEG, PNG, WebP and TIFF images using the libvips library",
+  "description": "High performance Node.js image processing, the fastest module to resize JPEG, PNG, WebP and TIFF images",
   "scripts": {
     "clean": "rm -rf node_modules/ build/ include/ lib/ coverage/ test/fixtures/output.*",
     "test": "VIPS_WARNING=0 node ./node_modules/istanbul/lib/cli.js cover ./node_modules/mocha/bin/_mocha -- --slow=5000 --timeout=30000 ./test/unit/*.js",
-    "test-win": "node ./node_modules/mocha/bin/mocha --slow=5000 --timeout=30000 ./test/unit/*.js",
+    "test-win": "node ./node_modules/mocha/bin/mocha --slow=5000 --timeout=60000 ./test/unit/*.js",
     "test-leak": "./test/leak/leak.sh",
     "test-packaging": "./packaging/test.sh",
     "test-clean": "rm -rf coverage/ test/fixtures/output.* && npm install && npm test"
@@ -39,7 +47,10 @@
     "png",
     "webp",
     "tiff",
+    "gif",
+    "svg",
     "dzi",
+    "image",
     "resize",
     "thumbnail",
     "crop",
@@ -47,28 +58,29 @@
     "vips"
   ],
   "dependencies": {
-    "bluebird": "^3.2.2",
+    "bluebird": "^3.4.1",
-    "color": "^0.11.1",
+    "color": "^0.11.3",
-    "nan": "^2.2.0",
+    "nan": "^2.4.0",
-    "semver": "^5.1.0",
+    "semver": "^5.2.0",
-    "request": "^2.69.0",
+    "request": "^2.73.0",
     "tar": "^2.2.1"
   },
   "devDependencies": {
     "async": "^1.5.2",
-    "coveralls": "^2.11.6",
+    "bufferutil": "^1.2.1",
+    "coveralls": "^2.11.9",
     "exif-reader": "^1.0.0",
     "icc": "^0.0.2",
-    "istanbul": "^0.4.2",
+    "istanbul": "^0.4.4",
-    "mocha": "^2.4.5",
+    "mocha": "^2.5.3",
     "mocha-jshint": "^2.3.1",
     "node-cpplint": "^0.4.0",
-    "rimraf": "^2.5.1",
+    "rimraf": "^2.5.3",
-    "bufferutil": "^1.2.1"
+    "unzip": "^0.1.11"
   },
   "license": "Apache-2.0",
   "config": {
-    "libvips": "8.2.2"
+    "libvips": "8.3.1"
   },
   "engines": {
     "node": ">=0.10"

packaging/arm/build.sh

@@ -19,18 +19,30 @@ export CXXFLAGS="-O3"
 # Dependency version numbers
 VERSION_ZLIB=1.2.8
 VERSION_FFI=3.2.1
-VERSION_GLIB=2.47.5
+VERSION_GLIB=2.48.0
 VERSION_XML2=2.9.3
-VERSION_GSF=1.14.34
+VERSION_GSF=1.14.36
 VERSION_EXIF=0.6.21
 VERSION_LCMS2=2.7
-VERSION_GM=1.3.23
+VERSION_JPEG=1.4.90
-VERSION_JPEG=1.4.2
 VERSION_PNG16=1.6.21
 VERSION_WEBP=0.5.0
 VERSION_TIFF=4.0.6
-VERSION_ORC=0.4.24
+VERSION_ORC=0.4.25
-VERSION_VIPS=8.2.2
+VERSION_GDKPIXBUF=2.34.0
+VERSION_FREETYPE=2.6.3
+VERSION_FONTCONFIG=2.11.95
+VERSION_HARFBUZZ=1.2.6
+VERSION_PIXMAN=0.34.0
+VERSION_CAIRO=1.14.6
+VERSION_PANGO=1.40.1
+VERSION_CROCO=0.6.11
+VERSION_SVG=2.40.15
+VERSION_GIF=5.1.4
+VERSION_VIPS=8.3.1
+
+# Least out-of-sync Sourceforge mirror
+SOURCEFORGE_MIRROR=netix
 
 mkdir ${DEPS}/zlib
 curl -Ls http://zlib.net/zlib-${VERSION_ZLIB}.tar.xz | tar xJC ${DEPS}/zlib --strip-components=1
@@ -44,7 +56,7 @@ cd ${DEPS}/ffi
 ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-builddir && make install-strip
 
 mkdir ${DEPS}/glib
-curl -Ls https://download.gnome.org/sources/glib/2.47/glib-${VERSION_GLIB}.tar.xz | tar xJC ${DEPS}/glib --strip-components=1
+curl -Ls https://download.gnome.org/sources/glib/2.48/glib-${VERSION_GLIB}.tar.xz | tar xJC ${DEPS}/glib --strip-components=1
 cd ${DEPS}/glib
 ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-pcre=internal && make install-strip
 
@@ -59,27 +71,22 @@ cd ${DEPS}/gsf
 ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
 
 mkdir ${DEPS}/exif
-curl -Ls http://heanet.dl.sourceforge.net/project/libexif/libexif/${VERSION_EXIF}/libexif-${VERSION_EXIF}.tar.bz2 | tar xjC ${DEPS}/exif --strip-components=1
+curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/libexif/libexif/${VERSION_EXIF}/libexif-${VERSION_EXIF}.tar.bz2 | tar xjC ${DEPS}/exif --strip-components=1
 cd ${DEPS}/exif
 ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
 
 mkdir ${DEPS}/lcms2
-curl -Ls http://heanet.dl.sourceforge.net/project/lcms/lcms/${VERSION_LCMS2}/lcms2-${VERSION_LCMS2}.tar.gz | tar xzC ${DEPS}/lcms2 --strip-components=1
+curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/lcms/lcms/${VERSION_LCMS2}/lcms2-${VERSION_LCMS2}.tar.gz | tar xzC ${DEPS}/lcms2 --strip-components=1
 cd ${DEPS}/lcms2
 ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
 
-mkdir ${DEPS}/gm
-curl -Ls http://heanet.dl.sourceforge.net/project/graphicsmagick/graphicsmagick/${VERSION_GM}/GraphicsMagick-${VERSION_GM}.tar.xz | tar xJC ${DEPS}/gm --strip-components=1
-cd ${DEPS}/gm
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --without-magick-plus-plus && make install-strip
-
 mkdir ${DEPS}/jpeg
-curl -Ls http://heanet.dl.sourceforge.net/project/libjpeg-turbo/${VERSION_JPEG}/libjpeg-turbo-${VERSION_JPEG}.tar.gz | tar xzC ${DEPS}/jpeg --strip-components=1
+curl -Ls https://github.com/libjpeg-turbo/libjpeg-turbo/archive/${VERSION_JPEG}.tar.gz | tar xzC ${DEPS}/jpeg --strip-components=1
 cd ${DEPS}/jpeg
-./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-jpeg8 --without-turbojpeg && make install-strip
+autoreconf -fiv && ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-jpeg8 --without-turbojpeg && make install-strip
 
 mkdir ${DEPS}/png16
-curl -Ls http://heanet.dl.sourceforge.net/project/libpng/libpng16/${VERSION_PNG16}/libpng-${VERSION_PNG16}.tar.xz | tar xJC ${DEPS}/png16 --strip-components=1
+curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/libpng/libpng16/${VERSION_PNG16}/libpng-${VERSION_PNG16}.tar.xz | tar xJC ${DEPS}/png16 --strip-components=1
 cd ${DEPS}/png16
 ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
 
@@ -99,11 +106,69 @@ curl -Ls http://gstreamer.freedesktop.org/data/src/orc/orc-${VERSION_ORC}.tar.xz
 cd ${DEPS}/orc
 ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
 
+mkdir ${DEPS}/gdkpixbuf
+curl -Ls https://download.gnome.org/sources/gdk-pixbuf/2.34/gdk-pixbuf-${VERSION_GDKPIXBUF}.tar.xz | tar xJC ${DEPS}/gdkpixbuf --strip-components=1
+cd ${DEPS}/gdkpixbuf
+LD_LIBRARY_PATH=${TARGET}/lib ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
+  --disable-introspection --disable-modules --without-libpng --without-libjpeg --without-libtiff --without-gdiplus --with-included-loaders= \
+  && make install-strip
+
+mkdir ${DEPS}/freetype
+curl -Ls http://download.savannah.gnu.org/releases/freetype/freetype-${VERSION_FREETYPE}.tar.gz | tar xzC ${DEPS}/freetype --strip-components=1
+cd ${DEPS}/freetype
+./configure --prefix=${TARGET} --enable-shared --disable-static && make install
+
+mkdir ${DEPS}/fontconfig
+curl -Ls https://www.freedesktop.org/software/fontconfig/release/fontconfig-${VERSION_FONTCONFIG}.tar.bz2 | tar xjC ${DEPS}/fontconfig --strip-components=1
+cd ${DEPS}/fontconfig
+./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --enable-libxml2 && make install-strip
+
+mkdir ${DEPS}/harfbuzz
+curl -Ls https://www.freedesktop.org/software/harfbuzz/release/harfbuzz-${VERSION_HARFBUZZ}.tar.bz2 | tar xjC ${DEPS}/harfbuzz --strip-components=1
+cd ${DEPS}/harfbuzz
+./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
+
+mkdir ${DEPS}/pixman
+curl -Ls http://cairographics.org/releases/pixman-${VERSION_PIXMAN}.tar.gz | tar xzC ${DEPS}/pixman --strip-components=1
+cd ${DEPS}/pixman
+./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-libpng --disable-arm-iwmmxt && make install-strip
+
+mkdir ${DEPS}/cairo
+curl -Ls http://cairographics.org/releases/cairo-${VERSION_CAIRO}.tar.xz | tar xJC ${DEPS}/cairo --strip-components=1
+cd ${DEPS}/cairo
+./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
+  --disable-xlib --disable-xcb --disable-quartz --disable-win32 --disable-egl --disable-glx --disable-wgl \
+  --disable-script --disable-ps --disable-gobject --disable-trace --disable-interpreter \
+  && make install-strip
+
+mkdir ${DEPS}/pango
+curl -Ls https://download.gnome.org/sources/pango/1.40/pango-${VERSION_PANGO}.tar.xz | tar xJC ${DEPS}/pango --strip-components=1
+cd ${DEPS}/pango
+./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
+
+mkdir ${DEPS}/croco
+curl -Ls https://download.gnome.org/sources/libcroco/0.6/libcroco-${VERSION_CROCO}.tar.xz | tar xJC ${DEPS}/croco --strip-components=1
+cd ${DEPS}/croco
+./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
+
+mkdir ${DEPS}/svg
+curl -Ls https://download.gnome.org/sources/librsvg/2.40/librsvg-${VERSION_SVG}.tar.xz | tar xJC ${DEPS}/svg --strip-components=1
+cd ${DEPS}/svg
+./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
+  --disable-introspection --disable-tools \
+  && make install-strip
+
+mkdir ${DEPS}/gif
+curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/giflib/giflib-${VERSION_GIF}.tar.gz | tar xzC ${DEPS}/gif --strip-components=1
+cd ${DEPS}/gif
+./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
+
 mkdir ${DEPS}/vips
-curl -Ls http://www.vips.ecs.soton.ac.uk/supported/8.2/vips-${VERSION_VIPS}.tar.gz | tar xzC ${DEPS}/vips --strip-components=1
+curl -Ls http://www.vips.ecs.soton.ac.uk/supported/8.3/vips-${VERSION_VIPS}.tar.gz | tar xzC ${DEPS}/vips --strip-components=1
 cd ${DEPS}/vips
 ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
-  --disable-debug --disable-introspection --without-python --without-fftw --with-magickpackage=GraphicsMagick \
+  --disable-debug --disable-introspection --without-python --without-fftw \
+  --without-magick --without-pangoft2 --without-ppm --without-analyze --without-radiance \
   --with-zip-includes=${TARGET}/include --with-zip-libraries=${TARGET}/lib \
   --with-jpeg-includes=${TARGET}/include --with-jpeg-libraries=${TARGET}/lib \
   && make install-strip
@@ -117,20 +182,29 @@ rm -rf pkgconfig .libs *.la libvipsCC*
 # Create JSON file of version numbers
 cd ${TARGET}
 echo "{\n\
+  \"cairo\": \"${VERSION_CAIRO}\",\n\
+  \"croco\": \"${VERSION_CROCO}\",\n\
   \"exif\": \"${VERSION_EXIF}\",\n\
   \"ffi\": \"${VERSION_FFI}\",\n\
+  \"fontconfig\": \"${VERSION_FONTCONFIG}\",\n\
+  \"freetype\": \"${VERSION_FREETYPE}\",\n\
+  \"gdkpixbuf\": \"${VERSION_GDKPIXBUF}\",\n\
+  \"gif\": \"${VERSION_GIF}\",\n\
   \"glib\": \"${VERSION_GLIB}\",\n\
   \"gsf\": \"${VERSION_GSF}\",\n\
+  \"harfbuzz\": \"${VERSION_HARFBUZZ}\",\n\
   \"jpeg\": \"${VERSION_JPEG}\",\n\
   \"lcms\": \"${VERSION_LCMS2}\",\n\
-  \"gm\": \"${VERSION_GM}\",\n\
   \"orc\": \"${VERSION_ORC}\",\n\
+  \"pango\": \"${VERSION_PANGO}\",\n\
+  \"pixman\": \"${VERSION_PIXMAN}\",\n\
   \"png\": \"${VERSION_PNG16}\",\n\
+  \"svg\": \"${VERSION_SVG}\",\n\
   \"tiff\": \"${VERSION_TIFF}\",\n\
-  \"vips\": \"${VERSION_VIPS}\"\n\
+  \"vips\": \"${VERSION_VIPS}\",\n\
   \"webp\": \"${VERSION_WEBP}\",\n\
   \"xml\": \"${VERSION_XML2}\",\n\
-  \"zlib\": \"${VERSION_ZLIB}\",\n\
+  \"zlib\": \"${VERSION_ZLIB}\"\n\
 }" >lib/versions.json
 
 # Create .tar.gz

packaging/build.sh

@@ -1,5 +1,7 @@
 #!/bin/sh
 
+VERSION_VIPS=8.3.1
+
 # Is docker available?
 
 if ! type docker >/dev/null; then
@@ -7,21 +9,21 @@ if ! type docker >/dev/null; then
   exit 1
 fi
 
-# TODO: docker v1.9.0 will allow build-time args - https://github.com/docker/docker/pull/15182
+# TODO: docker v1.9.0 allows build-time args - https://github.com/docker/docker/pull/15182
 
 # Windows
 
 docker build -t vips-dev-win win
 WIN_CONTAINER_ID=$(docker run -d vips-dev-win)
-docker cp $WIN_CONTAINER_ID:/libvips-8.2.2-win.tar.gz .
+docker cp "${WIN_CONTAINER_ID}:/libvips-${VERSION_VIPS}-win.tar.gz" .
-docker rm $WIN_CONTAINER_ID
+docker rm "${WIN_CONTAINER_ID}"
 
 # Linux
 
 docker build -t vips-dev-lin lin
 LIN_CONTAINER_ID=$(docker run -d vips-dev-lin)
-docker cp $LIN_CONTAINER_ID:/libvips-8.2.2-lin.tar.gz .
+docker cp "${LIN_CONTAINER_ID}:/libvips-${VERSION_VIPS}-lin.tar.gz" .
-docker rm $LIN_CONTAINER_ID
+docker rm "${LIN_CONTAINER_ID}"
 
 # Checksums
 

packaging/lin/Dockerfile

@@ -10,28 +10,40 @@ ENV DEPS=/deps \
 RUN mkdir ${DEPS} && mkdir ${TARGET}
 
 # Common build paths and flags
-ENV PKG_CONFIG_PATH=${PKG_CONFIG_PATH}:${TARGET}/lib/pkgconfig \
+ENV PKG_CONFIG_PATH="${PKG_CONFIG_PATH}:${TARGET}/lib/pkgconfig" \
-    PATH=${PATH}:${TARGET}/bin \
+    PATH="${PATH}:${TARGET}/bin" \
-    CPPFLAGS=-I${TARGET}/include \
+    CPPFLAGS="-I${TARGET}/include" \
-    LDFLAGS=-L${TARGET}/lib \
+    LDFLAGS="-L${TARGET}/lib" \
     CFLAGS="-O3" \
     CXXFLAGS="-O3"
 
 # Dependency version numbers
 ENV VERSION_ZLIB=1.2.8 \
     VERSION_FFI=3.2.1 \
-    VERSION_GLIB=2.47.5 \
+    VERSION_GLIB=2.48.0 \
     VERSION_XML2=2.9.3 \
-    VERSION_GSF=1.14.34 \
+    VERSION_GSF=1.14.36 \
     VERSION_EXIF=0.6.21 \
     VERSION_LCMS2=2.7 \
-    VERSION_GM=1.3.23 \
+    VERSION_JPEG=1.4.90 \
-    VERSION_JPEG=1.4.2 \
     VERSION_PNG16=1.6.21 \
     VERSION_WEBP=0.5.0 \
     VERSION_TIFF=4.0.6 \
-    VERSION_ORC=0.4.24 \
+    VERSION_ORC=0.4.25 \
-    VERSION_VIPS=8.2.2
+    VERSION_GDKPIXBUF=2.34.0 \
+    VERSION_FREETYPE=2.6.3 \
+    VERSION_FONTCONFIG=2.11.95 \
+    VERSION_HARFBUZZ=1.2.6 \
+    VERSION_PIXMAN=0.34.0 \
+    VERSION_CAIRO=1.14.6 \
+    VERSION_PANGO=1.40.1 \
+    VERSION_CROCO=0.6.11 \
+    VERSION_SVG=2.40.15 \
+    VERSION_GIF=5.1.4 \
+    VERSION_VIPS=8.3.1
+
+# Least out-of-sync Sourceforge mirror
+ENV SOURCEFORGE_MIRROR=netix
 
 RUN mkdir ${DEPS}/zlib
 RUN curl -Ls http://zlib.net/zlib-${VERSION_ZLIB}.tar.xz | tar xJC ${DEPS}/zlib --strip-components=1
@@ -45,14 +57,18 @@ WORKDIR ${DEPS}/ffi
 RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-builddir && make install-strip
 
 RUN mkdir ${DEPS}/glib
-RUN curl -Ls https://download.gnome.org/sources/glib/2.47/glib-${VERSION_GLIB}.tar.xz | tar xJC ${DEPS}/glib --strip-components=1
+RUN curl -Ls https://download.gnome.org/sources/glib/2.48/glib-${VERSION_GLIB}.tar.xz | tar xJC ${DEPS}/glib --strip-components=1
 WORKDIR ${DEPS}/glib
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-pcre=internal && make install-strip
+RUN CFLAGS="${CFLAGS} -Wl,--default-symver" CXXFLAGS="${CXXFLAGS} -Wl,--default-symver" \
+  ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-pcre=internal && make install-strip
 
 RUN mkdir ${DEPS}/xml2
 RUN curl -Ls http://xmlsoft.org/sources/libxml2-${VERSION_XML2}.tar.gz | tar xzC ${DEPS}/xml2 --strip-components=1
 WORKDIR ${DEPS}/xml2
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --without-python --with-zlib=${TARGET} && make install-strip
+RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
+  --without-python --without-debug --without-docbook --without-ftp --without-html --without-legacy \
+  --without-pattern --without-push --without-regexps --without-schemas --without-schematron --with-zlib=${TARGET} \
+  && make install-strip
 
 RUN mkdir ${DEPS}/gsf
 RUN curl -Ls https://download.gnome.org/sources/libgsf/1.14/libgsf-${VERSION_GSF}.tar.xz | tar xJC ${DEPS}/gsf --strip-components=1
@@ -60,27 +76,22 @@ WORKDIR ${DEPS}/gsf
 RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
 
 RUN mkdir ${DEPS}/exif
-RUN curl -Ls http://heanet.dl.sourceforge.net/project/libexif/libexif/${VERSION_EXIF}/libexif-${VERSION_EXIF}.tar.bz2 | tar xjC ${DEPS}/exif --strip-components=1
+RUN curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/libexif/libexif/${VERSION_EXIF}/libexif-${VERSION_EXIF}.tar.bz2 | tar xjC ${DEPS}/exif --strip-components=1
 WORKDIR ${DEPS}/exif
 RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
 
 RUN mkdir ${DEPS}/lcms2
-RUN curl -Ls http://heanet.dl.sourceforge.net/project/lcms/lcms/${VERSION_LCMS2}/lcms2-${VERSION_LCMS2}.tar.gz | tar xzC ${DEPS}/lcms2 --strip-components=1
+RUN curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/lcms/lcms/${VERSION_LCMS2}/lcms2-${VERSION_LCMS2}.tar.gz | tar xzC ${DEPS}/lcms2 --strip-components=1
 WORKDIR ${DEPS}/lcms2
 RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
 
-RUN mkdir ${DEPS}/gm
-RUN curl -Ls http://heanet.dl.sourceforge.net/project/graphicsmagick/graphicsmagick/${VERSION_GM}/GraphicsMagick-${VERSION_GM}.tar.xz | tar xJC ${DEPS}/gm --strip-components=1
-WORKDIR ${DEPS}/gm
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --without-magick-plus-plus && make install-strip
-
 RUN mkdir ${DEPS}/jpeg
-RUN curl -Ls http://heanet.dl.sourceforge.net/project/libjpeg-turbo/${VERSION_JPEG}/libjpeg-turbo-${VERSION_JPEG}.tar.gz | tar xzC ${DEPS}/jpeg --strip-components=1
+RUN curl -Ls https://github.com/libjpeg-turbo/libjpeg-turbo/archive/${VERSION_JPEG}.tar.gz | tar xzC ${DEPS}/jpeg --strip-components=1
 WORKDIR ${DEPS}/jpeg
-RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-jpeg8 --without-turbojpeg && make install-strip
+RUN autoreconf -fiv && ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --with-jpeg8 --without-turbojpeg && make install-strip
 
 RUN mkdir ${DEPS}/png16
-RUN curl -Ls http://heanet.dl.sourceforge.net/project/libpng/libpng16/${VERSION_PNG16}/libpng-${VERSION_PNG16}.tar.xz | tar xJC ${DEPS}/png16 --strip-components=1
+RUN curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/libpng/libpng16/${VERSION_PNG16}/libpng-${VERSION_PNG16}.tar.xz | tar xJC ${DEPS}/png16 --strip-components=1
 WORKDIR ${DEPS}/png16
 RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
 
@@ -99,12 +110,74 @@ RUN mkdir ${DEPS}/orc
 RUN curl -Ls http://gstreamer.freedesktop.org/data/src/orc/orc-${VERSION_ORC}.tar.xz | tar xJC ${DEPS}/orc --strip-components=1
 WORKDIR ${DEPS}/orc
 RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
+RUN rm ${TARGET}/lib/liborc-test-*
+
+RUN mkdir ${DEPS}/gdkpixbuf
+RUN curl -Ls https://download.gnome.org/sources/gdk-pixbuf/2.34/gdk-pixbuf-${VERSION_GDKPIXBUF}.tar.xz | tar xJC ${DEPS}/gdkpixbuf --strip-components=1
+WORKDIR ${DEPS}/gdkpixbuf
+RUN LD_LIBRARY_PATH=${TARGET}/lib ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
+  --disable-introspection --disable-modules --without-libpng --without-libjpeg --without-libtiff --without-gdiplus --with-included-loaders= \
+  && make install-strip
+
+RUN mkdir ${DEPS}/freetype
+RUN curl -Ls http://download.savannah.gnu.org/releases/freetype/freetype-${VERSION_FREETYPE}.tar.gz | tar xzC ${DEPS}/freetype --strip-components=1
+WORKDIR ${DEPS}/freetype
+RUN ./configure --prefix=${TARGET} --enable-shared --disable-static && make install
+
+RUN mkdir ${DEPS}/fontconfig
+RUN curl -Ls https://www.freedesktop.org/software/fontconfig/release/fontconfig-${VERSION_FONTCONFIG}.tar.bz2 | tar xjC ${DEPS}/fontconfig --strip-components=1
+WORKDIR ${DEPS}/fontconfig
+RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --enable-libxml2 && make install-strip
+
+RUN mkdir ${DEPS}/harfbuzz
+RUN curl -Ls https://www.freedesktop.org/software/harfbuzz/release/harfbuzz-${VERSION_HARFBUZZ}.tar.bz2 | tar xjC ${DEPS}/harfbuzz --strip-components=1
+WORKDIR ${DEPS}/harfbuzz
+RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
+
+RUN mkdir ${DEPS}/pixman
+RUN curl -Ls http://cairographics.org/releases/pixman-${VERSION_PIXMAN}.tar.gz | tar xzC ${DEPS}/pixman --strip-components=1
+WORKDIR ${DEPS}/pixman
+RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking --disable-libpng && make install-strip
+
+RUN mkdir ${DEPS}/cairo
+RUN curl -Ls http://cairographics.org/releases/cairo-${VERSION_CAIRO}.tar.xz | tar xJC ${DEPS}/cairo --strip-components=1
+WORKDIR ${DEPS}/cairo
+RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
+  --disable-xlib --disable-xcb --disable-quartz --disable-win32 --disable-egl --disable-glx --disable-wgl \
+  --disable-script --disable-ps --disable-gobject --disable-trace --disable-interpreter \
+  && make install-strip
+
+RUN mkdir ${DEPS}/pango
+RUN curl -Ls https://download.gnome.org/sources/pango/1.40/pango-${VERSION_PANGO}.tar.xz | tar xJC ${DEPS}/pango --strip-components=1
+WORKDIR ${DEPS}/pango
+RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
+
+RUN mkdir ${DEPS}/croco
+RUN curl -Ls https://download.gnome.org/sources/libcroco/0.6/libcroco-${VERSION_CROCO}.tar.xz | tar xJC ${DEPS}/croco --strip-components=1
+WORKDIR ${DEPS}/croco
+RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
+
+RUN mkdir ${DEPS}/svg
+RUN curl -Ls https://download.gnome.org/sources/librsvg/2.40/librsvg-${VERSION_SVG}.tar.xz | tar xJC ${DEPS}/svg --strip-components=1
+WORKDIR ${DEPS}/svg
+RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
+  --disable-introspection --disable-tools \
+  && make install-strip
+
+RUN mkdir ${DEPS}/gif
+RUN curl -Ls http://${SOURCEFORGE_MIRROR}.dl.sourceforge.net/project/giflib/giflib-${VERSION_GIF}.tar.gz | tar xzC ${DEPS}/gif --strip-components=1
+WORKDIR ${DEPS}/gif
+RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking && make install-strip
 
 RUN mkdir ${DEPS}/vips
-RUN curl -Ls http://www.vips.ecs.soton.ac.uk/supported/8.2/vips-${VERSION_VIPS}.tar.gz | tar xzC ${DEPS}/vips --strip-components=1
+RUN curl -Ls http://www.vips.ecs.soton.ac.uk/supported/8.3/vips-${VERSION_VIPS}.tar.gz | tar xzC ${DEPS}/vips --strip-components=1
+#RUN apt-get install -y swig gobject-introspection gettext glib2.0-dev
+#RUN curl -Ls https://github.com/jcupitt/libvips/archive/master.tar.gz | tar xzC ${DEPS}/vips --strip-components=1
 WORKDIR ${DEPS}/vips
+#RUN ./bootstrap.sh
 RUN ./configure --prefix=${TARGET} --enable-shared --disable-static --disable-dependency-tracking \
-  --disable-debug --disable-introspection --without-python --without-fftw --with-magickpackage=GraphicsMagick \
+  --disable-debug --disable-introspection --without-python --without-fftw \
+  --without-magick --without-pangoft2 --without-ppm --without-analyze --without-radiance \
   --with-zip-includes=${TARGET}/include --with-zip-libraries=${TARGET}/lib \
   --with-jpeg-includes=${TARGET}/include --with-jpeg-libraries=${TARGET}/lib \
   && make install-strip
@@ -118,20 +191,29 @@ RUN rm -rf pkgconfig .libs *.la libvipsCC*
 # Create JSON file of version numbers
 WORKDIR ${TARGET}
 RUN echo "{\n\
+  \"cairo\": \"${VERSION_CAIRO}\",\n\
+  \"croco\": \"${VERSION_CROCO}\",\n\
   \"exif\": \"${VERSION_EXIF}\",\n\
   \"ffi\": \"${VERSION_FFI}\",\n\
+  \"fontconfig\": \"${VERSION_FONTCONFIG}\",\n\
+  \"freetype\": \"${VERSION_FREETYPE}\",\n\
+  \"gdkpixbuf\": \"${VERSION_GDKPIXBUF}\",\n\
+  \"gif\": \"${VERSION_GIF}\",\n\
   \"glib\": \"${VERSION_GLIB}\",\n\
   \"gsf\": \"${VERSION_GSF}\",\n\
+  \"harfbuzz\": \"${VERSION_HARFBUZZ}\",\n\
   \"jpeg\": \"${VERSION_JPEG}\",\n\
   \"lcms\": \"${VERSION_LCMS2}\",\n\
-  \"gm\": \"${VERSION_GM}\",\n\
   \"orc\": \"${VERSION_ORC}\",\n\
+  \"pango\": \"${VERSION_PANGO}\",\n\
+  \"pixman\": \"${VERSION_PIXMAN}\",\n\
   \"png\": \"${VERSION_PNG16}\",\n\
+  \"svg\": \"${VERSION_SVG}\",\n\
   \"tiff\": \"${VERSION_TIFF}\",\n\
-  \"vips\": \"${VERSION_VIPS}\"\n\
+  \"vips\": \"${VERSION_VIPS}\",\n\
   \"webp\": \"${VERSION_WEBP}\",\n\
   \"xml\": \"${VERSION_XML2}\",\n\
-  \"zlib\": \"${VERSION_ZLIB}\",\n\
+  \"zlib\": \"${VERSION_ZLIB}\"\n\
 }" >lib/versions.json
 
 # Create .tar.gz

packaging/test.sh

@@ -6,34 +6,33 @@ if ! type docker >/dev/null; then
   exit 1
 fi
 
+version_node=4.4.2
+
 test="npm run clean; npm install --unsafe-perm; npm test"
 
 # Debian 7, 8
-# Ubuntu 12.04, 14.04
+# Ubuntu 14.04
-for dist in wheezy jessie precise trusty; do
+for dist in wheezy jessie trusty; do
   echo "Testing $dist..."
-  if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/$dist:0.12 >packaging/$dist.log 2>&1 sh -c "cd /v; ./packaging/test/debian.sh; $test";
+  if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/$dist:$version_node >packaging/$dist.log 2>&1 sh -c "cd /v; ./packaging/test/debian.sh; $test";
   then echo "$dist OK"
   else echo "$dist fail" && cat packaging/$dist.log
   fi
 done
 
-# Centos 6
-echo "Testing centos6..."
-if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/centos6:0.12 >packaging/centos6.log 2>&1 sh -c "cd /v; source ./packaging/test/centos6.sh; ./preinstall.sh; $test";
-then echo "centos6 OK"
-else echo "centos6 fail" && cat packaging/centos6.log
-fi
-
 # Centos 7
-# Fedora 20, 21
+echo "Testing centos7..."
-for dist in centos7 fedora20 fedora21; do
+if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/centos7:$version_node >packaging/$dist.log 2>&1 sh -c "cd /v; $test";
-  echo "Testing $dist..."
+then echo "$dist OK"
-  if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/$dist:0.12 >packaging/$dist.log 2>&1 sh -c "cd /v; $test";
+else echo "$dist fail" && cat packaging/$dist.log
+fi
+
+# Fedora 22
+echo "Testing fedora22..."
+if docker run -i -t --rm -v $PWD:/v -e "NODE_ENV=development" nodesource/fedora22:$version_node >packaging/$dist.log 2>&1 sh -c "cd /v; $test";
 then echo "$dist OK"
 else echo "$dist fail" && cat packaging/$dist.log
 fi
-done
 
 # openSUSE 13.2
 echo "Testing opensuse..."

packaging/test/centos6.sh

@@ -1,8 +0,0 @@
-#!/bin/sh
-
-# Install C++11 compatible version of g++ on Centos 6
-curl -o /etc/yum.repos.d/devtools-1.1.repo http://people.centos.org/tru/devtools-1.1/devtools-1.1.repo
-yum install -y devtoolset-1.1
-export CC=/opt/centos/devtoolset-1.1/root/usr/bin/gcc
-export CPP=/opt/centos/devtoolset-1.1/root/usr/bin/cpp
-export CXX=/opt/centos/devtoolset-1.1/root/usr/bin/c++

packaging/test/opensuse.sh

@@ -3,5 +3,5 @@
 # Install Node.js on openSUSE 13.2
 zypper addrepo http://download.opensuse.org/repositories/devel:languages:nodejs/openSUSE_13.2/devel:languages:nodejs.repo
 zypper --gpg-auto-import-keys refresh
-zypper --non-interactive install gcc-c++ make nodejs-devel nodejs-npm
+zypper --non-interactive install gcc-c++ make nodejs-devel npm
 npm install -g npm

packaging/win/Dockerfile

@@ -1,18 +1,20 @@
-FROM ubuntu:precise
+FROM debian:wheezy
 MAINTAINER Lovell Fuller <npm@lovell.info>
 
 RUN apt-get update && apt-get install -y curl zip
 
+ENV VERSION_VIPS=8.3.1
+
 # Fetch and unzip
 RUN mkdir /vips
 WORKDIR /vips
-RUN curl -O http://www.vips.ecs.soton.ac.uk/supported/8.2/win32/vips-dev-w64-8.2.2.zip
+RUN curl -L -O https://github.com/lovell/build-win64/releases/download/v${VERSION_VIPS}/vips-dev-w64-web-${VERSION_VIPS}.zip
-RUN unzip vips-dev-w64-8.2.2.zip
+RUN unzip vips-dev-w64-web-${VERSION_VIPS}.zip
 
 # Clean and zip
-WORKDIR /vips/vips-dev-8.2
+WORKDIR /vips/vips-dev-8.3
-RUN rm bin/libvipsCC-42.dll bin/libvips-cpp-42.dll bin/libgsf-win32-1-114.dll bin/libstdc++-6.dll
+RUN rm bin/libvipsCC-42.dll bin/libvips-cpp-42.dll bin/libgsf-win32-1-114.dll
 RUN cp bin/*.dll lib/
 RUN cp -r lib64/* lib/
 
-RUN GZIP=-9 tar czf /libvips-8.2.2-win.tar.gz include lib/glib-2.0 lib/libvips.lib lib/libglib-2.0.lib lib/libgobject-2.0.lib lib/*.dll
+RUN GZIP=-9 tar czf /libvips-${VERSION_VIPS}-win.tar.gz include lib/glib-2.0 lib/libvips.lib lib/libglib-2.0.lib lib/libgobject-2.0.lib lib/*.dll

preinstall.sh

@@ -1,28 +1,19 @@
 #!/bin/sh
 
-# This script is no longer required on most
+# Use of this script is deprecated
-# 64-bit Linux systems when using sharp v0.12.0+
 
-# See http://sharp.dimens.io/page/install#linux
+echo
+echo "WARNING: This script is no longer required on most 64-bit Linux systems when using sharp v0.12.0+"
+echo
+echo "See http://sharp.dimens.io/page/install#linux"
+echo
+echo "If you really, really need this script, it will attempt"
+echo "to globally install libvips if not already available."
+echo
 
-# If you really need this script, it will attempt to
+vips_version_minimum=8.3.1
-# globally install libvips if not already available.
+vips_version_latest_major_minor=8.3
-
+vips_version_latest_patch=1
-# Supports:
-# * Debian Linux
-#   * Debian 7, 8
-#   * Ubuntu 12.04, 14.04, 14.10, 15.04, 15.10
-#   * Mint 13, 17
-#   * Elementary 0.3
-# * Red Hat Linux
-#   * RHEL/Centos/Scientific 6, 7
-#   * Fedora 21, 22, 23
-#   * Amazon Linux 2015.03, 2015.09
-# * OpenSuse 13
-
-vips_version_minimum=8.2.2
-vips_version_latest_major_minor=8.2
-vips_version_latest_patch=2
 
 openslide_version_minimum=3.4.0
 openslide_version_latest_major_minor=3.4
@@ -33,7 +24,7 @@ install_libvips_from_source() {
   curl -O http://www.vips.ecs.soton.ac.uk/supported/$vips_version_latest_major_minor/vips-$vips_version_latest_major_minor.$vips_version_latest_patch.tar.gz
   tar zvxf vips-$vips_version_latest_major_minor.$vips_version_latest_patch.tar.gz
   cd vips-$vips_version_latest_major_minor.$vips_version_latest_patch
-  ./configure --disable-debug --disable-docs --disable-static --disable-introspection --disable-dependency-tracking --enable-cxx=yes --without-python --without-orc --without-fftw $1
+  CXXFLAGS="-D_GLIBCXX_USE_CXX11_ABI=0" ./configure --disable-debug --disable-docs --disable-static --disable-introspection --disable-dependency-tracking --enable-cxx=yes --without-python --without-orc --without-fftw $1
   make
   make install
   cd ..
@@ -139,7 +130,7 @@ if [ $enable_openslide -eq 1 ] && [ -z $vips_with_openslide ] && [ $openslide_ex
     DISTRO=$(lsb_release -c -s)
     echo "Detected Debian Linux '$DISTRO'"
     case "$DISTRO" in
-      jessie|vivid|wily)
+      jessie|vivid|wily|xenial)
         # Debian 8, Ubuntu 15
         echo "Installing libopenslide via apt-get"
         apt-get install -y libopenslide-dev

src/common.cc

@@ -8,16 +8,16 @@
 // Verify platform and compiler compatibility
 
 #if (VIPS_MAJOR_VERSION < 8 || (VIPS_MAJOR_VERSION == 8 && VIPS_MINOR_VERSION < 2))
-#error libvips version 8.2.0+ required - see http://sharp.dimens.io/page/install
+#error libvips version 8.2.0+ required - see sharp.dimens.io/page/install
 #endif
 
 #if ((!defined(__clang__)) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)))
-#error GCC version 4.6+ is required for C++11 features - see http://sharp.dimens.io/page/install#prerequisites
+#error GCC version 4.6+ is required for C++11 features - see sharp.dimens.io/page/install#prerequisites
 #endif
 
 #if (defined(__clang__) && defined(__has_feature))
 #if (!__has_feature(cxx_range_for))
-#error clang version 3.0+ is required for C++11 features - see http://sharp.dimens.io/page/install#prerequisites
+#error clang version 3.0+ is required for C++11 features - see sharp.dimens.io/page/install#prerequisites
 #endif
 #endif
 
@@ -52,6 +52,12 @@ namespace sharp {
   bool IsDz(std::string const &str) {
     return EndsWith(str, ".dzi") || EndsWith(str, ".DZI");
   }
+  bool IsDzZip(std::string const &str) {
+    return EndsWith(str, ".zip") || EndsWith(str, ".ZIP") || EndsWith(str, ".szi") || EndsWith(str, ".SZI");
+  }
+  bool IsV(std::string const &str) {
+    return EndsWith(str, ".v") || EndsWith(str, ".V") || EndsWith(str, ".vips") || EndsWith(str, ".VIPS");
+  }
 
   /*
     Provide a string identifier for the given image type.
@@ -63,10 +69,14 @@ namespace sharp {
       case ImageType::PNG: id = "png"; break;
       case ImageType::WEBP: id = "webp"; break;
       case ImageType::TIFF: id = "tiff"; break;
+      case ImageType::GIF: id = "gif"; break;
+      case ImageType::SVG: id = "svg"; break;
+      case ImageType::PDF: id = "pdf"; break;
       case ImageType::MAGICK: id = "magick"; break;
       case ImageType::OPENSLIDE: id = "openslide"; break;
       case ImageType::PPM: id = "ppm"; break;
       case ImageType::FITS: id = "fits"; break;
+      case ImageType::VIPS: id = "v"; break;
       case ImageType::RAW: id = "raw"; break;
       case ImageType::UNKNOWN: id = "unknown"; break;
     }
@@ -89,6 +99,12 @@ namespace sharp {
         imageType = ImageType::WEBP;
       } else if (EndsWith(loader, "TiffBuffer")) {
         imageType = ImageType::TIFF;
+      } else if (EndsWith(loader, "GifBuffer")) {
+        imageType = ImageType::GIF;
+      } else if (EndsWith(loader, "SvgBuffer")) {
+        imageType = ImageType::SVG;
+      } else if (EndsWith(loader, "PdfBuffer")) {
+        imageType = ImageType::PDF;
       } else if (EndsWith(loader, "MagickBuffer")) {
         imageType = ImageType::MAGICK;
       }
@@ -114,10 +130,18 @@ namespace sharp {
         imageType = ImageType::OPENSLIDE;
       } else if (EndsWith(loader, "TiffFile")) {
         imageType = ImageType::TIFF;
+      } else if (EndsWith(loader, "GifFile")) {
+        imageType = ImageType::GIF;
+      } else if (EndsWith(loader, "SvgFile")) {
+        imageType = ImageType::SVG;
+      } else if (EndsWith(loader, "PdfFile")) {
+        imageType = ImageType::PDF;
       } else if (EndsWith(loader, "Ppm")) {
         imageType = ImageType::PPM;
       } else if (EndsWith(loader, "Fits")) {
         imageType = ImageType::FITS;
+      } else if (EndsWith(loader, "Vips")) {
+        imageType = ImageType::VIPS;
       } else if (EndsWith(loader, "Magick") || EndsWith(loader, "MagickFile")) {
         imageType = ImageType::MAGICK;
       }
@@ -176,6 +200,30 @@ namespace sharp {
     SetExifOrientation(image, 0);
   }
 
+  /*
+    Does this image have a non-default density?
+  */
+  bool HasDensity(VImage image) {
+    return image.xres() > 1.0;
+  }
+
+  /*
+    Get pixels/mm resolution as pixels/inch density.
+  */
+  int GetDensity(VImage image) {
+    return static_cast<int>(round(image.xres() * 25.4));
+  }
+
+  /*
+    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;
+    image.set("Xres", pixelsPerMm);
+    image.set("Yres", pixelsPerMm);
+    image.set(VIPS_META_RESOLUTION_UNIT, "in");
+  }
+
   /*
     Called when a Buffer undergoes GC, required to support mixed runtime libraries in Windows
   */
@@ -185,4 +233,113 @@ namespace sharp {
     }
   }
 
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given gravity.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const gravity) {
+
+    int left = 0;
+    int top = 0;
+    switch (gravity) {
+      case 1:
+        // North
+        left = (inWidth - outWidth + 1) / 2;
+        break;
+      case 2:
+        // East
+        left = inWidth - outWidth;
+        top = (inHeight - outHeight + 1) / 2;
+        break;
+      case 3:
+        // South
+        left = (inWidth - outWidth + 1) / 2;
+        top = inHeight - outHeight;
+        break;
+      case 4:
+        // West
+        top = (inHeight - outHeight + 1) / 2;
+        break;
+      case 5:
+        // Northeast
+        left = inWidth - outWidth;
+        break;
+      case 6:
+        // Southeast
+        left = inWidth - outWidth;
+        top = inHeight - outHeight;
+      case 7:
+        // Southwest
+        top = inHeight - outHeight;
+      case 8:
+        // Northwest
+        break;
+      default:
+        // Centre
+        left = (inWidth - outWidth + 1) / 2;
+        top = (inHeight - outHeight + 1) / 2;
+    }
+    return std::make_tuple(left, top);
+  }
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given x and y offsets.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const x, int const y) {
+
+    // default values
+    int left = 0;
+    int top = 0;
+
+    // assign only if valid
+    if(x >= 0 && x < (inWidth - outWidth)) {
+      left = x;
+    } else if(x >= (inWidth - outWidth)) {
+      left = inWidth - outWidth;
+    }
+
+    if(y >= 0 && y < (inHeight - outHeight)) {
+      top = y;
+    } else if(x >= (inHeight - outHeight)) {
+      top = inHeight - outHeight;
+    }
+
+    // the resulting left and top could have been outside the image after calculation from bottom/right edges
+    if(left < 0) {
+      left = 0;
+    }
+    if(top < 0) {
+      top = 0;
+    }
+
+    return std::make_tuple(left, top);
+  }
+
+  /*
+    Are pixel values in this image 16-bit integer?
+  */
+  bool Is16Bit(VipsInterpretation const interpretation) {
+    return interpretation == VIPS_INTERPRETATION_RGB16 || interpretation == VIPS_INTERPRETATION_GREY16;
+  }
+
+  /*
+    Return the image alpha maximum. Useful for combining alpha bands. scRGB
+    images are 0 - 1 for image data, but the alpha is 0 - 255.
+  */
+  double MaximumImageAlpha(VipsInterpretation const interpretation) {
+    return Is16Bit(interpretation) ? 65535.0 : 255.0;
+  }
+
+  /*
+    Get boolean operation type from string
+  */
+  VipsOperationBoolean GetBooleanOperation(std::string const opStr) {
+    return static_cast<VipsOperationBoolean>(
+      vips_enum_from_nick(nullptr, VIPS_TYPE_OPERATION_BOOLEAN, opStr.data())
+    );
+  }
+
 }  // namespace sharp

src/common.h

@@ -2,6 +2,8 @@
 #define SRC_COMMON_H_
 
 #include <string>
+#include <tuple>
+
 #include <vips/vips8>
 
 using vips::VImage;
@@ -9,16 +11,20 @@ using vips::VImage;
 namespace sharp {
 
   enum class ImageType {
-    UNKNOWN,
     JPEG,
     PNG,
     WEBP,
     TIFF,
+    GIF,
+    SVG,
+    PDF,
     MAGICK,
     OPENSLIDE,
     PPM,
     FITS,
-    RAW
+    VIPS,
+    RAW,
+    UNKNOWN
   };
 
   // How many tasks are in the queue?
@@ -33,6 +39,8 @@ namespace sharp {
   bool IsWebp(std::string const &str);
   bool IsTiff(std::string const &str);
   bool IsDz(std::string const &str);
+  bool IsDzZip(std::string const &str);
+  bool IsV(std::string const &str);
 
   /*
     Provide a string identifier for the given image type.
@@ -75,11 +83,56 @@ namespace sharp {
   */
   void RemoveExifOrientation(VImage image);
 
+  /*
+    Does this image have a non-default density?
+  */
+  bool HasDensity(VImage image);
+
+  /*
+    Get pixels/mm resolution as pixels/inch density.
+  */
+  int GetDensity(VImage image);
+
+  /*
+    Set pixels/mm resolution based on a pixels/inch density.
+  */
+  void SetDensity(VImage image, const int density);
+
   /*
     Called when a Buffer undergoes GC, required to support mixed runtime libraries in Windows
   */
   void FreeCallback(char* data, void* hint);
 
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given gravity.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const gravity);
+
+  /*
+    Calculate the (left, top) coordinates of the output image
+    within the input image, applying the given x and y offsets of the output image.
+  */
+  std::tuple<int, int> CalculateCrop(int const inWidth, int const inHeight,
+    int const outWidth, int const outHeight, int const x, int const y);
+
+  /*
+    Are pixel values in this image 16-bit integer?
+  */
+  bool Is16Bit(VipsInterpretation const interpretation);
+
+  /*
+    Return the image alpha maximum. Useful for combining alpha bands. scRGB
+    images are 0 - 1 for image data, but the alpha is 0 - 255.
+  */
+  double MaximumImageAlpha(VipsInterpretation const interpretation);
+
+  /*
+    Get boolean operation type from string
+  */
+  VipsOperationBoolean GetBooleanOperation(std::string const opStr);
+
 }  // namespace sharp
 
 #endif  // SRC_COMMON_H_

src/libvips/cplusplus/VImage.cpp

@@ -711,4 +711,499 @@ VImage::maxpos( VOption *options )
 	return( std::complex<double>( x, y ) ); 
 }
 
+// Operator overloads
+
+VImage 
+VImage::operator[]( int index ) 
+{
+	return( this->extract_band( index ) ); 
+}
+
+std::vector<double> 
+VImage::operator()( int x, int y )
+{
+	return( this->getpoint( x, y ) ); 
+}
+
+VImage 
+operator+( VImage a, VImage b ) 
+{
+	return( a.add( b ) );
+}
+
+VImage 
+operator+( double a, VImage b ) 
+{
+	return( b.linear( 1.0, a ) ); 
+}
+
+VImage 
+operator+( VImage a, double b ) 
+{ 
+	return( a.linear( 1.0, b ) ); 
+}
+
+VImage 
+operator+( std::vector<double> a, VImage b ) 
+{
+	return( b.linear( 1.0, a ) ); 
+}
+
+VImage 
+operator+( VImage a, std::vector<double> b ) 
+{ 
+	return( a.linear( 1.0, b ) ); 
+}
+
+VImage 
+operator-( VImage a, VImage b ) 
+{
+	return( a.subtract( b ) );
+}
+
+VImage operator-( double a, VImage b ) 
+{
+	return( b.linear( -1.0, a ) ); 
+}
+
+VImage 
+operator-( VImage a, double b ) 
+{ 
+	return( a.linear( 1.0, -b ) ); 
+}
+
+VImage 
+operator-( std::vector<double> a, VImage b ) 
+{
+	return( b.linear( -1.0, a ) ); 
+}
+
+VImage 
+operator-( VImage a, std::vector<double> b ) 
+{ 
+	return( a.linear( 1.0, vips::negate( b ) ) ); 
+}
+
+VImage 
+operator-( VImage a ) 
+{ 
+	return( a * -1 );
+}
+
+VImage 
+operator*( VImage a, VImage b ) 
+{
+	return( a.multiply( b ) );
+}
+
+VImage 
+operator*( double a, VImage b ) 
+{
+	return( b.linear( a, 0.0 ) ); 
+}
+
+VImage 
+operator*( VImage a, double b ) 
+{ 
+	return( a.linear( b, 0.0 ) ); 
+}
+
+VImage 
+operator*( std::vector<double> a, VImage b ) 
+{
+	return( b.linear( a, 0.0 ) ); 
+}
+
+VImage 
+operator*( VImage a, std::vector<double> b ) 
+{ 
+	return( a.linear( b, 0.0 ) ); 
+}
+
+VImage 
+operator/( VImage a, VImage b ) 
+{
+	return( a.divide( b ) );
+}
+
+VImage 
+operator/( double a, VImage b ) 
+{
+	return( b.pow( -1.0 ).linear( a, 0.0 ) ); 
+}
+
+VImage 
+operator/( VImage a, double b ) 
+{ 
+	return( a.linear( 1.0 / b, 0.0 ) ); 
+}
+
+VImage 
+operator/( std::vector<double> a, VImage b ) 
+{
+	return( b.pow( -1.0 ).linear( a, 0.0 ) ); 
+}
+
+VImage 
+operator/( VImage a, std::vector<double> b ) 
+{ 
+	return( a.linear( vips::invert( b ), 0.0 ) ); 
+}
+
+VImage 
+operator%( VImage a, VImage b ) 
+{
+	return( a.remainder( b ) );
+}
+
+VImage 
+operator%( VImage a, double b ) 
+{ 
+	return( a.remainder_const( to_vector( b ) ) ); 
+}
+
+VImage 
+operator%( VImage a, std::vector<double> b ) 
+{ 
+	return( a.remainder_const( b ) ); 
+}
+
+VImage 
+operator<( VImage a, VImage b ) 
+{
+	return( a.relational( b, VIPS_OPERATION_RELATIONAL_LESS ) );
+}
+
+VImage 
+operator<( double a, VImage b ) 
+{
+	return( b.relational_const( to_vector( a ), 
+		VIPS_OPERATION_RELATIONAL_MORE ) );
+}
+
+VImage 
+operator<( VImage a, double b ) 
+{ 
+	return( a.relational_const( to_vector( b ), 
+		VIPS_OPERATION_RELATIONAL_LESS ) );
+}
+
+VImage 
+operator<( std::vector<double> a, VImage b ) 
+{
+	return( b.relational_const( a, 
+		VIPS_OPERATION_RELATIONAL_MORE ) );
+}
+
+VImage 
+operator<( VImage a, std::vector<double> b ) 
+{ 
+	return( a.relational_const( b, 
+		VIPS_OPERATION_RELATIONAL_LESS ) );
+}
+
+VImage 
+operator<=( VImage a, VImage b ) 
+{
+	return( a.relational( b, VIPS_OPERATION_RELATIONAL_LESSEQ ) );
+}
+
+VImage 
+operator<=( double a, VImage b ) 
+{
+	return( b.relational_const( to_vector( a ), 
+		VIPS_OPERATION_RELATIONAL_MOREEQ ) );
+}
+
+VImage 
+operator<=( VImage a, double b ) 
+{ 
+	return( a.relational_const( to_vector( b ), 
+		VIPS_OPERATION_RELATIONAL_LESSEQ ) );
+}
+
+VImage 
+operator<=( std::vector<double> a, VImage b ) 
+{
+	return( b.relational_const( a, 
+		VIPS_OPERATION_RELATIONAL_MOREEQ ) );
+}
+
+VImage 
+operator<=( VImage a, std::vector<double> b ) 
+{ 
+	return( a.relational_const( b, 
+		VIPS_OPERATION_RELATIONAL_LESSEQ ) );
+}
+
+VImage 
+operator>( VImage a, VImage b ) 
+{
+	return( a.relational( b, VIPS_OPERATION_RELATIONAL_MORE ) );
+}
+
+VImage 
+operator>( double a, VImage b ) 
+{
+	return( b.relational_const( to_vector( a ), 
+		VIPS_OPERATION_RELATIONAL_LESS ) );
+}
+
+VImage 
+operator>( VImage a, double b ) 
+{ 
+	return( a.relational_const( to_vector( b ), 
+		VIPS_OPERATION_RELATIONAL_MORE ) );
+}
+
+VImage 
+operator>( std::vector<double> a, VImage b ) 
+{
+	return( b.relational_const( a, 
+		VIPS_OPERATION_RELATIONAL_LESS ) );
+}
+
+VImage 
+operator>( VImage a, std::vector<double> b ) 
+{ 
+	return( a.relational_const( b, 
+		VIPS_OPERATION_RELATIONAL_MORE ) );
+}
+
+VImage 
+operator>=( VImage a, VImage b ) 
+{
+	return( a.relational( b, VIPS_OPERATION_RELATIONAL_MOREEQ ) );
+}
+
+VImage 
+operator>=( double a, VImage b ) 
+{
+	return( b.relational_const( to_vector( a ), 
+		VIPS_OPERATION_RELATIONAL_LESSEQ ) );
+}
+
+VImage 
+operator>=( VImage a, double b ) 
+{ 
+	return( a.relational_const( to_vector( b ), 
+		VIPS_OPERATION_RELATIONAL_MOREEQ ) );
+}
+
+VImage 
+operator>=( std::vector<double> a, VImage b ) 
+{
+	return( b.relational_const( a, 
+		VIPS_OPERATION_RELATIONAL_LESSEQ ) );
+}
+
+VImage 
+operator>=( VImage a, std::vector<double> b ) 
+{ 
+	return( a.relational_const( b, 
+		VIPS_OPERATION_RELATIONAL_MOREEQ ) );
+}
+
+VImage 
+operator==( VImage a, VImage b ) 
+{
+	return( a.relational( b, VIPS_OPERATION_RELATIONAL_EQUAL ) );
+}
+
+VImage 
+operator==( double a, VImage b ) 
+{
+	return( b.relational_const( to_vector( a ), 
+		VIPS_OPERATION_RELATIONAL_EQUAL ) );
+}
+
+VImage 
+operator==( VImage a, double b ) 
+{ 
+	return( a.relational_const( to_vector( b ), 
+		VIPS_OPERATION_RELATIONAL_EQUAL ) );
+}
+
+VImage 
+operator==( std::vector<double> a, VImage b ) 
+{
+	return( b.relational_const( a, 
+		VIPS_OPERATION_RELATIONAL_EQUAL ) );
+}
+
+VImage 
+operator==( VImage a, std::vector<double> b ) 
+{ 
+	return( a.relational_const( b, 
+		VIPS_OPERATION_RELATIONAL_EQUAL ) );
+}
+
+VImage 
+operator!=( VImage a, VImage b ) 
+{
+	return( a.relational( b, VIPS_OPERATION_RELATIONAL_NOTEQ ) );
+}
+
+VImage 
+operator!=( double a, VImage b ) 
+{
+	return( b.relational_const( to_vector( a ), 
+		VIPS_OPERATION_RELATIONAL_NOTEQ ) );
+}
+
+VImage 
+operator!=( VImage a, double b ) 
+{ 
+	return( a.relational_const( to_vector( b ), 
+		VIPS_OPERATION_RELATIONAL_NOTEQ ) );
+}
+
+VImage 
+operator!=( std::vector<double> a, VImage b ) 
+{
+	return( b.relational_const( a, 
+		VIPS_OPERATION_RELATIONAL_NOTEQ ) );
+}
+
+VImage 
+operator!=( VImage a, std::vector<double> b ) 
+{ 
+	return( a.relational_const( b, 
+		VIPS_OPERATION_RELATIONAL_NOTEQ ) );
+}
+
+VImage 
+operator&( VImage a, VImage b ) 
+{
+	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_AND ) );
+}
+
+VImage 
+operator&( double a, VImage b ) 
+{
+	return( b.boolean_const( to_vector( a ), 
+		VIPS_OPERATION_BOOLEAN_AND ) );
+}
+
+VImage 
+operator&( VImage a, double b ) 
+{ 
+	return( a.boolean_const( to_vector( b ), 
+		VIPS_OPERATION_BOOLEAN_AND ) );
+}
+
+VImage 
+operator&( std::vector<double> a, VImage b ) 
+{
+	return( b.boolean_const( a, VIPS_OPERATION_BOOLEAN_AND ) );
+}
+
+VImage 
+operator&( VImage a, std::vector<double> b ) 
+{ 
+	return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_AND ) );
+}
+
+VImage 
+operator|( VImage a, VImage b ) 
+{
+	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_OR ) );
+}
+
+VImage 
+operator|( double a, VImage b ) 
+{
+	return( b.boolean_const( to_vector( a ), 
+		VIPS_OPERATION_BOOLEAN_OR ) );
+}
+
+VImage 
+operator|( VImage a, double b ) 
+{ 
+	return( a.boolean_const( to_vector( b ), 
+		VIPS_OPERATION_BOOLEAN_OR ) );
+}
+
+VImage 
+operator|( std::vector<double> a, VImage b ) 
+{
+	return( b.boolean_const( a, VIPS_OPERATION_BOOLEAN_OR ) );
+}
+
+VImage 
+operator|( VImage a, std::vector<double> b ) 
+{ 
+	return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_OR ) );
+}
+
+VImage 
+operator^( VImage a, VImage b ) 
+{
+	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_EOR ) );
+}
+
+VImage 
+operator^( double a, VImage b ) 
+{
+	return( b.boolean_const( to_vector( a ), 
+		VIPS_OPERATION_BOOLEAN_EOR ) );
+}
+
+VImage 
+operator^( VImage a, double b ) 
+{ 
+	return( a.boolean_const( to_vector( b ), 
+		VIPS_OPERATION_BOOLEAN_EOR ) );
+}
+
+VImage 
+operator^( std::vector<double> a, VImage b ) 
+{
+	return( b.boolean_const( a, VIPS_OPERATION_BOOLEAN_EOR ) );
+}
+
+VImage 
+operator^( VImage a, std::vector<double> b ) 
+{ 
+	return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_EOR ) );
+}
+
+VImage 
+operator<<( VImage a, VImage b ) 
+{
+	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_LSHIFT ) );
+}
+
+VImage 
+operator<<( VImage a, double b ) 
+{ 
+	return( a.boolean_const( to_vector( b ), 
+		VIPS_OPERATION_BOOLEAN_LSHIFT ) ); 
+}
+
+VImage 
+operator<<( VImage a, std::vector<double> b ) 
+{ 
+	return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_LSHIFT ) ); 
+}
+
+VImage 
+operator>>( VImage a, VImage b ) 
+{
+	return( a.boolean( b, VIPS_OPERATION_BOOLEAN_RSHIFT ) );
+}
+
+VImage 
+operator>>( VImage a, double b ) 
+{ 
+	return( a.boolean_const( to_vector( b ), 
+		VIPS_OPERATION_BOOLEAN_RSHIFT ) ); 
+}
+
+VImage 
+operator>>( VImage a, std::vector<double> b ) 
+{ 
+	return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_RSHIFT ) ); 
+}
+
 VIPS_NAMESPACE_END

src/libvips/cplusplus/vips-operators.cpp

@@ -1,5 +1,5 @@
 // bodies for vips operations
-// Sat Jan  9 15:05:58 GMT 2016
+// Fri Feb 12 20:03:53 GMT 2016
 // this file is generated automatically, do not edit!
 
 void VImage::system( char * cmd_format , VOption *options )
@@ -1408,6 +1408,78 @@ VImage VImage::vipsload( char * filename , VOption *options )
     return( out );
 }
 
+VImage VImage::pdfload( char * filename , VOption *options )
+{
+    VImage out;
+
+    call( "pdfload" ,
+        (options ? options : VImage::option()) ->
+            set( "filename", filename ) ->
+            set( "out", &out ) );
+
+    return( out );
+}
+
+VImage VImage::pdfload_buffer( VipsBlob * buffer , VOption *options )
+{
+    VImage out;
+
+    call( "pdfload_buffer" ,
+        (options ? options : VImage::option()) ->
+            set( "buffer", buffer ) ->
+            set( "out", &out ) );
+
+    return( out );
+}
+
+VImage VImage::svgload( char * filename , VOption *options )
+{
+    VImage out;
+
+    call( "svgload" ,
+        (options ? options : VImage::option()) ->
+            set( "filename", filename ) ->
+            set( "out", &out ) );
+
+    return( out );
+}
+
+VImage VImage::svgload_buffer( VipsBlob * buffer , VOption *options )
+{
+    VImage out;
+
+    call( "svgload_buffer" ,
+        (options ? options : VImage::option()) ->
+            set( "buffer", buffer ) ->
+            set( "out", &out ) );
+
+    return( out );
+}
+
+VImage VImage::gifload( char * filename , VOption *options )
+{
+    VImage out;
+
+    call( "gifload" ,
+        (options ? options : VImage::option()) ->
+            set( "filename", filename ) ->
+            set( "out", &out ) );
+
+    return( out );
+}
+
+VImage VImage::gifload_buffer( VipsBlob * buffer , VOption *options )
+{
+    VImage out;
+
+    call( "gifload_buffer" ,
+        (options ? options : VImage::option()) ->
+            set( "buffer", buffer ) ->
+            set( "out", &out ) );
+
+    return( out );
+}
+
 VImage VImage::pngload( char * filename , VOption *options )
 {
     VImage out;
@@ -1783,11 +1855,37 @@ VImage VImage::shrinkv( int yshrink , VOption *options )
     return( out );
 }
 
-VImage VImage::shrink2( double xshrink , double yshrink , VOption *options )
+VImage VImage::reduceh( double xshrink , VOption *options )
 {
     VImage out;
 
-    call( "shrink2" ,
+    call( "reduceh" ,
+        (options ? options : VImage::option()) ->
+            set( "in", *this ) ->
+            set( "out", &out ) ->
+            set( "xshrink", xshrink ) );
+
+    return( out );
+}
+
+VImage VImage::reducev( double yshrink , VOption *options )
+{
+    VImage out;
+
+    call( "reducev" ,
+        (options ? options : VImage::option()) ->
+            set( "in", *this ) ->
+            set( "out", &out ) ->
+            set( "yshrink", yshrink ) );
+
+    return( out );
+}
+
+VImage VImage::reduce( double xshrink , double yshrink , VOption *options )
+{
+    VImage out;
+
+    call( "reduce" ,
         (options ? options : VImage::option()) ->
             set( "in", *this ) ->
             set( "out", &out ) ->

src/metadata.cc

@@ -38,6 +38,8 @@ using sharp::DetermineImageType;
 using sharp::HasProfile;
 using sharp::HasAlpha;
 using sharp::ExifOrientation;
+using sharp::HasDensity;
+using sharp::GetDensity;
 using sharp::FreeCallback;
 using sharp::counterQueue;
 
@@ -52,6 +54,7 @@ struct MetadataBaton {
   int height;
   std::string space;
   int channels;
+  int density;
   bool hasProfile;
   bool hasAlpha;
   int orientation;
@@ -63,13 +66,13 @@ struct MetadataBaton {
 
   MetadataBaton():
     bufferInLength(0),
+    density(0),
     orientation(0),
     exifLength(0),
     iccLength(0) {}
 };
 
 class MetadataWorker : public AsyncWorker {
-
  public:
   MetadataWorker(Callback *callback, MetadataBaton *baton, const Local<Object> &bufferIn) :
     AsyncWorker(callback), baton(baton) {
@@ -120,6 +123,9 @@ class MetadataWorker : public AsyncWorker {
       baton->height = image.height();
       baton->space = vips_enum_nick(VIPS_TYPE_INTERPRETATION, image.interpretation());
       baton->channels = image.bands();
+      if (HasDensity(image)) {
+        baton->density = GetDensity(image);
+      }
       baton->hasProfile = HasProfile(image);
       // Derived attributes
       baton->hasAlpha = HasAlpha(image);
@@ -161,6 +167,9 @@ class MetadataWorker : public AsyncWorker {
       Set(info, New("height").ToLocalChecked(), New<Number>(baton->height));
       Set(info, New("space").ToLocalChecked(), New<String>(baton->space).ToLocalChecked());
       Set(info, New("channels").ToLocalChecked(), New<Number>(baton->channels));
+      if (baton->density > 0) {
+        Set(info, New("density").ToLocalChecked(), New<Number>(baton->density));
+      }
       Set(info, New("hasProfile").ToLocalChecked(), New<Boolean>(baton->hasProfile));
       Set(info, New("hasAlpha").ToLocalChecked(), New<Boolean>(baton->hasAlpha));
       if (baton->orientation > 0) {

src/operations.cc

@@ -1,37 +1,88 @@
+#include <algorithm>
+#include <tuple>
+#include <memory>
 #include <vips/vips8>
 
 #include "common.h"
 #include "operations.h"
 
 using vips::VImage;
+using vips::VError;
 
 namespace sharp {
 
   /*
-    Alpha composite src over dst
+    Alpha composite src over dst with given gravity.
-    Assumes alpha channels are already premultiplied and will be unpremultiplied after
+    Assumes alpha channels are already premultiplied and will be unpremultiplied after.
    */
-  VImage Composite(VImage src, VImage dst) {
+  VImage Composite(VImage src, VImage dst, const int gravity) {
+    if(IsInputValidForComposition(src, dst)) {
+      // Enlarge overlay src, if required
+      if (src.width() < dst.width() || src.height() < dst.height()) {
+        // Calculate the (left, top) coordinates of the output image within the input image, applying the given gravity.
+        int left;
+        int top;
+        std::tie(left, top) = CalculateCrop(dst.width(), dst.height(), src.width(), src.height(), gravity);
+        // Embed onto transparent background
+        std::vector<double> background { 0.0, 0.0, 0.0, 0.0 };
+        src = src.embed(left, top, dst.width(), dst.height(), VImage::option()
+          ->set("extend", VIPS_EXTEND_BACKGROUND)
+          ->set("background", background)
+        );
+      }
+      return CompositeImage(src, dst);
+    }
+    // If the input was not valid for composition the return the input image itself
+    return dst;
+  }
+
+
+  VImage Composite(VImage src, VImage dst, const int x, const int y) {
+    if(IsInputValidForComposition(src, dst)) {
+      // Enlarge overlay src, if required
+      if (src.width() < dst.width() || src.height() < dst.height()) {
+        // Calculate the (left, top) coordinates of the output image within the input image, applying the given gravity.
+        int left;
+        int top;
+        std::tie(left, top) = CalculateCrop(dst.width(), dst.height(), src.width(), src.height(), x, y);
+        // Embed onto transparent background
+        std::vector<double> background { 0.0, 0.0, 0.0, 0.0 };
+        src = src.embed(left, top, dst.width(), dst.height(), VImage::option()
+          ->set("extend", VIPS_EXTEND_BACKGROUND)
+          ->set("background", background)
+        );
+      }
+      return CompositeImage(src, dst);
+    }
+    // If the input was not valid for composition the return the input image itself
+    return dst;
+  }
+
+  bool IsInputValidForComposition(VImage src, VImage dst) {
+    using sharp::CalculateCrop;
     using sharp::HasAlpha;
 
-    // Split src into non-alpha and alpha
+    if (!HasAlpha(src)) {
+      throw VError("Overlay image must have an alpha channel");
+    }
+    if (!HasAlpha(dst)) {
+      throw VError("Image to be overlaid must have an alpha channel");
+    }
+    if (src.width() > dst.width() || src.height() > dst.height()) {
+      throw VError("Overlay image must have same dimensions or smaller");
+    }
+
+    return true;
+  }
+
+  VImage CompositeImage(VImage src, VImage dst) {
+    // Split src into non-alpha and alpha channels
     VImage srcWithoutAlpha = src.extract_band(0, VImage::option()->set("n", src.bands() - 1));
     VImage srcAlpha = src[src.bands() - 1] * (1.0 / 255.0);
 
     // Split dst into non-alpha and alpha channels
-    VImage dstWithoutAlpha;
+    VImage dstWithoutAlpha = dst.extract_band(0, VImage::option()->set("n", dst.bands() - 1));
-    VImage dstAlpha;
+    VImage dstAlpha = dst[dst.bands() - 1] * (1.0 / 255.0);
-    if (HasAlpha(dst)) {
-      // Non-alpha: extract all-but-last channel
-      dstWithoutAlpha = dst.extract_band(0, VImage::option()->set("n", dst.bands() - 1));
-      // Alpha: Extract last channel
-      dstAlpha = dst[dst.bands() - 1] * (1.0 / 255.0);
-    } else {
-      // Non-alpha: Copy reference
-      dstWithoutAlpha = dst;
-      // Alpha: Use blank, opaque (0xFF) image
-      dstAlpha = VImage::black(dst.width(), dst.height()).invert();
-    }
 
     //
     // Compute normalized output alpha channel:
@@ -64,6 +115,65 @@ namespace sharp {
     return outRGBPremultiplied.bandjoin(outAlphaNormalized * 255.0);
   }
 
+  /*
+    Cutout src over dst with given gravity.
+   */
+  VImage Cutout(VImage mask, VImage dst, const int gravity) {
+    using sharp::CalculateCrop;
+    using sharp::HasAlpha;
+    using sharp::MaximumImageAlpha;
+
+    bool maskHasAlpha = HasAlpha(mask);
+
+    if (!maskHasAlpha && mask.bands() > 1) {
+      throw VError("Overlay image must have an alpha channel or one band");
+    }
+    if (!HasAlpha(dst)) {
+      throw VError("Image to be overlaid must have an alpha channel");
+    }
+    if (mask.width() > dst.width() || mask.height() > dst.height()) {
+      throw VError("Overlay image must have same dimensions or smaller");
+    }
+
+    // Enlarge overlay mask, if required
+    if (mask.width() < dst.width() || mask.height() < dst.height()) {
+      // Calculate the (left, top) coordinates of the output image within the input image, applying the given gravity.
+      int left;
+      int top;
+      std::tie(left, top) = CalculateCrop(dst.width(), dst.height(), mask.width(), mask.height(), gravity);
+      // Embed onto transparent background
+      std::vector<double> background { 0.0, 0.0, 0.0, 0.0 };
+      mask = mask.embed(left, top, dst.width(), dst.height(), VImage::option()
+              ->set("extend", VIPS_EXTEND_BACKGROUND)
+              ->set("background", background)
+      );
+    }
+
+    // we use the mask alpha if it has alpha
+    if(maskHasAlpha) {
+      mask = mask.extract_band(mask.bands() - 1, VImage::option()->set("n", 1));;
+    }
+
+    // Split dst into an optional alpha
+    VImage dstAlpha = dst.extract_band(dst.bands() - 1, VImage::option()->set("n", 1));
+
+    // we use the dst non-alpha
+    dst = dst.extract_band(0, VImage::option()->set("n", dst.bands() - 1));
+
+    // the range of the mask and the image need to match .. one could be
+    // 16-bit, one 8-bit
+    double const dstMax = MaximumImageAlpha(dst.interpretation());
+    double const maskMax = MaximumImageAlpha(mask.interpretation());
+
+    // combine the new mask and the existing alpha ... there are
+    // many ways of doing this, mult is the simplest
+    mask = dstMax * ((mask / maskMax) * (dstAlpha / dstMax));
+
+    // append the mask to the image data ... the mask might be float now,
+    // we must cast the format down to match the image data
+    return dst.bandjoin(mask.cast(dst.format()));
+  }
+
   /*
    * Stretch luminance to cover full dynamic range.
    */
@@ -118,10 +228,10 @@ namespace sharp {
   }
 
   /*
-   * Gaussian blur (use sigma <0 for fast blur)
+   * Gaussian blur. Use sigma of -1.0 for fast blur.
    */
   VImage Blur(VImage image, double const sigma) {
-    if (sigma < 0.0) {
+    if (sigma == -1.0) {
       // Fast, mild blur - averages neighbouring pixels
       VImage blur = VImage::new_matrixv(3, 3,
         1.0, 1.0, 1.0,
@@ -136,10 +246,30 @@ namespace sharp {
   }
 
   /*
-   * Sharpen flat and jagged areas. Use radius of -1 for fast sharpen.
+   * Convolution with a kernel.
    */
-  VImage Sharpen(VImage image, int const radius, double const flat, double const jagged) {
+  VImage Convolve(VImage image, int const width, int const height,
-    if (radius == -1) {
+    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);
+  }
+
+  /*
+   * 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,
@@ -149,9 +279,183 @@ namespace sharp {
       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("radius", radius)->set("m1", flat)->set("m2", jagged)
+        VImage::option()->set("sigma", sigma)->set("m1", flat)->set("m2", jagged)
+      ).colourspace(colourspaceBeforeSharpen);
+    }
+  }
+
+  /*
+    Calculate crop area based on image entropy
+  */
+  std::tuple<int, int> EntropyCrop(VImage image, int const outWidth, int const outHeight) {
+    int left = 0;
+    int top = 0;
+    int const inWidth = image.width();
+    int const inHeight = image.height();
+    if (inWidth > outWidth) {
+      // Reduce width by repeated removing slices from edge with lowest entropy
+      int width = inWidth;
+      double leftEntropy = 0.0;
+      double rightEntropy = 0.0;
+      // Max width of each slice
+      int const maxSliceWidth = static_cast<int>(ceil((inWidth - outWidth) / 8.0));
+      while (width > outWidth) {
+        // Width of current slice
+        int const slice = std::min(width - outWidth, maxSliceWidth);
+        if (leftEntropy == 0.0) {
+          // Update entropy of left slice
+          leftEntropy = Entropy(image.extract_area(left, 0, slice, inHeight));
+        }
+        if (rightEntropy == 0.0) {
+          // Update entropy of right slice
+          rightEntropy = Entropy(image.extract_area(width - slice - 1, 0, slice, inHeight));
+        }
+        // Keep slice with highest entropy
+        if (leftEntropy >= rightEntropy) {
+          // Discard right slice
+          rightEntropy = 0.0;
+        } else {
+          // Discard left slice
+          leftEntropy = 0.0;
+          left = left + slice;
+        }
+        width = width - slice;
+      }
+    }
+    if (inHeight > outHeight) {
+      // Reduce height by repeated removing slices from edge with lowest entropy
+      int height = inHeight;
+      double topEntropy = 0.0;
+      double bottomEntropy = 0.0;
+      // Max height of each slice
+      int const maxSliceHeight = static_cast<int>(ceil((inHeight - outHeight) / 8.0));
+      while (height > outHeight) {
+        // Height of current slice
+        int const slice = std::min(height - outHeight, maxSliceHeight);
+        if (topEntropy == 0.0) {
+          // Update entropy of top slice
+          topEntropy = Entropy(image.extract_area(0, top, inWidth, slice));
+        }
+        if (bottomEntropy == 0.0) {
+          // Update entropy of bottom slice
+          bottomEntropy = Entropy(image.extract_area(0, height - slice - 1, inWidth, slice));
+        }
+        // Keep slice with highest entropy
+        if (topEntropy >= bottomEntropy) {
+          // Discard bottom slice
+          bottomEntropy = 0.0;
+        } else {
+          // Discard top slice
+          topEntropy = 0.0;
+          top = top + slice;
+        }
+        height = height - slice;
+      }
+    }
+    return std::make_tuple(left, top);
+  }
+
+  /*
+    Calculate the Shannon entropy for an image
+  */
+  double Entropy(VImage image) {
+    return image.hist_find().hist_entropy();
+  }
+
+  /*
+    Insert a tile cache to prevent over-computation of any previous operations in the pipeline
+  */
+  VImage TileCache(VImage image, double const factor) {
+    int tile_width;
+    int tile_height;
+    int scanline_count;
+    vips_get_tile_size(image.get_image(), &tile_width, &tile_height, &scanline_count);
+    double const need_lines = 1.2 * scanline_count / factor;
+    return image.tilecache(VImage::option()
+      ->set("tile_width", image.width())
+      ->set("tile_height", 10)
+      ->set("max_tiles", static_cast<int>(round(1.0 + need_lines / 10.0)))
+      ->set("access", VIPS_ACCESS_SEQUENTIAL)
+      ->set("threaded", TRUE)
     );
   }
+
+  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) {
+    return image.bandbool(boolean);
+  }
+
+  /*
+    Perform bitwise boolean operation between images
+  */
+  VImage Boolean(VImage image, VImage imageR, VipsOperationBoolean const boolean) {
+    return image.boolean(imageR, boolean);
+  }
+
+  VImage Trim(VImage image, int const tolerance) {
+    using sharp::MaximumImageAlpha;
+    // An equivalent of ImageMagick's -trim in C++ ... automatically remove
+    // "boring" image edges.
+
+    // We use .project to sum the rows and columns of a 0/255 mask image, the first
+    // non-zero row or column is the object edge. We make the mask image with an
+    // amount-different-from-background image plus a threshold.
+
+    // find the value of the pixel at (0, 0) ... we will search for all pixels
+    // significantly different from this
+    std::vector<double> background = image(0, 0);
+
+    double const max = MaximumImageAlpha(image.interpretation());
+
+    // we need to smooth the image, subtract the background from every pixel, take
+    // the absolute value of the difference, then threshold
+    VImage mask = (image.median(3) - background).abs() > (max * tolerance / 100);
+
+    // sum mask rows and columns, then search for the first non-zero sum in each
+    // direction
+    VImage rows;
+    VImage columns = mask.project(&rows);
+
+    VImage profileLeftV;
+    VImage profileLeftH = columns.profile(&profileLeftV);
+
+    VImage profileRightV;
+    VImage profileRightH = columns.fliphor().profile(&profileRightV);
+
+    VImage profileTopV;
+    VImage profileTopH = rows.profile(&profileTopV);
+
+    VImage profileBottomV;
+    VImage profileBottomH = rows.flipver().profile(&profileBottomV);
+
+    int left = static_cast<int>(floor(profileLeftV.min()));
+    int right = columns.width() - static_cast<int>(floor(profileRightV.min()));
+    int top = static_cast<int>(floor(profileTopH.min()));
+    int bottom = rows.height() - static_cast<int>(floor(profileBottomH.min()));
+
+    int width = right - left;
+    int height = bottom - top;
+
+    if(width <= 0 || height <= 0) {
+      throw VError("Unexpected error while trimming. Try to lower the tolerance");
+    }
+
+    // and now crop the original image
+    return image.extract_area(left, top, width, height);
+  }
+
 }  // namespace sharp

src/operations.h

@@ -1,6 +1,8 @@
 #ifndef SRC_OPERATIONS_H_
 #define SRC_OPERATIONS_H_
 
+#include <tuple>
+#include <memory>
 #include <vips/vips8>
 
 using vips::VImage;
@@ -8,10 +10,31 @@ using vips::VImage;
 namespace sharp {
 
   /*
-    Composite images `src` and `dst` with premultiplied alpha channel and output
+    Alpha composite src over dst with given gravity.
-    image with premultiplied alpha.
+    Assumes alpha channels are already premultiplied and will be unpremultiplied after.
    */
-  VImage Composite(VImage src, VImage dst);
+  VImage Composite(VImage src, VImage dst, const int gravity);
+
+  /*
+    Alpha composite src over dst with given x and y offsets.
+    Assumes alpha channels are already premultiplied and will be unpremultiplied after.
+   */
+  VImage Composite(VImage src, VImage dst, const int x, const int y);
+
+  /*
+    Check if the src and dst Images for composition operation are valid
+  */
+  bool IsInputValidForComposition(VImage src, VImage dst);
+
+  /*
+    Given a valid src and dst, returns the composite of the two images
+  */
+  VImage CompositeImage(VImage src, VImage dst);
+
+  /*
+    Cutout src over dst with given gravity.
+  */
+  VImage Cutout(VImage src, VImage dst, const int gravity);
 
   /*
    * Stretch luminance to cover full dynamic range.
@@ -24,14 +47,56 @@ namespace sharp {
   VImage Gamma(VImage image, double const exponent);
 
   /*
-   * Gaussian blur. Use sigma of -1 for fast blur.
+   * Gaussian blur. Use sigma of -1.0 for fast blur.
    */
   VImage Blur(VImage image, double const sigma);
 
   /*
-   * Sharpen flat and jagged areas. Use radius of -1 for fast sharpen.
+   * Convolution with a kernel.
    */
-  VImage Sharpen(VImage image, int const radius, double const flat, double const jagged);
+  VImage Convolve(VImage image, int const width, int const height,
+    double const scale, double const offset, std::unique_ptr<double[]> const &kernel_v);
+
+  /*
+   * 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);
+
+  /*
+    Calculate crop area based on image entropy
+  */
+  std::tuple<int, int> EntropyCrop(VImage image, int const outWidth, int const outHeight);
+
+  /*
+    Calculate the Shannon entropy for an image
+  */
+  double Entropy(VImage image);
+
+  /*
+    Insert a tile cache to prevent over-computation of any previous operations in the pipeline
+  */
+  VImage TileCache(VImage image, double const factor);
+
+  /*
+    Threshold an image
+  */
+  VImage Threshold(VImage image, double const threshold, bool const thresholdColor);
+
+  /*
+    Perform boolean/bitwise operation on image color channels - results in one channel image
+  */
+  VImage Bandbool(VImage image, VipsOperationBoolean const boolean);
+
+  /*
+    Perform bitwise boolean operation between images
+  */
+  VImage Boolean(VImage image, VImage imageR, VipsOperationBoolean const boolean);
+
+  /*
+    Trim an image
+  */
+  VImage Trim(VImage image, int const tolerance);
+
 }  // namespace sharp
 
 #endif  // SRC_OPERATIONS_H_

src/pipeline.h

@@ -1,8 +1,177 @@
 #ifndef SRC_PIPELINE_H_
 #define SRC_PIPELINE_H_
 
+#include <memory>
+
+#include <vips/vips8>
+
 #include "nan.h"
 
 NAN_METHOD(pipeline);
 
+enum class Canvas {
+  CROP,
+  EMBED,
+  MAX,
+  MIN,
+  IGNORE_ASPECT
+};
+
+struct PipelineBaton {
+  std::string fileIn;
+  char *bufferIn;
+  size_t bufferInLength;
+  std::string iccProfilePath;
+  int limitInputPixels;
+  int density;
+  int rawWidth;
+  int rawHeight;
+  int rawChannels;
+  std::string formatOut;
+  std::string fileOut;
+  void *bufferOut;
+  size_t bufferOutLength;
+  std::string overlayFileIn;
+  char *overlayBufferIn;
+  size_t overlayBufferInLength;
+  int overlayGravity;
+  int overlayXOffset;
+  int overlayYOffset;
+  bool overlayTile;
+  bool overlayCutout;
+  std::string booleanFileIn;
+  char *booleanBufferIn;
+  size_t booleanBufferInLength;
+  int topOffsetPre;
+  int leftOffsetPre;
+  int widthPre;
+  int heightPre;
+  int topOffsetPost;
+  int leftOffsetPost;
+  int widthPost;
+  int heightPost;
+  int width;
+  int height;
+  int channels;
+  Canvas canvas;
+  int crop;
+  std::string kernel;
+  std::string interpolator;
+  double background[4];
+  bool flatten;
+  bool negate;
+  double blurSigma;
+  double sharpenSigma;
+  double sharpenFlat;
+  double sharpenJagged;
+  int threshold;
+  bool thresholdGrayscale;
+  int trimTolerance;
+  double gamma;
+  bool greyscale;
+  bool normalize;
+  int angle;
+  bool rotateBeforePreExtract;
+  bool flip;
+  bool flop;
+  int extendTop;
+  int extendBottom;
+  int extendLeft;
+  int extendRight;
+  bool progressive;
+  bool withoutEnlargement;
+  VipsAccess accessMethod;
+  int quality;
+  int compressionLevel;
+  bool withoutAdaptiveFiltering;
+  bool withoutChromaSubsampling;
+  bool trellisQuantisation;
+  bool overshootDeringing;
+  bool optimiseScans;
+  std::string err;
+  bool withMetadata;
+  int withMetadataOrientation;
+  std::unique_ptr<double[]> convKernel;
+  int convKernelWidth;
+  int convKernelHeight;
+  double convKernelScale;
+  double convKernelOffset;
+  VipsOperationBoolean bandBoolOp;
+  VipsOperationBoolean booleanOp;
+  int extractChannel;
+  int tileSize;
+  int tileOverlap;
+  VipsForeignDzContainer tileContainer;
+  VipsForeignDzLayout tileLayout;
+
+  PipelineBaton():
+    bufferInLength(0),
+    limitInputPixels(0),
+    density(72),
+    rawWidth(0),
+    rawHeight(0),
+    rawChannels(0),
+    formatOut(""),
+    fileOut(""),
+    bufferOutLength(0),
+    overlayBufferInLength(0),
+    overlayGravity(0),
+    overlayXOffset(-1),
+    overlayYOffset(-1),
+    overlayTile(false),
+    overlayCutout(false),
+    booleanBufferInLength(0),
+    topOffsetPre(-1),
+    topOffsetPost(-1),
+    channels(0),
+    canvas(Canvas::CROP),
+    crop(0),
+    flatten(false),
+    negate(false),
+    blurSigma(0.0),
+    sharpenSigma(0.0),
+    sharpenFlat(1.0),
+    sharpenJagged(2.0),
+    threshold(0),
+    thresholdGrayscale(true),
+    trimTolerance(0),
+    gamma(0.0),
+    greyscale(false),
+    normalize(false),
+    angle(0),
+    flip(false),
+    flop(false),
+    extendTop(0),
+    extendBottom(0),
+    extendLeft(0),
+    extendRight(0),
+    progressive(false),
+    withoutEnlargement(false),
+    quality(80),
+    compressionLevel(6),
+    withoutAdaptiveFiltering(false),
+    withoutChromaSubsampling(false),
+    trellisQuantisation(false),
+    overshootDeringing(false),
+    optimiseScans(false),
+    withMetadata(false),
+    withMetadataOrientation(-1),
+    convKernelWidth(0),
+    convKernelHeight(0),
+    convKernelScale(0.0),
+    convKernelOffset(0.0),
+    bandBoolOp(VIPS_OPERATION_BOOLEAN_LAST),
+    booleanOp(VIPS_OPERATION_BOOLEAN_LAST),
+    extractChannel(-1),
+    tileSize(256),
+    tileOverlap(0),
+    tileContainer(VIPS_FOREIGN_DZ_CONTAINER_FS),
+    tileLayout(VIPS_FOREIGN_DZ_LAYOUT_DZ) {
+      background[0] = 0.0;
+      background[1] = 0.0;
+      background[2] = 0.0;
+      background[3] = 255.0;
+    }
+};
+
 #endif  // SRC_PIPELINE_H_

src/utilities.cc

@@ -138,7 +138,9 @@ NAN_METHOD(format) {
 
   // Which load/save operations are available for each compressed format?
   Local<Object> format = New<Object>();
-  for (std::string f : {"jpeg", "png", "webp", "tiff", "magick", "openslide", "dz"}) {
+  for (std::string f : {
+    "jpeg", "png", "webp", "tiff", "magick", "openslide", "dz", "ppm", "fits", "gif", "svg", "pdf", "v"
+  }) {
     // Input
     Local<Boolean> hasInputFile =
       New<Boolean>(vips_type_find("VipsOperation", (f + "load").c_str()));

test/bench/package.json

@@ -9,12 +9,12 @@
   },
   "devDependencies": {
     "async": "^1.5.2",
-    "benchmark": "^2.0.0",
+    "benchmark": "^2.1.0",
-    "gm": "^1.21.0",
+    "gm": "^1.22.0",
     "imagemagick": "^0.1.3",
-    "imagemagick-native": "elad/node-imagemagick-native",
+    "imagemagick-native": "^1.9.2",
-    "jimp": "^0.2.20",
+    "jimp": "^0.2.24",
-    "lwip": "^0.0.8",
+    "lwip": "^0.0.9",
     "semver": "^5.1.0"
   },
   "license": "Apache-2.0",

test/bench/perf.js

@@ -30,18 +30,15 @@ var fixtures = require('../fixtures');
 var width = 720;
 var height = 480;
 
-var magickFilterBilinear = 'Triangle';
-var magickFilterBicubic = 'Lanczos';
-
 // Disable libvips cache to ensure tests are as fair as they can be
 sharp.cache(false);
 // Enable use of SIMD
 sharp.simd(true);
 
 async.series({
-  'jpeg-linear': function(callback) {
+  'jpeg': function(callback) {
     var inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
-    var jpegSuite = new Benchmark.Suite('jpeg-linear');
+    var jpegSuite = new Benchmark.Suite('jpeg');
     // jimp
     jpegSuite.add('jimp-buffer-buffer', {
       defer: true,
@@ -93,7 +90,7 @@ async.series({
             if (err) {
               throw err;
             }
-            image.resize(width, height, 'linear', function (err, image) {
+            image.resize(width, height, 'lanczos', function (err, image) {
               if (err) {
                 throw err;
               }
@@ -113,7 +110,7 @@ async.series({
             if (err) {
               throw err;
             }
-            image.resize(width, height, 'linear', function (err, image) {
+            image.resize(width, height, 'lanczos', function (err, image) {
               if (err) {
                 throw err;
               }
@@ -140,7 +137,7 @@ async.series({
           width: width,
           height: height,
           format: 'jpg',
-          filter: magickFilterBilinear
+          filter: 'Lanczos'
         }, function(err) {
           if (err) {
             throw err;
@@ -161,7 +158,7 @@ async.series({
             width: width,
             height: height,
             format: 'JPEG',
-            filter: magickFilterBilinear
+            filter: 'Lanczos'
           }, function (err, buffer) {
             if (err) {
               throw err;
@@ -179,7 +176,7 @@ async.series({
       fn: function(deferred) {
         gm(inputJpgBuffer)
           .resize(width, height)
-          .filter(magickFilterBilinear)
+          .filter('Lanczos')
           .quality(80)
           .write(fixtures.outputJpg, function (err) {
             if (err) {
@@ -194,7 +191,7 @@ async.series({
       fn: function(deferred) {
         gm(inputJpgBuffer)
           .resize(width, height)
-          .filter(magickFilterBilinear)
+          .filter('Lanczos')
           .quality(80)
           .toBuffer(function (err, buffer) {
             if (err) {
@@ -210,7 +207,7 @@ async.series({
       fn: function(deferred) {
         gm(fixtures.inputJpg)
           .resize(width, height)
-          .filter(magickFilterBilinear)
+          .filter('Lanczos')
           .quality(80)
           .write(fixtures.outputJpg, function (err) {
             if (err) {
@@ -225,7 +222,7 @@ async.series({
       fn: function(deferred) {
         gm(fixtures.inputJpg)
           .resize(width, height)
-          .filter(magickFilterBilinear)
+          .filter('Lanczos')
           .quality(80)
           .toBuffer(function (err, buffer) {
             if (err) {
@@ -243,7 +240,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toFile(fixtures.outputJpg, function(err) {
             if (err) {
               throw err;
@@ -257,7 +253,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -272,7 +267,6 @@ async.series({
       fn: function(deferred) {
         sharp(fixtures.inputJpg)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toFile(fixtures.outputJpg, function(err) {
             if (err) {
               throw err;
@@ -290,8 +284,7 @@ async.series({
           deferred.resolve();
         });
         var pipeline = sharp()
-          .resize(width, height)
+          .resize(width, height);
-          .interpolateWith(sharp.interpolator.bilinear);
         readable.pipe(pipeline).pipe(writable);
       }
     }).add('sharp-file-buffer', {
@@ -299,7 +292,6 @@ async.series({
       fn: function(deferred) {
         sharp(fixtures.inputJpg)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -314,19 +306,27 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toBuffer()
           .then(function(buffer) {
             assert.notStrictEqual(null, buffer);
             deferred.resolve();
           });
       }
-    }).add('sharp-sharpen-mild', {
+    }).on('cycle', function(event) {
+      console.log('jpeg ' + String(event.target));
+    }).on('complete', function() {
+      callback(null, this.filter('fastest').map('name'));
+    }).run();
+  },
+  // Effect of applying operations
+  operations: function(callback) {
+    var inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
+    var operationsSuite = new Benchmark.Suite('operations');
+    operationsSuite.add('sharp-sharpen-mild', {
       defer: true,
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .sharpen()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -342,7 +342,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .sharpen(3, 1, 3)
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -358,7 +357,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .blur()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -374,7 +372,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .blur(3)
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -390,7 +387,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .gamma()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -406,7 +402,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .normalise()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -422,7 +417,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .greyscale()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -438,7 +432,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .gamma()
           .greyscale()
           .toBuffer(function(err, buffer) {
@@ -455,7 +448,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .progressive()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -471,7 +463,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .withoutChromaSubsampling()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -487,7 +478,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputJpgBuffer)
           .rotate(90)
-          .interpolateWith(sharp.interpolator.bilinear)
           .resize(width, height)
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -503,8 +493,6 @@ async.series({
       fn: function(deferred) {
         sharp.simd(false);
         sharp(inputJpgBuffer)
-          .rotate(90)
-          .interpolateWith(sharp.interpolator.bilinear)
           .resize(width, height)
           .toBuffer(function(err, buffer) {
             sharp.simd(true);
@@ -520,9 +508,8 @@ async.series({
       defer: true,
       fn: function(deferred) {
         sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .sequentialRead()
+          .resize(width, height)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -533,127 +520,19 @@ async.series({
           });
       }
     }).on('cycle', function(event) {
-      console.log('jpeg-linear ' + String(event.target));
+      console.log('operations ' + String(event.target));
     }).on('complete', function() {
       callback(null, this.filter('fastest').map('name'));
     }).run();
   },
-
+  // Comparitive speed of kernels
-  'jpeg-cubic': function(callback) {
+  kernels: function(callback) {
     var inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
-    var jpegSuite = new Benchmark.Suite('jpeg-cubic');
+    (new Benchmark.Suite('kernels')).add('sharp-cubic', {
-    // lwip
-    if (typeof lwip !== 'undefined') {
-      jpegSuite.add('lwip-file-file', {
       defer: true,
       fn: function(deferred) {
-          lwip.open(fixtures.inputJpg, function (err, image) {
+        sharp(inputJpgBuffer)
-            if (err) {
+          .resize(width, height, { kernel: 'cubic' })
-              throw err;
-            }
-            image.resize(width, height, 'lanczos', function (err, image) {
-              if (err) {
-                throw err;
-              }
-              image.writeFile(fixtures.outputJpg, {quality: 80}, function (err) {
-                if (err) {
-                  throw err;
-                }
-                deferred.resolve();
-              });
-            });
-          });
-        }
-      }).add('lwip-buffer-buffer', {
-        defer: true,
-        fn: function(deferred) {
-          lwip.open(inputJpgBuffer, 'jpg', function (err, image) {
-            if (err) {
-              throw err;
-            }
-            image.resize(width, height, 'lanczos', function (err, image) {
-              if (err) {
-                throw err;
-              }
-              image.toBuffer('jpg', {quality: 80}, function (err, buffer) {
-                if (err) {
-                  throw err;
-                }
-                assert.notStrictEqual(null, buffer);
-                deferred.resolve();
-              });
-            });
-          });
-        }
-      });
-    }
-    // imagemagick
-    jpegSuite.add('imagemagick-file-file', {
-      defer: true,
-      fn: function(deferred) {
-        imagemagick.resize({
-          srcPath: fixtures.inputJpg,
-          dstPath: fixtures.outputJpg,
-          quality: 0.8,
-          width: width,
-          height: height,
-          format: 'jpg',
-          filter: magickFilterBicubic
-        }, function(err) {
-          if (err) {
-            throw err;
-          } else {
-            deferred.resolve();
-          }
-        });
-      }
-    });
-    // imagemagick-native
-    if (typeof imagemagickNative !== 'undefined') {
-      jpegSuite.add('imagemagick-native-buffer-buffer', {
-        defer: true,
-        fn: function(deferred) {
-          imagemagickNative.convert({
-            srcData: inputJpgBuffer,
-            quality: 80,
-            width: width,
-            height: height,
-            format: 'JPEG',
-            filter: magickFilterBicubic
-          }, function (err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-        }
-      });
-    }
-    // gm
-    jpegSuite.add('gm-buffer-file', {
-      defer: true,
-      fn: function(deferred) {
-        gm(inputJpgBuffer)
-          .resize(width, height)
-          .filter(magickFilterBicubic)
-          .quality(80)
-          .write(fixtures.outputJpg, function (err) {
-            if (err) {
-              throw err;
-            } else {
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('gm-buffer-buffer', {
-      defer: true,
-      fn: function(deferred) {
-        gm(inputJpgBuffer)
-          .resize(width, height)
-          .filter(magickFilterBicubic)
-          .quality(80)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -663,28 +542,11 @@ async.series({
             }
           });
       }
-    }).add('gm-file-file', {
+    }).add('sharp-lanczos2', {
       defer: true,
       fn: function(deferred) {
-        gm(fixtures.inputJpg)
+        sharp(inputJpgBuffer)
-          .resize(width, height)
+          .resize(width, height, { kernel: 'lanczos2' })
-          .filter(magickFilterBicubic)
-          .quality(80)
-          .write(fixtures.outputJpg, function (err) {
-            if (err) {
-              throw err;
-            } else {
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('gm-file-buffer', {
-      defer: true,
-      fn: function(deferred) {
-        gm(fixtures.inputJpg)
-          .resize(width, height)
-          .filter(magickFilterBicubic)
-          .quality(80)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -694,182 +556,11 @@ async.series({
             }
           });
       }
-    });
+    }).add('sharp-lanczos3', {
-    // sharp
-    jpegSuite.add('sharp-buffer-file', {
       defer: true,
       fn: function(deferred) {
         sharp(inputJpgBuffer)
-          .resize(width, height)
+          .resize(width, height, { kernel: 'lanczos3' })
-          .interpolateWith(sharp.interpolator.bicubic)
-          .toFile(fixtures.outputJpg, function(err) {
-            if (err) {
-              throw err;
-            } else {
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-buffer-buffer', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bicubic)
-          .toBuffer(function(err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-file-file', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(fixtures.inputJpg)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bicubic)
-          .toFile(fixtures.outputJpg, function(err) {
-            if (err) {
-              throw err;
-            } else {
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-stream-stream', {
-      defer: true,
-      fn: function(deferred) {
-        var readable = fs.createReadStream(fixtures.inputJpg);
-        var writable = fs.createWriteStream(fixtures.outputJpg);
-        writable.on('finish', function() {
-          deferred.resolve();
-        });
-        var pipeline = sharp()
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bicubic);
-        readable.pipe(pipeline).pipe(writable);
-      }
-    }).add('sharp-file-buffer', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(fixtures.inputJpg)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bicubic)
-          .toBuffer(function(err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-promise', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bicubic)
-          .toBuffer()
-          .then(function(buffer) {
-            assert.notStrictEqual(null, buffer);
-            deferred.resolve();
-          });
-      }
-    }).on('cycle', function(event) {
-      console.log('jpeg-cubic ' + String(event.target));
-    }).on('complete', function() {
-      callback(null, this.filter('fastest').map('name'));
-    }).run();
-  },
-
-  // Comparitive speed of pixel interpolators
-  interpolators: function(callback) {
-    var inputJpgBuffer = fs.readFileSync(fixtures.inputJpg);
-    (new Benchmark.Suite('interpolators')).add('sharp-nearest-neighbour', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.nearest)
-          .toBuffer(function(err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-bilinear', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
-          .toBuffer(function(err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-vertexSplitQuadraticBasisSpline', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.vertexSplitQuadraticBasisSpline)
-          .toBuffer(function(err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-bicubic', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.bicubic)
-          .toBuffer(function(err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-locallyBoundedBicubic', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.locallyBoundedBicubic)
-          .toBuffer(function(err, buffer) {
-            if (err) {
-              throw err;
-            } else {
-              assert.notStrictEqual(null, buffer);
-              deferred.resolve();
-            }
-          });
-      }
-    }).add('sharp-nohalo', {
-      defer: true,
-      fn: function(deferred) {
-        sharp(inputJpgBuffer)
-          .resize(width, height)
-          .interpolateWith(sharp.interpolator.nohalo)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -880,12 +571,12 @@ async.series({
           });
       }
     }).on('cycle', function(event) {
-      console.log('interpolators ' + String(event.target));
+      console.log('kernels ' + String(event.target));
     }).on('complete', function() {
       callback(null, this.filter('fastest').map('name'));
     }).run();
   },
-
+  // PNG
   png: function(callback) {
     var inputPngBuffer = fs.readFileSync(fixtures.inputPng);
     var pngSuite = new Benchmark.Suite('png');
@@ -938,7 +629,7 @@ async.series({
             if (err) {
               throw err;
             }
-            image.resize(width, height, 'linear', function (err, image) {
+            image.resize(width, height, 'lanczos', function (err, image) {
               if (err) {
                 throw err;
               }
@@ -963,7 +654,7 @@ async.series({
           dstPath: fixtures.outputPng,
           width: width,
           height: height,
-          filter: magickFilterBilinear
+          filter: 'Lanczos'
         }, function(err) {
           if (err) {
             throw err;
@@ -983,7 +674,7 @@ async.series({
             width: width,
             height: height,
             format: 'PNG',
-            filter: magickFilterBilinear
+            filter: 'Lanczos'
           });
           deferred.resolve();
         }
@@ -995,7 +686,7 @@ async.series({
       fn: function(deferred) {
         gm(fixtures.inputPng)
           .resize(width, height)
-          .filter(magickFilterBilinear)
+          .filter('Lanczos')
           .write(fixtures.outputPng, function (err) {
             if (err) {
               throw err;
@@ -1009,7 +700,7 @@ async.series({
       fn: function(deferred) {
         gm(fixtures.inputPng)
           .resize(width, height)
-          .filter(magickFilterBilinear)
+          .filter('Lanczos')
           .toBuffer(function (err, buffer) {
             if (err) {
               throw err;
@@ -1026,7 +717,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputPngBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toFile(fixtures.outputPng, function(err) {
             if (err) {
               throw err;
@@ -1040,7 +730,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputPngBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -1055,7 +744,6 @@ async.series({
       fn: function(deferred) {
         sharp(fixtures.inputPng)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toFile(fixtures.outputPng, function(err) {
             if (err) {
               throw err;
@@ -1069,7 +757,6 @@ async.series({
       fn: function(deferred) {
         sharp(fixtures.inputPng)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -1084,7 +771,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputPngBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .progressive()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -1100,7 +786,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputPngBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .withoutAdaptiveFiltering()
           .toBuffer(function(err, buffer) {
             if (err) {
@@ -1118,7 +803,7 @@ async.series({
       callback(null, this.filter('fastest').map('name'));
     }).run();
   },
-
+  // WebP
   webp: function(callback) {
     var inputWebPBuffer = fs.readFileSync(fixtures.inputWebP);
     (new Benchmark.Suite('webp')).add('sharp-buffer-file', {
@@ -1126,7 +811,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputWebPBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toFile(fixtures.outputWebP, function(err) {
             if (err) {
               throw err;
@@ -1140,7 +824,6 @@ async.series({
       fn: function(deferred) {
         sharp(inputWebPBuffer)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;
@@ -1155,7 +838,6 @@ async.series({
       fn: function(deferred) {
         sharp(fixtures.inputWebP)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toFile(fixtures.outputWebP, function(err) {
             if (err) {
               throw err;
@@ -1169,7 +851,6 @@ async.series({
       fn: function(deferred) {
         sharp(fixtures.inputWebp)
           .resize(width, height)
-          .interpolateWith(sharp.interpolator.bilinear)
           .toBuffer(function(err, buffer) {
             if (err) {
               throw err;

test/bench/random.js

@@ -8,14 +8,12 @@ var Benchmark = require('benchmark');
 var sharp = require('../../index');
 var fixtures = require('../fixtures');
 
+sharp.cache(false);
 sharp.simd(true);
 
 var min = 320;
 var max = 960;
 
-// Nearest equivalent to bilinear
-var magickFilter = 'Triangle';
-
 var randomDimension = function() {
   return Math.ceil(Math.random() * (max - min) + min);
 };
@@ -30,7 +28,7 @@ new Benchmark.Suite('random').add('imagemagick', {
       width: randomDimension(),
       height: randomDimension(),
       format: 'jpg',
-      filter: magickFilter
+      filter: 'Lanczos'
     }, function(err) {
       if (err) {
         throw err;
@@ -44,7 +42,7 @@ new Benchmark.Suite('random').add('imagemagick', {
   fn: function(deferred) {
     gm(fixtures.inputJpg)
       .resize(randomDimension(), randomDimension())
-      .filter(magickFilter)
+      .filter('Lanczos')
       .quality(80)
       .toBuffer(function (err, buffer) {
         if (err) {
@@ -58,7 +56,9 @@ new Benchmark.Suite('random').add('imagemagick', {
 }).add('sharp', {
   defer: true,
   fn: function(deferred) {
-    sharp(fixtures.inputJpg).resize(randomDimension(), randomDimension()).toBuffer(function(err, buffer) {
+    sharp(fixtures.inputJpg)
+      .resize(randomDimension(), randomDimension())
+      .toBuffer(function(err, buffer) {
         if (err) {
           throw err;
         } else {
@@ -72,5 +72,4 @@ new Benchmark.Suite('random').add('imagemagick', {
 }).on('complete', function() {
   var winner = this.filter('fastest').map('name');
   assert.strictEqual('sharp', String(winner), 'sharp was slower than ' + winner);
-  console.dir(sharp.cache());
 }).run();