hphp/runtime/ext/imagick/imagick.cpp

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   6    | Copyright (c) 1997-2010 The PHP Group                                |
   7    +----------------------------------------------------------------------+
   8    | This source file is subject to version 3.01 of the PHP license,      |
   9    | that is bundled with this package in the file LICENSE, and is        |
  10    | available through the world-wide-web at the following url:           |
  11    | http://www.php.net/license/3_01.txt                                  |
  12    | If you did not receive a copy of the PHP license and are unable to   |
  13    | obtain it through the world-wide-web, please send a note to          |
  14    | license@php.net so we can mail you a copy immediately.               |
  15    +----------------------------------------------------------------------+
  16 */
  17
  18 #include "hphp/runtime/ext/imagick/ext_imagick.h"
  19
  20 #include "hphp/runtime/ext/std/ext_std_file.h"
  21 #include "hphp/runtime/ext/string/ext_string.h"
  22
  23 using std::pair;
  24 using std::string;
  25 using std::vector;
  26
  27 namespace HPHP {
  28
  29 #define IMAGICK_THROW imagickThrow<ImagickException>
  30
  31 // bool Imagick::$imagePending
  32 static const StaticString s_imagePending("imagePending");
  33
  34 ALWAYS_INLINE
  35 static bool getImagePending(const Object& imagick) {
  36   auto var = imagick->o_get(s_imagePending, true, s_Imagick);
  37   return var.toBoolean();
  38 }
  39
  40 ALWAYS_INLINE
  41 static void setImagePending(const Object& imagick, bool imagePending) {
  42   imagick->o_set(s_imagePending, imagePending, s_Imagick);
  43 }
  44
  45 // class ImageGeometry
  46 struct ImageGeometry {
  47   static const ImageGeometry empty_geometry;
  48
  49   ImageGeometry(int64_t width, int64_t height) :
  50     m_width(width), m_height(height) {
  51   }
  52
  53   explicit ImageGeometry(MagickWand* wand) :
  54     ImageGeometry(MagickGetImageWidth(wand), MagickGetImageHeight(wand)) {
  55   }
  56
  57   bool empty() const {
  58     return m_width <= 0 || m_height <= 0;
  59   }
  60
  61   bool operator==(const ImageGeometry& other) const {
  62     return m_width == other.m_width && m_height == other.m_height;
  63   }
  64
  65   bool operator!=(const ImageGeometry& other) const {
  66     return m_width != other.m_width || m_height != other.m_height;
  67   }
  68
  69   int64_t getWidth() const {
  70     return m_width;
  71   }
  72
  73   int64_t getHeight() const {
  74     return m_height;
  75   }
  76
  77   ImageGeometry scale(double ratio) const {
  78     static const double kEPS = 1e-8;
  79     return ImageGeometry(
  80       std::max<int64_t>(1, (int64_t)(m_width * ratio + kEPS)),
  81       std::max<int64_t>(1, (int64_t)(m_height * ratio + kEPS)));
  82   }
  83
  84   ImageGeometry toThumbnail(ImageGeometry hint, bool bestfit) const {
  85     if (empty()) {
  86       return empty_geometry;
  87     }
  88     double ratio_w = (double)hint.m_width / (double)m_width;
  89     double ratio_h = (double)hint.m_height / (double)m_height;
  90     if (bestfit) {
  91       if (hint.empty()) {
  92         return empty_geometry;
  93       } else {
  94         return scale(std::min(ratio_w, ratio_h));
  95       }
  96     } else {
  97       if (!hint.empty()) {
  98         return hint;
  99       } else if (hint.m_width <= 0 && hint.m_height <= 0) {
 100         return empty_geometry;
 101       } else {
 102         return scale(std::max(ratio_w, ratio_h));
 103       }
 104     }
 105   }
 106
 107   Array toArray() const {
 108     return make_map_array(
 109       s_width, m_width,
 110       s_height, m_height);
 111   }
 112
 113  private:
 114   int64_t m_width;
 115   int64_t m_height;
 116 };
 117
 118 const ImageGeometry ImageGeometry::empty_geometry(0, 0);
 119
 120 // assertion
 121 ALWAYS_INLINE
 122 static void ensureImageHasFormat(MagickWand* wand) {
 123   String format = convertMagickString(MagickGetImageFormat(wand));
 124   if (format.empty()) {
 125     IMAGICK_THROW("Image has no format");
 126   }
 127 }
 128
 129 ALWAYS_INLINE
 130 static void ensurePageIsValid(
 131     int64_t x, int64_t y, int64_t width, int64_t height) {
 132   if (x < 0 || y < 0) {
 133     IMAGICK_THROW("The coordinates must be non-negative");
 134   }
 135   if (width <= 0 || height <= 0) {
 136     IMAGICK_THROW("The width and height must be greater than zero");
 137   }
 138 }
 139
 140 ALWAYS_INLINE
 141 static void ensureChannelMapIsValid(const String& map) {
 142   static const StaticString s_channels("RGBAOCYMKIP");
 143   for (int i = 0; i < map.size(); ++i) {
 144     if (s_channels.find(map[i]) == String::npos) {
 145       IMAGICK_THROW("The map contains disallowed characters");
 146     }
 147   }
 148 }
 149
 150 // import/export ImagePixels
 151 template<StorageType T> struct StorageTypeCPPType;
 152 template<> struct StorageTypeCPPType<CharPixel> { using T = unsigned char; };
 153 template<> struct StorageTypeCPPType<LongPixel> { using T = long; };
 154 template<> struct StorageTypeCPPType<DoublePixel> { using T = double; };
 155
 156 ALWAYS_INLINE
 157 static StorageType resolveStorageType(StorageType storage) {
 158
 159 #define substituteStorageType(from, to) \
 160   do { \
 161     if (storage == from) { \
 162       /* \
 163       raiseDeprecated(s_Imagick.c_str(), #from, \
 164                       s_Imagick.c_str(), #to); \
 165       */ \
 166       storage = to; \
 167     } \
 168   } while (false)
 169
 170   substituteStorageType(FloatPixel, DoublePixel);
 171   substituteStorageType(ShortPixel, LongPixel);
 172   substituteStorageType(IntegerPixel, LongPixel);
 173
 174 #undef substituteStorageType
 175
 176   if (storage != CharPixel &&
 177       storage != IntegerPixel &&
 178       storage != DoublePixel) {
 179     IMAGICK_THROW("Unknown storage format");
 180   } else {
 181     return storage;
 182   }
 183 }
 184
 185 // misc
 186 ALWAYS_INLINE
 187 static String getImageMimeType(MagickWand* wand) {
 188   String format = convertMagickString(MagickGetImageFormat(wand));
 189   if (format.empty()) {
 190     return String();
 191   }
 192   String mimetype = convertMagickString(MagickToMime(format.c_str()));
 193   if (mimetype.empty()) {
 194     return String();
 195   }
 196   return mimetype;
 197 }
 198
 199 //////////////////////////////////////////////////////////////////////////////
 200 // Imagick Helper
 201 using MagickQueryFunction = char** (*)(const char*, size_t*);
 202
 203 Object createImagick(MagickWand* wand) {
 204   Object ret = Imagick::allocObject();
 205   setWandResource(s_Imagick, ret, wand);
 206   return ret;
 207 }
 208
 209 ALWAYS_INLINE
 210 static Array magickQuery(const char* pattern, MagickQueryFunction query) {
 211   size_t num = 0;
 212   auto result = query(pattern, &num);
 213   return convertMagickArray(num, result);
 214 }
 215
 216 Array magickQueryFonts(const char* pattern /* = "*" */) {
 217   return magickQuery(pattern, MagickQueryFonts);
 218 }
 219
 220 Array magickQueryFormats(const char* pattern /* = "*" */) {
 221   return magickQuery(pattern, MagickQueryFormats);
 222 }
 223
 224 String magickResolveFont(const String& fontName) {
 225   Array fonts = magickQueryFonts();
 226   for (ArrayIter it(fonts); it; ++it) {
 227     if (strcasecmp(it.secondRefPlus().toCStrRef().c_str(),
 228                    fontName.c_str()) == 0) {
 229       return fontName;
 230     }
 231   }
 232   auto font = HHVM_FN(realpath)(fontName);
 233   if (font.isBoolean() && !font.toBoolean()) {
 234     return String();
 235   } else {
 236     return font.toString();
 237   }
 238 }
 239
 240 //////////////////////////////////////////////////////////////////////////////
 241 // class Imagick
 242 static bool HHVM_METHOD(Imagick, adaptiveBlurImage,
 243     double radius, double sigma, int64_t channel) {
 244   auto wand = getMagickWandResource(Object{this_});
 245   auto status = MagickAdaptiveBlurImageChannel(
 246     wand->getWand(), (ChannelType)channel, radius, sigma);
 247   if (status == MagickFalse) {
 248     IMAGICK_THROW("Unable to adaptive blur image");
 249   }
 250   return true;
 251 }
 252
 253 static bool HHVM_METHOD(Imagick, adaptiveResizeImage,
 254     int64_t columns, int64_t rows, bool bestfit) {
 255   auto wand = getMagickWandResource(Object{this_});
 256   auto geometry = ImageGeometry(wand->getWand()).toThumbnail(
 257     {columns, rows}, bestfit);
 258   if (geometry.empty()) {
 259     IMAGICK_THROW("Invalid image geometry");
 260   }
 261   auto status = MagickAdaptiveResizeImage(
 262     wand->getWand(), geometry.getWidth(), geometry.getHeight());
 263   if (status == MagickFalse) {
 264     IMAGICK_THROW("Unable to adaptive resize image");
 265   }
 266   return true;
 267 }
 268
 269 static bool HHVM_METHOD(Imagick, adaptiveSharpenImage,
 270     double radius, double sigma, int64_t channel) {
 271   auto wand = getMagickWandResource(Object{this_});
 272   auto status = MagickAdaptiveSharpenImageChannel(
 273     wand->getWand(), (ChannelType)channel, radius, sigma);
 274   if (status == MagickFalse) {
 275     IMAGICK_THROW("Unable to adaptive sharpen image");
 276   }
 277   return true;
 278 }
 279
 280 static bool HHVM_METHOD(Imagick, adaptiveThresholdImage,
 281     int64_t width, int64_t height, int64_t offset) {
 282   auto wand = getMagickWandResource(Object{this_});
 283   auto status = MagickAdaptiveThresholdImage(
 284     wand->getWand(), width, height, offset);
 285   if (status == MagickFalse) {
 286     IMAGICK_THROW("Unable to adaptive threshold image");
 287   }
 288   return true;
 289 }
 290
 291 static bool HHVM_METHOD(Imagick, addImage, const Object& source) {
 292   auto wand = getMagickWandResource(Object{this_});
 293   auto magick = getMagickWandResource(source);
 294   auto status = MagickAddImage(wand->getWand(), magick->getWand());
 295   if (status == MagickFalse) {
 296     IMAGICK_THROW("Unable to add image");
 297   }
 298   MagickSetLastIterator(wand->getWand());
 299   return true;
 300 }
 301
 302 static bool HHVM_METHOD(Imagick, addNoiseImage,
 303     int64_t noise_type, int64_t channel) {
 304   auto wand = getMagickWandResource(Object{this_});
 305   auto status = MagickAddNoiseImageChannel(
 306     wand->getWand(), (ChannelType)channel, (NoiseType)noise_type);
 307   if (status == MagickFalse) {
 308     IMAGICK_THROW("Unable to add image noise");
 309   }
 310   return true;
 311 }
 312
 313 static bool HHVM_METHOD(Imagick, affineTransformImage, const Object& matrix) {
 314   auto wand = getMagickWandResource(Object{this_});
 315   auto drawing = getDrawingWandResource(matrix);
 316   auto status = MagickAffineTransformImage(
 317     wand->getWand(), drawing->getWand());
 318   if (status == MagickFalse) {
 319     IMAGICK_THROW("Unable to affine transform image");
 320   }
 321   return true;
 322 }
 323
 324 static bool HHVM_METHOD(Imagick, animateImages, const String& x_server) {
 325   auto wand = getMagickWandResource(Object{this_});
 326   MagickSetFirstIterator(wand->getWand());
 327   auto status = MagickAnimateImages(wand->getWand(), x_server.c_str());
 328   if (status == MagickFalse) {
 329     IMAGICK_THROW("Unable to animate images");
 330   }
 331   return true;
 332 }
 333
 334 static bool HHVM_METHOD(Imagick, annotateImage, const Object& draw_settings,
 335     double x, double y, double angle, const String& text) {
 336   auto wand = getMagickWandResource(Object{this_});
 337   auto drawing = getDrawingWandResource(draw_settings);
 338   auto status = MagickAnnotateImage(
 339     wand->getWand(), drawing->getWand(), x, y, angle, text.c_str());
 340   if (status == MagickFalse) {
 341     IMAGICK_THROW("Unable to annotate image");
 342   }
 343   return true;
 344 }
 345
 346 static Object HHVM_METHOD(Imagick, appendImages, bool stack) {
 347   auto wand = getMagickWandResource(Object{this_});
 348   auto magick = MagickAppendImages(wand->getWand(), toMagickBool(stack));
 349   if (magick == nullptr) {
 350     IMAGICK_THROW("Unable to append images");
 351   }
 352   return createImagick(magick);
 353 }
 354
 355 static Object HHVM_METHOD(Imagick, averageImages) {
 356   raiseDeprecated(s_Imagick.c_str(), "averageImages");
 357
 358   auto wand = getMagickWandResource(Object{this_});
 359 #pragma GCC diagnostic push
 360 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 361   auto magick = MagickAverageImages(wand->getWand());
 362 #pragma GCC diagnostic pop
 363   if (magick == nullptr) {
 364     IMAGICK_THROW("Averaging images failed");
 365   }
 366   return createImagick(magick);
 367 }
 368
 369 static bool HHVM_METHOD(Imagick, blackThresholdImage,
 370     const Variant& threshold) {
 371   auto wand = getMagickWandResource(Object{this_});
 372   auto pixel = buildColorWand(threshold);
 373   auto status = MagickBlackThresholdImage(wand->getWand(), pixel->getWand());
 374   if (status == MagickFalse) {
 375     IMAGICK_THROW("Unable to black threshold image");
 376   }
 377   return true;
 378 }
 379
 380 static bool HHVM_METHOD(Imagick, blurImage,
 381     double radius, double sigma, int64_t channel) {
 382   auto wand = getMagickWandResource(Object{this_});
 383   auto status = MagickBlurImageChannel(
 384     wand->getWand(), (ChannelType)channel, radius, sigma);
 385   if (status == MagickFalse) {
 386     IMAGICK_THROW("Unable to blur image");
 387   }
 388   return true;
 389 }
 390
 391 static bool HHVM_METHOD(Imagick, borderImage,
 392     const Variant& bordercolor, int64_t width, int64_t height) {
 393   auto wand = getMagickWandResource(Object{this_});
 394   auto pixel = buildColorWand(bordercolor);
 395   auto status = MagickBorderImage(
 396     wand->getWand(), pixel->getWand(), width, height);
 397   if (status == MagickFalse) {
 398     IMAGICK_THROW("Unable to border image");
 399   }
 400   return true;
 401 }
 402
 403 static bool HHVM_METHOD(Imagick, charcoalImage,
 404     double radius, double sigma) {
 405   auto wand = getMagickWandResource(Object{this_});
 406   auto status = MagickCharcoalImage(wand->getWand(), radius, sigma);
 407   if (status == MagickFalse) {
 408     IMAGICK_THROW("Unable to charcoal image");
 409   }
 410   return true;
 411 }
 412
 413 static bool HHVM_METHOD(Imagick, chopImage,
 414     int64_t width, int64_t height, int64_t x, int64_t y) {
 415   auto wand = getMagickWandResource(Object{this_});
 416   auto status = MagickChopImage(wand->getWand(), width, height, x, y);
 417   if (status == MagickFalse) {
 418     IMAGICK_THROW("Unable to chop image");
 419   }
 420   return true;
 421 }
 422
 423 static bool HHVM_METHOD(Imagick, clear) {
 424   auto wand = getWandResource<MagickWand>(s_Imagick, Object{this_});
 425   if (!wand || wand->getWand() == nullptr) {
 426     return false;
 427   } else {
 428     ClearMagickWand(wand->getWand());
 429     setImagePending(Object{this_}, false);
 430     return true;
 431   }
 432 }
 433
 434 static bool HHVM_METHOD(Imagick, clipImage) {
 435   auto wand = getMagickWandResource(Object{this_});
 436   auto status = MagickClipImage(wand->getWand());
 437   if (status == MagickFalse) {
 438     IMAGICK_THROW("Unable to clip image");
 439   }
 440   return true;
 441 }
 442
 443 static bool HHVM_METHOD(Imagick, clipPathImage,
 444     const String& pathname, bool inside) {
 445   auto wand = getMagickWandResource(Object{this_});
 446   auto status = MagickClipImagePath(
 447     wand->getWand(), pathname.c_str(), toMagickBool(inside));
 448   if (status == MagickFalse) {
 449     IMAGICK_THROW("Unable to clip path image");
 450   }
 451   return true;
 452 }
 453
 454 static void HHVM_METHOD(Imagick, __clone) {
 455   auto wand = getMagickWandResource(Object{this_});
 456   auto magick = CloneMagickWand(wand->getWand());
 457   if (magick == nullptr) {
 458     IMAGICK_THROW("Cloning Imagick object failed");
 459   } else {
 460     setWandResource(s_Imagick, Object{this_}, magick);
 461   }
 462 }
 463
 464 static bool HHVM_METHOD(Imagick, clutImage,
 465     const Object& lookup_table, int64_t channel) {
 466   auto wand = getMagickWandResource(Object{this_});
 467   auto magick = getMagickWandResource(lookup_table);
 468   auto status = MagickClutImageChannel(
 469     wand->getWand(), (ChannelType)channel, magick->getWand());
 470   if (status == MagickFalse) {
 471     IMAGICK_THROW(
 472       "Unable to replace colors in the image from a color lookup table");
 473   }
 474   return true;
 475 }
 476
 477 static Object HHVM_METHOD(Imagick, coalesceImages) {
 478   auto wand = getMagickWandResource(Object{this_});
 479   auto magick = MagickCoalesceImages(wand->getWand());
 480   if (magick == nullptr) {
 481     IMAGICK_THROW("Coalesce image failed");
 482   }
 483   return createImagick(magick);
 484 }
 485
 486 static bool HHVM_METHOD(Imagick, colorFloodfillImage,
 487     const Variant& fill, double fuzz,
 488     const Variant& bordercolor, int64_t x, int64_t y) {
 489   raiseDeprecated(s_Imagick.c_str(), "colorFloodFillImage");
 490
 491   auto wand = getMagickWandResource(Object{this_});
 492   auto fillPixel = buildColorWand(fill);
 493   auto borderPixel = buildColorWand(bordercolor);
 494 #pragma GCC diagnostic push
 495 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 496   auto status = MagickColorFloodfillImage(
 497     wand->getWand(), fillPixel->getWand(), fuzz, borderPixel->getWand(), x, y);
 498 #pragma GCC diagnostic pop
 499   if (status == MagickFalse) {
 500     IMAGICK_THROW("Unable to color floodfill image");
 501   }
 502   return true;
 503 }
 504
 505 static bool HHVM_METHOD(Imagick, colorizeImage,
 506     const Variant& colorize, const Variant& opacity) {
 507   auto wand = getMagickWandResource(Object{this_});
 508   auto colorPixel = buildColorWand(colorize);
 509   auto opacityPixel = buildOpacityWand(opacity);
 510   auto pixel = req::make<WandResource<PixelWand>>(
 511     ClonePixelWand(colorPixel->getWand()));
 512
 513   if (pixel->getWand() == nullptr) {
 514     IMAGICK_THROW("Failed to allocate");
 515   } else {
 516     auto opacityValue = PixelGetOpacity(opacityPixel->getWand());
 517     auto alphaValue = PixelGetAlpha(opacityPixel->getWand());
 518     PixelSetOpacity(pixel->getWand(), opacityValue);
 519     PixelSetAlpha(pixel->getWand(), alphaValue);
 520   }
 521
 522   auto status = MagickColorizeImage(
 523     wand->getWand(), pixel->getWand(), pixel->getWand());
 524   if (status == MagickFalse) {
 525     IMAGICK_THROW("Unable to colorize image");
 526   }
 527   return true;
 528 }
 529
 530 static Object HHVM_METHOD(Imagick, combineImages, int64_t channelType) {
 531   auto wand = getMagickWandResource(Object{this_});
 532   auto magick = MagickCombineImages(wand->getWand(), (ChannelType)channelType);
 533   if (magick == nullptr) {
 534     IMAGICK_THROW("Combine images failed");
 535   }
 536   return createImagick(magick);
 537 }
 538
 539 static bool HHVM_METHOD(Imagick, commentImage, const String& comment) {
 540   auto wand = getMagickWandResource(Object{this_});
 541   auto status = MagickCommentImage(wand->getWand(), comment.c_str());
 542   if (status == MagickFalse) {
 543     IMAGICK_THROW("Unable to comment image");
 544   }
 545   return true;
 546 }
 547
 548 static Array HHVM_METHOD(Imagick, compareImageChannels,
 549     const Object& image, int64_t channelType, int64_t metricType) {
 550   auto wand = getMagickWandResource(Object{this_});
 551   auto wand2 = getMagickWandResource(image);
 552   double distortion;
 553   auto magick = MagickCompareImageChannels(
 554     wand->getWand(), wand2->getWand(),
 555     (ChannelType)channelType, (MetricType)metricType, &distortion);
 556
 557   if (magick == nullptr) {
 558     IMAGICK_THROW("Compare image channels failed");
 559   } else {
 560     return make_packed_array(createImagick(magick), distortion);
 561   }
 562 }
 563
 564 static Object HHVM_METHOD(Imagick, compareImageLayers, int64_t method) {
 565   auto wand = getMagickWandResource(Object{this_});
 566   auto magick = MagickCompareImageLayers(
 567     wand->getWand(), (ImageLayerMethod)method);
 568   if (magick == nullptr) {
 569     IMAGICK_THROW("Compare image layers failed");
 570   }
 571   return createImagick(magick);
 572 }
 573
 574 static Array HHVM_METHOD(Imagick, compareImages,
 575     const Object& compare, int64_t metric) {
 576   auto wand = getMagickWandResource(Object{this_});
 577   auto wand2 = getMagickWandResource(compare);
 578   double distortion;
 579   auto magick = MagickCompareImages(
 580     wand->getWand(), wand2->getWand(),
 581     (MetricType)metric, &distortion);
 582
 583   if (magick == nullptr) {
 584     IMAGICK_THROW("Compare images failed");
 585   } else {
 586     return make_packed_array(createImagick(magick), distortion);
 587   }
 588 }
 589
 590 static bool HHVM_METHOD(Imagick, compositeImage,
 591     const Object& composite_object, int64_t composite,
 592     int64_t x, int64_t y, int64_t channel) {
 593   auto wand = getMagickWandResource(Object{this_});
 594   auto wand2 = getMagickWandResource(composite_object);
 595   MagickCompositeImageChannel(
 596     wand->getWand(), (ChannelType)channel,
 597     wand2->getWand(), (CompositeOperator)composite, x, y);
 598   return true;
 599 }
 600
 601 static void HHVM_METHOD(Imagick, __construct, const Variant& files) {
 602   auto magick = NewMagickWand();
 603   if (magick == nullptr) {
 604     IMAGICK_THROW("Failed to create ImagickDraw object");
 605   } else {
 606     setWandResource(s_Imagick, Object{this_}, magick);
 607   }
 608   auto wand = getMagickWandResource(Object{this_});
 609   Array array = files.isString() ? make_packed_array(files)
 610               : files.isArray() ? files.toArray()
 611               : Array();
 612   for (ArrayIter it(array); it; ++it) {
 613     String file = it.secondRefPlus().toString();
 614     imagickReadOp(wand->getWand(), file, MagickReadImage);
 615   }
 616 }
 617
 618 static bool HHVM_METHOD(Imagick, contrastImage, bool sharpen) {
 619   auto wand = getMagickWandResource(Object{this_});
 620   auto status = MagickContrastImage(wand->getWand(), toMagickBool(sharpen));
 621   if (status == MagickFalse) {
 622     IMAGICK_THROW("Unable to contrast image");
 623   }
 624   return true;
 625 }
 626
 627 static bool HHVM_METHOD(Imagick, contrastStretchImage,
 628     double black_point, double white_point, int64_t channel) {
 629   auto wand = getMagickWandResource(Object{this_});
 630   auto status = MagickContrastStretchImageChannel(
 631     wand->getWand(), (ChannelType)channel, black_point, white_point);
 632   if (status == MagickFalse) {
 633     IMAGICK_THROW("Unable to contrast strech image");
 634   }
 635   return true;
 636 }
 637
 638 static bool HHVM_METHOD(Imagick, convolveImage,
 639     const Array& kernelArray, int64_t channel) {
 640   auto wand = getMagickWandResource(Object{this_});
 641   auto kernel = toDoubleArray(kernelArray);
 642   if (kernel.empty()) {
 643     IMAGICK_THROW("Unable to read matrix array");
 644   }
 645   auto order = (size_t)sqrt(kernel.size());
 646   auto status = MagickConvolveImageChannel(
 647     wand->getWand(), (ChannelType)channel, order, kernel.data());
 648   if (status == MagickFalse) {
 649     IMAGICK_THROW("Unable to convolve image");
 650   }
 651   return true;
 652 }
 653
 654 static bool HHVM_METHOD(Imagick, cropImage,
 655     int64_t width, int64_t height, int64_t x, int64_t y) {
 656   auto wand = getMagickWandResource(Object{this_});
 657   auto status = MagickCropImage(wand->getWand(), width, height, x, y);
 658   if (status == MagickFalse) {
 659     IMAGICK_THROW("Unable to crop image");
 660   }
 661   return true;
 662 }
 663
 664 static bool HHVM_METHOD(Imagick, cropThumbnailImage,
 665     int64_t width, int64_t height) {
 666   auto wand = getMagickWandResource(Object{this_});
 667   auto geometry = ImageGeometry(wand->getWand());
 668   ImageGeometry thumbnail(width, height);
 669   MagickBooleanType status;
 670
 671   if (thumbnail.empty()) {
 672     status = MagickFalse;
 673   } else if (thumbnail == geometry) {
 674     // Already at the size, just strip profiles
 675     status = MagickStripImage(wand->getWand());
 676   } else {
 677     auto ratio_w = (double)thumbnail.getWidth() / geometry.getWidth();
 678     auto ratio_h = (double)thumbnail.getHeight() / geometry.getHeight();
 679     auto thumbnail = geometry.scale(std::max(ratio_w, ratio_h));
 680     status = MagickThumbnailImage(
 681       wand->getWand(), thumbnail.getWidth(), thumbnail.getHeight());
 682     if (status != MagickFalse && thumbnail != ImageGeometry(width, height)) {
 683       auto crop_x = (thumbnail.getWidth() - width) / 2;
 684       auto crop_y = (thumbnail.getHeight() - height) / 2;
 685       status = MagickCropImage(
 686         wand->getWand(), width, height, crop_x, crop_y);
 687       if (status != MagickFalse) {
 688         status = MagickSetImagePage(wand->getWand(), width, height, 0, 0);
 689       }
 690     }
 691   }
 692
 693   if (status == MagickFalse) {
 694     IMAGICK_THROW("Unable to crop-thumbnail image");
 695   }
 696   return true;
 697 }
 698
 699 static bool HHVM_METHOD(Imagick, cycleColormapImage, int64_t displace) {
 700   auto wand = getMagickWandResource(Object{this_});
 701   auto status = MagickCycleColormapImage(wand->getWand(), displace);
 702   if (status == MagickFalse) {
 703     IMAGICK_THROW("Unable to cycle image colormap");
 704   }
 705   return true;
 706 }
 707
 708 static bool HHVM_METHOD(Imagick, decipherImage, const String& passphrase) {
 709   auto wand = getMagickWandResource(Object{this_});
 710   auto status = MagickDecipherImage(wand->getWand(), passphrase.c_str());
 711   if (status == MagickFalse) {
 712     IMAGICK_THROW("Unable to decipher image");
 713   }
 714   return true;
 715 }
 716
 717 static Object HHVM_METHOD(Imagick, deconstructImages) {
 718   auto wand = getMagickWandResource(Object{this_});
 719   auto magick = MagickDeconstructImages(wand->getWand());
 720   if (magick == nullptr) {
 721     IMAGICK_THROW("Deconstruct image failed");
 722   }
 723   return createImagick(magick);
 724 }
 725
 726 static bool HHVM_METHOD(Imagick, deleteImageArtifact,
 727     const String& artifact) {
 728   auto wand = getMagickWandResource(Object{this_});
 729   auto status = MagickDeleteImageArtifact(wand->getWand(), artifact.c_str());
 730   if (status == MagickFalse) {
 731     IMAGICK_THROW("Unable to delete image artifact");
 732   }
 733   return true;
 734 }
 735
 736 static bool HHVM_METHOD(Imagick, deskewImage, double threshold) {
 737   auto wand = getMagickWandResource(Object{this_});
 738   auto status = MagickDeskewImage(wand->getWand(), threshold);
 739   if (status == MagickFalse) {
 740     IMAGICK_THROW("Unable to deskew image");
 741   }
 742   return true;
 743 }
 744
 745 static bool HHVM_METHOD(Imagick, despeckleImage) {
 746   auto wand = getMagickWandResource(Object{this_});
 747   auto status = MagickDespeckleImage(wand->getWand());
 748   if (status == MagickFalse) {
 749     IMAGICK_THROW("Unable to despeckle image");
 750   }
 751   return true;
 752 }
 753
 754 static bool HHVM_METHOD(Imagick, destroy) {
 755   return HHVM_MN(Imagick, clear)(this_);
 756 }
 757
 758 static bool HHVM_METHOD(Imagick, displayImage, const String& servername) {
 759   auto wand = getMagickWandResource(Object{this_});
 760   auto status = MagickDisplayImage(wand->getWand(), servername.c_str());
 761   if (status == MagickFalse) {
 762     IMAGICK_THROW("Unable to display image");
 763   }
 764   return true;
 765 }
 766
 767 static bool HHVM_METHOD(Imagick, displayImages, const String& servername) {
 768   auto wand = getMagickWandResource(Object{this_});
 769   auto status = MagickDisplayImages(wand->getWand(), servername.c_str());
 770   if (status == MagickFalse) {
 771     IMAGICK_THROW("Unable to display images");
 772   }
 773   return true;
 774 }
 775
 776 static bool HHVM_METHOD(Imagick, distortImage,
 777     int64_t method, const Array& arguments, bool bestfit) {
 778   auto wand = getMagickWandResource(Object{this_});
 779   auto args = toDoubleArray(arguments);
 780   if (args.empty()) {
 781     IMAGICK_THROW("Can't read argument array");
 782   }
 783   auto status = MagickDistortImage(
 784     wand->getWand(), (DistortImageMethod)method,
 785     args.size(), args.data(), toMagickBool(bestfit));
 786   if (status == MagickFalse) {
 787     IMAGICK_THROW("Unable to distort the image");
 788   }
 789   return true;
 790 }
 791
 792 static bool HHVM_METHOD(Imagick, drawImage, const Object& draw) {
 793   auto wand = getMagickWandResource(Object{this_});
 794   auto drawing = getDrawingWandResource(draw);
 795   auto status = withMagickLocaleFix([&wand, &drawing](){
 796     return MagickDrawImage(wand->getWand(), drawing->getWand());
 797   });
 798   if (status == MagickFalse) {
 799     IMAGICK_THROW("Unable to draw image");
 800   }
 801   return true;
 802 }
 803
 804 static bool HHVM_METHOD(Imagick, edgeImage, double radius) {
 805   auto wand = getMagickWandResource(Object{this_});
 806   auto status = MagickEdgeImage(wand->getWand(), radius);
 807   if (status == MagickFalse) {
 808     IMAGICK_THROW("Unable to edge image");
 809   }
 810   return true;
 811 }
 812
 813 static bool HHVM_METHOD(Imagick, embossImage, double radius, double sigma) {
 814   auto wand = getMagickWandResource(Object{this_});
 815   auto status = MagickEmbossImage(wand->getWand(), radius, sigma);
 816   if (status == MagickFalse) {
 817     IMAGICK_THROW("Unable to emboss image");
 818   }
 819   return true;
 820 }
 821
 822 static bool HHVM_METHOD(Imagick, encipherImage, const String& passphrase) {
 823   auto wand = getMagickWandResource(Object{this_});
 824   auto status = MagickEncipherImage(wand->getWand(), passphrase.c_str());
 825   if (status == MagickFalse) {
 826     IMAGICK_THROW("Unable to encipher image");
 827   }
 828   return true;
 829 }
 830
 831 static bool HHVM_METHOD(Imagick, enhanceImage) {
 832   auto wand = getMagickWandResource(Object{this_});
 833   auto status = MagickEnhanceImage(wand->getWand());
 834   if (status == MagickFalse) {
 835     IMAGICK_THROW("Unable to enchance image");
 836   }
 837   return true;
 838 }
 839
 840 static bool HHVM_METHOD(Imagick, equalizeImage) {
 841   auto wand = getMagickWandResource(Object{this_});
 842   auto status = MagickEqualizeImage(wand->getWand());
 843   if (status == MagickFalse) {
 844     IMAGICK_THROW("Unable to equalize image");
 845   }
 846   return true;
 847 }
 848
 849 static bool HHVM_METHOD(Imagick, evaluateImage,
 850     int64_t op, double constant, int64_t channel) {
 851   auto wand = getMagickWandResource(Object{this_});
 852   auto status = MagickEvaluateImageChannel(wand->getWand(),
 853     (ChannelType)channel, (MagickEvaluateOperator)op, constant);
 854   if (status == MagickFalse) {
 855     IMAGICK_THROW("Unable to evaluate image");
 856   }
 857   return true;
 858 }
 859
 860 template<StorageType T>
 861 ALWAYS_INLINE
 862 static vector<typename StorageTypeCPPType<T>::T> exportImagePixels(
 863     req::ptr<WandResource<MagickWand>> wand, int64_t x, int64_t y,
 864     int64_t width, int64_t height, const String& map) {
 865   size_t size = width * height * map.length();
 866   vector<typename StorageTypeCPPType<T>::T> ret(size);
 867   auto status = MagickExportImagePixels(
 868     wand->getWand(), x, y, width, height, map.c_str(), T, (void*)ret.data());
 869   if (status == MagickFalse) {
 870     IMAGICK_THROW("Unable to export image pixels");
 871   }
 872   return ret;
 873 }
 874
 875 static Array HHVM_METHOD(Imagick, exportImagePixels,
 876                          int64_t x, int64_t y,
 877                          int64_t width, int64_t height,
 878                          const String& map, int64_t storage_) {
 879   auto wand = getMagickWandResource(Object{this_});
 880   ensurePageIsValid(x, y, width, height);
 881   ensureChannelMapIsValid(map);
 882   auto storage = resolveStorageType((StorageType)storage_);
 883
 884   if (storage == DoublePixel) {
 885     auto ret = exportImagePixels<DoublePixel>(wand, x, y, width, height, map);
 886     return convertArray(ret.size(), ret.data());
 887   } else {
 888     vector<int64_t> ret;
 889     if (storage == CharPixel) {
 890       auto tmp = exportImagePixels<CharPixel>(wand, x, y, width, height, map);
 891       ret.assign(tmp.begin(), tmp.end());
 892     } else {
 893       auto tmp = exportImagePixels<LongPixel>(wand, x, y, width, height, map);
 894       ret.assign(tmp.begin(), tmp.end());
 895     }
 896     return convertArray(ret.size(), ret.data());
 897   }
 898 }
 899
 900 static bool HHVM_METHOD(Imagick, extentImage,
 901     int64_t width, int64_t height, int64_t x, int64_t y) {
 902   auto wand = getMagickWandResource(Object{this_});
 903   auto status = MagickExtentImage(wand->getWand(), width, height, x, y);
 904   if (status == MagickFalse) {
 905     IMAGICK_THROW("Unable to extent image");
 906   }
 907   return true;
 908 }
 909
 910 static Object HHVM_METHOD(Imagick, flattenImages) {
 911   raiseDeprecated(s_Imagick.c_str(), "flattenImages");
 912
 913   auto wand = getMagickWandResource(Object{this_});
 914   MagickSetFirstIterator(wand->getWand());
 915 #pragma GCC diagnostic push
 916 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 917   auto magick = MagickFlattenImages(wand->getWand());
 918 #pragma GCC diagnostic pop
 919   if (magick == nullptr) {
 920     IMAGICK_THROW("Flatten images failed");
 921   }
 922   return createImagick(magick);
 923 }
 924
 925 static bool HHVM_METHOD(Imagick, flipImage) {
 926   auto wand = getMagickWandResource(Object{this_});
 927   auto status = MagickFlipImage(wand->getWand());
 928   if (status == MagickFalse) {
 929     IMAGICK_THROW("Unable to flip image");
 930   }
 931   return true;
 932 }
 933
 934 static bool HHVM_METHOD(Imagick, floodFillPaintImage,
 935                         const Variant& fill, double fuzz,
 936                         const Variant& target, int64_t x, int64_t y,
 937                         bool invert, int64_t channel /*=Default*/) {
 938   auto wand = getMagickWandResource(Object{this_});
 939   auto fillPixel = buildColorWand(fill);
 940   auto targetPixel = buildColorWand(target);
 941   auto status = MagickFloodfillPaintImage(
 942     wand->getWand(), (ChannelType)channel, fillPixel->getWand(),
 943     fuzz, targetPixel->getWand(), x, y, toMagickBool(invert));
 944   if (status == MagickFalse) {
 945     IMAGICK_THROW("Unable to floodfill paint image");
 946   }
 947   return true;
 948 }
 949
 950 static bool HHVM_METHOD(Imagick, flopImage) {
 951   auto wand = getMagickWandResource(Object{this_});
 952   auto status = MagickFlopImage(wand->getWand());
 953   if (status == MagickFalse) {
 954     IMAGICK_THROW("Unable to flop image");
 955   }
 956   return true;
 957 }
 958
 959 static bool HHVM_METHOD(Imagick, frameImage, const Variant& matte_color,
 960     int64_t width, int64_t height, int64_t inner_bevel, int64_t outer_bevel) {
 961   auto wand = getMagickWandResource(Object{this_});
 962   auto pixel = buildColorWand(matte_color);
 963   auto status = MagickFrameImage(
 964     wand->getWand(), pixel->getWand(),
 965     width, height, inner_bevel, outer_bevel);
 966   if (status == MagickFalse) {
 967     IMAGICK_THROW("Unable to frame image");
 968   }
 969   return true;
 970 }
 971
 972 static bool HHVM_METHOD(Imagick, functionImage,
 973     int64_t func, const Array& arguments, int64_t channel) {
 974   auto wand = getMagickWandResource(Object{this_});
 975   auto args = toDoubleArray(arguments);
 976   if (args.empty()) {
 977     IMAGICK_THROW("The arguments array contains disallowed characters");
 978   }
 979   auto status = MagickFunctionImageChannel(
 980     wand->getWand(), (ChannelType)channel, (MagickFunction)func,
 981     args.size(), args.data());
 982   if (status == MagickFalse) {
 983     IMAGICK_THROW("Unable to execute function on the image");
 984   }
 985   return true;
 986 }
 987
 988 static Object HHVM_METHOD(Imagick, fxImage,
 989     const String& expression, int64_t channel) {
 990   auto wand = getMagickWandResource(Object{this_});
 991   auto magick = MagickFxImageChannel(
 992     wand->getWand(), (ChannelType)channel, expression.c_str());
 993   if (magick == nullptr) {
 994     IMAGICK_THROW("Fx image failed");
 995   }
 996   return createImagick(magick);
 997 }
 998
 999 static bool HHVM_METHOD(Imagick, gammaImage, double gamma, int64_t channel) {
1000   auto wand = getMagickWandResource(Object{this_});
1001   auto status = MagickGammaImageChannel(
1002     wand->getWand(), (ChannelType)channel, gamma);
1003   if (status == MagickFalse) {
1004     IMAGICK_THROW("Unable to gamma image");
1005   }
1006   return true;
1007 }
1008
1009 static bool HHVM_METHOD(Imagick, gaussianBlurImage,
1010     double radius, double sigma, int64_t channel) {
1011   auto wand = getMagickWandResource(Object{this_});
1012   auto status = MagickGaussianBlurImageChannel(
1013     wand->getWand(), (ChannelType)channel, radius, sigma);
1014   if (status == MagickFalse) {
1015     IMAGICK_THROW("Unable to gaussian blur image");
1016   }
1017   return true;
1018 }
1019
1020 static int64_t HHVM_METHOD(Imagick, getColorspace) {
1021   auto wand = getMagickWandResource(Object{this_});
1022   return MagickGetColorspace(wand->getWand());
1023 }
1024
1025 static int64_t HHVM_METHOD(Imagick, getCompression) {
1026   auto wand = getMagickWandResource(Object{this_});
1027   return MagickGetCompression(wand->getWand());
1028 }
1029
1030 static int64_t HHVM_METHOD(Imagick, getCompressionQuality) {
1031   auto wand = getMagickWandResource(Object{this_});
1032   return MagickGetCompressionQuality(wand->getWand());
1033 }
1034
1035 static String HHVM_STATIC_METHOD(Imagick, getCopyright) {
1036   return MagickGetCopyright();
1037 }
1038
1039 static String HHVM_METHOD(Imagick, getFilename) {
1040   auto wand = getMagickWandResource(Object{this_});
1041   return convertMagickString(MagickGetFilename(wand->getWand()));
1042 }
1043
1044 static String HHVM_METHOD(Imagick, getFont) {
1045   auto wand = getMagickWandResource(Object{this_});
1046   return convertMagickString(MagickGetFont(wand->getWand()));
1047 }
1048
1049 static String HHVM_METHOD(Imagick, getFormat) {
1050   auto wand = getMagickWandResource(Object{this_});
1051   return convertMagickString(MagickGetFormat(wand->getWand()));
1052 }
1053
1054 static int64_t HHVM_METHOD(Imagick, getGravity) {
1055   auto wand = getMagickWandResource(Object{this_});
1056   return MagickGetGravity(wand->getWand());
1057 }
1058
1059 static String HHVM_STATIC_METHOD(Imagick, getHomeURL) {
1060   return convertMagickString(MagickGetHomeURL());
1061 }
1062
1063 static Object HHVM_METHOD(Imagick, getImage) {
1064   auto wand = getMagickWandResource(Object{this_});
1065   auto magick = MagickGetImage(wand->getWand());
1066   if (magick == nullptr) {
1067     IMAGICK_THROW("Get image failed");
1068   }
1069   return createImagick(magick);
1070 }
1071
1072 static int64_t HHVM_METHOD(Imagick, getImageAlphaChannel) {
1073   auto wand = getMagickWandResource(Object{this_});
1074   return MagickGetImageAlphaChannel(wand->getWand());
1075 }
1076
1077 static String HHVM_METHOD(Imagick, getImageArtifact,
1078     const String& artifact) {
1079   auto wand = getMagickWandResource(Object{this_});
1080   return convertMagickString(
1081     MagickGetImageArtifact(wand->getWand(), artifact.c_str()));
1082 }
1083
1084 static Object HHVM_METHOD(Imagick, getImageBackgroundColor) {
1085   auto wand = getMagickWandResource(Object{this_});
1086   auto pixel = newPixelWand();
1087   auto status = MagickGetImageBackgroundColor(
1088     wand->getWand(), pixel->getWand());
1089   if (pixel->getWand() == nullptr || status == MagickFalse) {
1090     IMAGICK_THROW("Unable to get image background color");
1091   }
1092   return createImagickPixel(pixel->releaseWand());
1093 }
1094
1095 static String HHVM_METHOD(Imagick, getImageBlob) {
1096   auto wand = getMagickWandResource(Object{this_});
1097   ensureImageHasFormat(wand->getWand());
1098   size_t size;
1099   auto data = MagickGetImageBlob(wand->getWand(), &size);
1100   return convertMagickData(size, data);
1101 }
1102
1103 static Array HHVM_METHOD(Imagick, getImageBluePrimary) {
1104   auto wand = getMagickWandResource(Object{this_});
1105   double x, y;
1106   auto status = MagickGetImageBluePrimary(wand->getWand(), &x, &y);
1107   if (status == MagickFalse) {
1108     IMAGICK_THROW("Unable to get image blue primary");
1109   }
1110   return make_map_array(s_x, x, s_y, y);
1111 }
1112
1113 static Object HHVM_METHOD(Imagick, getImageBorderColor) {
1114   auto wand = getMagickWandResource(Object{this_});
1115   auto pixel = newPixelWand();
1116   auto status = MagickGetImageBorderColor(wand->getWand(), pixel->getWand());
1117   if (pixel->getWand() == nullptr || status == MagickFalse) {
1118     IMAGICK_THROW("Unable to get image border color");
1119   }
1120   return createImagickPixel(pixel->releaseWand());
1121 }
1122
1123 static int64_t HHVM_METHOD(Imagick, getImageChannelDepth, int64_t channel) {
1124   auto wand = getMagickWandResource(Object{this_});
1125   return MagickGetImageChannelDepth(wand->getWand(), (ChannelType)channel);
1126 }
1127
1128 static double HHVM_METHOD(Imagick, getImageChannelDistortion,
1129     const Object& reference, int64_t channel, int64_t metric) {
1130   auto wand = getMagickWandResource(Object{this_});
1131   auto wand2 = getMagickWandResource(reference);
1132   double distortion;
1133   auto status = MagickGetImageChannelDistortion(
1134     wand->getWand(), wand2->getWand(),
1135     (ChannelType)channel, (MetricType)metric, &distortion);
1136   if (status == MagickFalse) {
1137     IMAGICK_THROW("Unable to get image channel distortion");
1138   }
1139   return distortion;
1140 }
1141
1142 static double HHVM_METHOD(Imagick, getImageChannelDistortions,
1143     const Object& reference, int64_t metric, int64_t channel) {
1144   auto wand = getMagickWandResource(Object{this_});
1145   auto wand2 = getMagickWandResource(reference);
1146   double distortion;
1147   auto status = MagickGetImageChannelDistortion(
1148     wand->getWand(), wand2->getWand(),
1149     (ChannelType)channel, (MetricType)metric, &distortion);
1150   if (status == MagickFalse) {
1151     IMAGICK_THROW("Unable to get image channel distortion metrics");
1152   }
1153   return distortion;
1154 }
1155
1156 static Array HHVM_METHOD(Imagick, getImageChannelExtrema, int64_t channel) {
1157   raiseDeprecated(s_Imagick.c_str(), "getImageChannelExtrema");
1158
1159   auto wand = getMagickWandResource(Object{this_});
1160   size_t minima, maxima;
1161 #pragma GCC diagnostic push
1162 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1163   auto status = MagickGetImageChannelExtrema(
1164     wand->getWand(), (ChannelType)channel, &minima, &maxima);
1165 #pragma GCC diagnostic pop
1166   if (status == MagickFalse) {
1167     IMAGICK_THROW("Unable to get image channel extrema");
1168   }
1169   return make_map_array(
1170     s_minima, (int64_t)minima,
1171     s_maxima, (int64_t)maxima);
1172 }
1173
1174 static Array HHVM_METHOD(Imagick, getImageChannelKurtosis, int64_t channel) {
1175   auto wand = getMagickWandResource(Object{this_});
1176   double kurtosis, skewness;
1177   auto status = MagickGetImageChannelKurtosis(
1178     wand->getWand(), (ChannelType)channel, &kurtosis, &skewness);
1179   if (status == MagickFalse) {
1180     IMAGICK_THROW("Unable to get image channel kurtosis");
1181   }
1182   return make_map_array(
1183     s_kurtosis, kurtosis,
1184     s_skewness, skewness);
1185 }
1186
1187 static Array HHVM_METHOD(Imagick, getImageChannelMean, int64_t channel) {
1188   auto wand = getMagickWandResource(Object{this_});
1189   double mean, standardDeviation;
1190   auto status = MagickGetImageChannelMean(
1191     wand->getWand(), (ChannelType)channel, &mean, &standardDeviation);
1192   if (status == MagickFalse) {
1193     IMAGICK_THROW("Unable to get image channel mean");
1194   }
1195   return make_map_array(
1196     s_mean, mean,
1197     s_standardDeviation, standardDeviation);
1198 }
1199
1200 static Array HHVM_METHOD(Imagick, getImageChannelRange, int64_t channel) {
1201   auto wand = getMagickWandResource(Object{this_});
1202   double minima, maxima;
1203   auto status = MagickGetImageChannelRange(
1204     wand->getWand(), (ChannelType)channel, &minima, &maxima);
1205   if (status == MagickFalse) {
1206     IMAGICK_THROW("Unable to get channel range");
1207   }
1208   return make_map_array(
1209     s_minima, minima,
1210     s_maxima, maxima);
1211 }
1212
1213 static Array HHVM_METHOD(Imagick, getImageChannelStatistics) {
1214   static const int channels[] = {
1215     UndefinedChannel, RedChannel, CyanChannel, GreenChannel, MagentaChannel,
1216     BlueChannel, YellowChannel, OpacityChannel, BlackChannel, MatteChannel
1217   };
1218   auto wand = getMagickWandResource(Object{this_});
1219   auto stat = MagickGetImageChannelStatistics(wand->getWand());
1220
1221   ArrayInit ret(sizeof(channels) / sizeof(channels[0]), ArrayInit::Mixed{});
1222   for (auto channel : channels) {
1223     ret.set(channel, make_map_array(
1224         s_mean, stat[channel].mean,
1225         s_minima, stat[channel].minima,
1226         s_maxima, stat[channel].maxima,
1227         s_standardDeviation, stat[channel].standard_deviation,
1228         s_depth, (int64_t)stat[channel].depth));
1229   }
1230   freeMagickMemory(stat);
1231   return ret.toArray();
1232 }
1233
1234 static Object HHVM_METHOD(Imagick, getImageClipMask) {
1235   auto wand = getMagickWandResource(Object{this_});
1236   auto magick = MagickGetImageClipMask(wand->getWand());
1237   if (magick == nullptr) {
1238     IMAGICK_THROW("Unable to get image clip mask");
1239   }
1240   return createImagick(magick);
1241 }
1242
1243 static Object HHVM_METHOD(Imagick, getImageColormapColor, int64_t index) {
1244   auto wand = getMagickWandResource(Object{this_});
1245   auto pixel = newPixelWand();
1246   auto status = MagickGetImageColormapColor(
1247     wand->getWand(), index , pixel->getWand());
1248   if (pixel->getWand() == nullptr || status == MagickFalse) {
1249     IMAGICK_THROW("Unable to get image colormap color");
1250   }
1251   return createImagickPixel(pixel->releaseWand());
1252 }
1253
1254 static int64_t HHVM_METHOD(Imagick, getImageColors) {
1255   auto wand = getMagickWandResource(Object{this_});
1256   return MagickGetImageColors(wand->getWand());
1257 }
1258
1259 static int64_t HHVM_METHOD(Imagick, getImageColorspace) {
1260   auto wand = getMagickWandResource(Object{this_});
1261   return MagickGetImageColorspace(wand->getWand());
1262 }
1263
1264 static int64_t HHVM_METHOD(Imagick, getImageCompose) {
1265   auto wand = getMagickWandResource(Object{this_});
1266   return MagickGetImageCompose(wand->getWand());
1267 }
1268
1269 static int64_t HHVM_METHOD(Imagick, getImageCompression) {
1270   auto wand = getMagickWandResource(Object{this_});
1271   return MagickGetImageCompression(wand->getWand());
1272 }
1273
1274 static int64_t HHVM_METHOD(Imagick, getImageDelay) {
1275   auto wand = getMagickWandResource(Object{this_});
1276   return MagickGetImageDelay(wand->getWand());
1277 }
1278
1279 static int64_t HHVM_METHOD(Imagick, getImageDepth) {
1280   auto wand = getMagickWandResource(Object{this_});
1281   return MagickGetImageDepth(wand->getWand());
1282 }
1283
1284 static int64_t HHVM_METHOD(Imagick, getImageDispose) {
1285   auto wand = getMagickWandResource(Object{this_});
1286   return MagickGetImageDispose(wand->getWand());
1287 }
1288
1289 static double HHVM_METHOD(Imagick, getImageDistortion,
1290     const Object& reference, int64_t metric) {
1291   auto wand = getMagickWandResource(Object{this_});
1292   auto wand2 = getMagickWandResource(reference);
1293   double distortion;
1294   auto status = MagickGetImageDistortion(
1295     wand->getWand(), wand2->getWand(), (MetricType)metric, &distortion);
1296   if (status == MagickFalse) {
1297     IMAGICK_THROW("Unable to get image distortion");
1298   }
1299   return distortion;
1300 }
1301
1302 static Array HHVM_METHOD(Imagick, getImageExtrema) {
1303   raiseDeprecated(s_Imagick.c_str(), "getImageExtrema");
1304
1305   auto wand = getMagickWandResource(Object{this_});
1306   size_t min, max;
1307 #pragma GCC diagnostic push
1308 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1309   auto status = MagickGetImageExtrema(wand->getWand(), &min, &max);
1310 #pragma GCC diagnostic pop
1311   if (status == MagickFalse) {
1312     IMAGICK_THROW("Unable to get image extrema");
1313   }
1314   return make_map_array(
1315     s_min, (int64_t)min,
1316     s_max, (int64_t)max);
1317 }
1318
1319 static String HHVM_METHOD(Imagick, getImageFilename) {
1320   auto wand = getMagickWandResource(Object{this_});
1321   return convertMagickString(MagickGetImageFilename(wand->getWand()));
1322 }
1323
1324 static String HHVM_METHOD(Imagick, getImageFormat) {
1325   auto wand = getMagickWandResource(Object{this_});
1326   ensureImageHasFormat(wand->getWand());
1327   return convertMagickString(MagickGetImageFormat(wand->getWand()));
1328 }
1329
1330 static double HHVM_METHOD(Imagick, getImageGamma) {
1331   auto wand = getMagickWandResource(Object{this_});
1332   return MagickGetImageGamma(wand->getWand());
1333 }
1334
1335 static Array HHVM_METHOD(Imagick, getImageGeometry) {
1336   auto wand = getMagickWandResource(Object{this_});
1337   return ImageGeometry(wand->getWand()).toArray();
1338 }
1339
1340 static int64_t HHVM_METHOD(Imagick, getImageGravity) {
1341   auto wand = getMagickWandResource(Object{this_});
1342   return MagickGetImageGravity(wand->getWand());
1343 }
1344
1345 static Array HHVM_METHOD(Imagick, getImageGreenPrimary) {
1346   auto wand = getMagickWandResource(Object{this_});
1347   double x, y;
1348   auto status = MagickGetImageGreenPrimary(wand->getWand(), &x, &y);
1349   if (status == MagickFalse) {
1350     IMAGICK_THROW("Unable to get image green primary");
1351   }
1352   return make_map_array(s_x, x, s_y, y);
1353 }
1354
1355 static int64_t HHVM_METHOD(Imagick, getImageHeight) {
1356   auto wand = getMagickWandResource(Object{this_});
1357   return MagickGetImageHeight(wand->getWand());
1358 }
1359
1360 static Array HHVM_METHOD(Imagick, getImageHistogram) {
1361   auto wand = getMagickWandResource(Object{this_});
1362   size_t colors;
1363   auto hist = MagickGetImageHistogram(wand->getWand(), &colors);
1364   auto ret = createImagickPixelArray(colors, hist);
1365   freeMagickMemory(hist);
1366   return ret;
1367 }
1368
1369 static int64_t HHVM_METHOD(Imagick, getImageIndex) {
1370   raiseDeprecated(s_Imagick.c_str(), "getImageindex");
1371
1372   auto wand = getMagickWandResource(Object{this_});
1373 #pragma GCC diagnostic push
1374 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1375   return MagickGetImageIndex(wand->getWand());
1376 #pragma GCC diagnostic pop
1377 }
1378
1379 static int64_t HHVM_METHOD(Imagick, getImageInterlaceScheme) {
1380   raiseDeprecated(s_Imagick.c_str(), "getImageInterlaceScheme");
1381
1382   auto wand = getMagickWandResource(Object{this_});
1383   return MagickGetImageInterlaceScheme(wand->getWand());
1384 }
1385
1386 static int64_t HHVM_METHOD(Imagick, getImageInterpolateMethod) {
1387   auto wand = getMagickWandResource(Object{this_});
1388   return MagickGetImageInterpolateMethod(wand->getWand());
1389 }
1390
1391 static int64_t HHVM_METHOD(Imagick, getImageIterations) {
1392   auto wand = getMagickWandResource(Object{this_});
1393   return MagickGetImageIterations(wand->getWand());
1394 }
1395
1396 static int64_t HHVM_METHOD(Imagick, getImageLength) {
1397   auto wand = getMagickWandResource(Object{this_});
1398   MagickSizeType length;
1399   auto status = MagickGetImageLength(wand->getWand(), &length);
1400   if (status == MagickFalse) {
1401     IMAGICK_THROW("Unable to acquire image length");
1402   }
1403   return length;
1404 }
1405
1406 static bool HHVM_METHOD(Imagick, getImageMatte) {
1407   raiseDeprecated(s_Imagick.c_str(), "getImageMatte");
1408
1409   auto wand = getMagickWandResource(Object{this_});
1410 #pragma GCC diagnostic push
1411 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1412   return MagickGetImageMatte(wand->getWand()) == MagickTrue;
1413 #pragma GCC diagnostic pop
1414 }
1415
1416 static Object HHVM_METHOD(Imagick, getImageMatteColor) {
1417   auto wand = getMagickWandResource(Object{this_});
1418   auto pixel = newPixelWand();
1419   auto status = MagickGetImageMatteColor(wand->getWand(), pixel->getWand());
1420   if (pixel->getWand() == nullptr || status == MagickFalse) {
1421     IMAGICK_THROW("Unable to get image matte color");
1422   }
1423   return createImagickPixel(pixel->releaseWand());
1424 }
1425
1426 static String HHVM_METHOD(Imagick, getImageMimeType) {
1427   auto wand = getMagickWandResource(Object{this_});
1428   return getImageMimeType(wand->getWand());
1429 }
1430
1431 static int64_t HHVM_METHOD(Imagick, getImageOrientation) {
1432   auto wand = getMagickWandResource(Object{this_});
1433   return MagickGetImageOrientation(wand->getWand());
1434 }
1435
1436 static Array HHVM_METHOD(Imagick, getImagePage) {
1437   auto wand = getMagickWandResource(Object{this_});
1438   size_t width, height;
1439   ssize_t x, y;
1440   auto status = MagickGetImagePage(wand->getWand(), &width, &height, &x, &y);
1441   if (status == MagickFalse) {
1442     IMAGICK_THROW("Unable to get image page");
1443   }
1444   return make_map_array(
1445     s_width, (int64_t)width,
1446     s_height, (int64_t)height,
1447     s_x, (int64_t)x,
1448     s_y, (int64_t)y);
1449 }
1450
1451 static Object HHVM_METHOD(Imagick, getImagePixelColor,
1452     int64_t x, int64_t y) {
1453   auto wand = getMagickWandResource(Object{this_});
1454   auto pixel = newPixelWand();
1455   auto status = MagickGetImagePixelColor(
1456     wand->getWand(), x, y , pixel->getWand());
1457   if (pixel->getWand() == nullptr || status == MagickFalse) {
1458     IMAGICK_THROW("Unable get image pixel color");
1459   }
1460   return createImagickPixel(pixel->releaseWand());
1461 }
1462
1463 ALWAYS_INLINE
1464 static String magickGetImageProfile(MagickWand* wand, const char* name) {
1465   size_t length;
1466   auto profile = MagickGetImageProfile(wand, name, &length);
1467   if (profile == nullptr) {
1468     IMAGICK_THROW("Can not get image profile");
1469   } else {
1470     return convertMagickData(length, profile);
1471   }
1472 }
1473
1474 static String HHVM_METHOD(Imagick, getImageProfile, const String& name) {
1475   auto wand = getMagickWandResource(Object{this_});
1476   return magickGetImageProfile(wand->getWand(), name.c_str());
1477 }
1478
1479 static Array HHVM_METHOD(Imagick, getImageProfiles,
1480     const String& pattern, bool with_values) {
1481   auto wand = getMagickWandResource(Object{this_});
1482   size_t count;
1483   auto profiles = MagickGetImageProfiles(
1484     wand->getWand(), pattern.c_str(), &count);
1485   if (profiles == nullptr) {
1486     IMAGICK_THROW("Unable to get image profiles");
1487   }
1488
1489   if (with_values) {
1490     ArrayInit ret(count, ArrayInit::Map{});
1491     for (size_t i = 0; i < count; ++i) {
1492       ret.setUnknownKey(
1493         String(profiles[i]),
1494         magickGetImageProfile(wand->getWand(), profiles[i]));
1495     }
1496     freeMagickMemory(profiles);
1497     return ret.toArray();
1498   } else {
1499     return convertMagickArray(count, profiles);
1500   }
1501 }
1502
1503 ALWAYS_INLINE
1504 static String magickGetImageProperty(MagickWand* wand, const char* name) {
1505   return convertMagickString(MagickGetImageProperty(wand, name));
1506 }
1507
1508 static Array HHVM_METHOD(Imagick, getImageProperties,
1509     const String& pattern, bool with_values) {
1510   auto wand = getMagickWandResource(Object{this_});
1511   size_t count;
1512   auto properties = MagickGetImageProperties(
1513     wand->getWand(), pattern.c_str(), &count);
1514   if (properties == nullptr) {
1515     IMAGICK_THROW("Unable to get image properties");
1516   }
1517
1518   if (with_values) {
1519     ArrayInit ret(count, ArrayInit::Map{});
1520     for (size_t i = 0; i < count; ++i) {
1521       ret.setUnknownKey(
1522         String(properties[i]),
1523         magickGetImageProperty(wand->getWand(), properties[i]));
1524     }
1525     freeMagickMemory(properties);
1526     return ret.toArray();
1527   } else {
1528     return convertMagickArray(count, properties);
1529   }
1530 }
1531
1532 static String HHVM_METHOD(Imagick, getImageProperty, const String& name) {
1533   auto wand = getMagickWandResource(Object{this_});
1534   return magickGetImageProperty(wand->getWand(), name.c_str());
1535 }
1536
1537 static Array HHVM_METHOD(Imagick, getImageRedPrimary) {
1538   auto wand = getMagickWandResource(Object{this_});
1539   double x, y;
1540   auto status = MagickGetImageRedPrimary(wand->getWand(), &x, &y);
1541   if (status == MagickFalse) {
1542     IMAGICK_THROW("Unable to get image red primary");
1543   }
1544   return make_map_array(s_x, x, s_y, y);
1545 }
1546
1547 static Object HHVM_METHOD(Imagick, getImageRegion,
1548     int64_t width, int64_t height, int64_t x, int64_t y) {
1549   auto wand = getMagickWandResource(Object{this_});
1550   auto magick = MagickGetImageRegion(wand->getWand(), width, height, x, y);
1551   if (magick == nullptr) {
1552     IMAGICK_THROW("Get image region failed");
1553   }
1554   return createImagick(magick);
1555 }
1556
1557 static int64_t HHVM_METHOD(Imagick, getImageRenderingIntent) {
1558   auto wand = getMagickWandResource(Object{this_});
1559   return MagickGetImageRenderingIntent(wand->getWand());
1560 }
1561
1562 static Array HHVM_METHOD(Imagick, getImageResolution) {
1563   auto wand = getMagickWandResource(Object{this_});
1564   double x, y;
1565   auto status = MagickGetImageResolution(wand->getWand(), &x, &y);
1566   if (status == MagickFalse) {
1567     IMAGICK_THROW("Unable to get image resolution");
1568   }
1569   return make_map_array(s_x, x, s_y, y);
1570 }
1571
1572 static String HHVM_METHOD(Imagick, getImagesBlob) {
1573   auto wand = getMagickWandResource(Object{this_});
1574   int current = MagickGetIteratorIndex(wand->getWand());
1575   MagickResetIterator(wand->getWand());
1576   while (MagickNextImage(wand->getWand()) != MagickFalse) {
1577     ensureImageHasFormat(wand->getWand());
1578   }
1579   auto status = MagickSetIteratorIndex(wand->getWand(), current);
1580   if (status == MagickFalse) {
1581     IMAGICK_THROW("Unable to set the iterator index");
1582   }
1583   size_t size;
1584   auto data = MagickGetImagesBlob(wand->getWand(), &size);
1585   return convertMagickData(size, data);
1586 }
1587
1588 static int64_t HHVM_METHOD(Imagick, getImageScene) {
1589   auto wand = getMagickWandResource(Object{this_});
1590   return MagickGetImageScene(wand->getWand());
1591 }
1592
1593 static String HHVM_METHOD(Imagick, getImageSignature) {
1594   auto wand = getMagickWandResource(Object{this_});
1595   return MagickGetImageSignature(wand->getWand());
1596 }
1597
1598 static int64_t HHVM_METHOD(Imagick, getImageSize) {
1599   raiseDeprecated(s_Imagick.c_str(), "getImageSize",
1600                   s_Imagick.c_str(), "getImageLength");
1601
1602   auto wand = getMagickWandResource(Object{this_});
1603 #pragma GCC diagnostic push
1604 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1605   return MagickGetImageSize(wand->getWand());
1606 #pragma GCC diagnostic pop
1607 }
1608
1609 static int64_t HHVM_METHOD(Imagick, getImageTicksPerSecond) {
1610   auto wand = getMagickWandResource(Object{this_});
1611   return MagickGetImageTicksPerSecond(wand->getWand());
1612 }
1613
1614 static double HHVM_METHOD(Imagick, getImageTotalInkDensity) {
1615   auto wand = getMagickWandResource(Object{this_});
1616   return MagickGetImageTotalInkDensity(wand->getWand());
1617 }
1618
1619 static int64_t HHVM_METHOD(Imagick, getImageType) {
1620   auto wand = getMagickWandResource(Object{this_});
1621   return MagickGetImageType(wand->getWand());
1622 }
1623
1624 static int64_t HHVM_METHOD(Imagick, getImageUnits) {
1625   auto wand = getMagickWandResource(Object{this_});
1626   return MagickGetImageUnits(wand->getWand());
1627 }
1628
1629 static int64_t HHVM_METHOD(Imagick, getImageVirtualPixelMethod) {
1630   auto wand = getMagickWandResource(Object{this_});
1631   return MagickGetImageVirtualPixelMethod(wand->getWand());
1632 }
1633
1634 static Array HHVM_METHOD(Imagick, getImageWhitePoint) {
1635   auto wand = getMagickWandResource(Object{this_});
1636   double x, y;
1637   auto status = MagickGetImageWhitePoint(wand->getWand(), &x, &y);
1638   if (status == MagickFalse) {
1639     IMAGICK_THROW("Unable to get image white point");
1640   }
1641   return make_map_array(s_x, x, s_y, y);
1642 }
1643
1644 static int64_t HHVM_METHOD(Imagick, getImageWidth) {
1645   auto wand = getMagickWandResource(Object{this_});
1646   return MagickGetImageWidth(wand->getWand());
1647 }
1648
1649 static int64_t HHVM_METHOD(Imagick, getInterlaceScheme) {
1650   auto wand = getMagickWandResource(Object{this_});
1651   return MagickGetInterlaceScheme(wand->getWand());
1652 }
1653
1654 static int64_t HHVM_METHOD(Imagick, getIteratorIndex) {
1655   auto wand = getMagickWandResource(Object{this_});
1656   return MagickGetIteratorIndex(wand->getWand());
1657 }
1658
1659 static int64_t HHVM_METHOD(Imagick, getNumberImages) {
1660   auto wand = getMagickWandResource(Object{this_});
1661   return MagickGetNumberImages(wand->getWand());
1662 }
1663
1664 static String HHVM_METHOD(Imagick, getOption, const String& key) {
1665   auto wand = getMagickWandResource(Object{this_});
1666   return convertMagickString(MagickGetOption(wand->getWand(), key.c_str()));
1667 }
1668
1669 static String HHVM_STATIC_METHOD(Imagick, getPackageName) {
1670   return MagickGetPackageName();
1671 }
1672
1673 static Array HHVM_METHOD(Imagick, getPage) {
1674   auto wand = getMagickWandResource(Object{this_});
1675   size_t width, height;
1676   ssize_t x, y;
1677   auto status = MagickGetPage(wand->getWand(), &width, &height, &x, &y);
1678   if (status == MagickFalse) {
1679     IMAGICK_THROW("Unable to get page");
1680   }
1681   return make_map_array(
1682     s_width, (int64_t)width,
1683     s_height, (int64_t)height,
1684     s_x, (int64_t)x,
1685     s_y, (int64_t)y);
1686 }
1687
1688 static Object HHVM_METHOD(Imagick, getPixelIterator) {
1689   return createPixelIterator(Object{this_});
1690 }
1691
1692 static Object HHVM_METHOD(Imagick, getPixelRegionIterator,
1693     int64_t x, int64_t y, int64_t columns, int64_t rows) {
1694   return createPixelRegionIterator(Object{this_}, x, y, columns, rows);
1695 }
1696
1697 static double HHVM_METHOD(Imagick, getPointSize) {
1698   auto wand = getMagickWandResource(Object{this_});
1699   return MagickGetPointsize(wand->getWand());
1700 }
1701
1702 static Array HHVM_STATIC_METHOD(Imagick, getQuantumDepth) {
1703   size_t depth;
1704   const char* quantumDepth = MagickGetQuantumDepth(&depth);
1705   return make_map_array(
1706     s_quantumDepthLong, (int64_t)depth,
1707     s_quantumDepthString, quantumDepth);
1708 }
1709
1710 static Array HHVM_STATIC_METHOD(Imagick, getQuantumRange) {
1711   size_t range;
1712   const char* quantumRange = MagickGetQuantumRange(&range);
1713   return make_map_array(
1714     s_quantumRangeLong, (int64_t)range,
1715     s_quantumRangeString, quantumRange);
1716 }
1717
1718 static String HHVM_STATIC_METHOD(Imagick, getReleaseDate) {
1719   return MagickGetReleaseDate();
1720 }
1721
1722 static int64_t HHVM_STATIC_METHOD(Imagick, getResource,
1723     int64_t resource_type) {
1724   return MagickGetResource((ResourceType)resource_type);
1725 }
1726
1727 static int64_t HHVM_STATIC_METHOD(Imagick, getResourceLimit,
1728     int64_t resource_type) {
1729   return MagickGetResourceLimit((ResourceType)resource_type);
1730 }
1731
1732 static Array HHVM_METHOD(Imagick, getSamplingFactors) {
1733   auto wand = getMagickWandResource(Object{this_});
1734   size_t num;
1735   auto arr = MagickGetSamplingFactors(wand->getWand(), &num);
1736   return convertMagickArray(num, arr);
1737 }
1738
1739 static Array HHVM_METHOD(Imagick, getSize) {
1740   auto wand = getMagickWandResource(Object{this_});
1741   size_t columns, rows;
1742   auto status = MagickGetSize(wand->getWand(), &columns, &rows);
1743   if (status == MagickFalse) {
1744     IMAGICK_THROW("Unable to get size");
1745   }
1746   return make_map_array(
1747     s_columns, (int64_t)columns,
1748     s_rows, (int64_t)rows);
1749 }
1750
1751 static int64_t HHVM_METHOD(Imagick, getSizeOffset) {
1752   auto wand = getMagickWandResource(Object{this_});
1753   ssize_t offset;
1754   auto status = MagickGetSizeOffset(wand->getWand(), &offset);
1755   if (status == MagickFalse) {
1756     IMAGICK_THROW("Unable to get size offset");
1757   }
1758   return offset;
1759 }
1760
1761 static Array HHVM_STATIC_METHOD(Imagick, getVersion) {
1762   size_t version;
1763   const char* versionStr = MagickGetVersion(&version);
1764   return make_map_array(
1765     s_versionNumber, (int64_t)version,
1766     s_versionString, versionStr);
1767 }
1768
1769 static bool HHVM_METHOD(Imagick, haldClutImage,
1770     const Object& clut, int64_t channel) {
1771   auto wand = getMagickWandResource(Object{this_});
1772   auto wand2 = getMagickWandResource(clut);
1773   auto status = MagickHaldClutImageChannel(
1774     wand->getWand(), (ChannelType)channel, wand2->getWand());
1775   if (status == MagickFalse) {
1776     IMAGICK_THROW("Unable to hald clut image");
1777   }
1778   return true;
1779 }
1780
1781 static bool HHVM_METHOD(Imagick, hasNextImage) {
1782   auto wand = getMagickWandResource(Object{this_});
1783   return MagickHasNextImage(wand->getWand()) != MagickFalse;
1784 }
1785
1786 static bool HHVM_METHOD(Imagick, hasPreviousImage) {
1787   auto wand = getMagickWandResource(Object{this_});
1788   return MagickHasPreviousImage(wand->getWand()) != MagickFalse;
1789 }
1790
1791 ALWAYS_INLINE
1792 static vector<pair<String, String>> parseIdentify(const String& identify) {
1793   using Keys = vector<pair<string, StaticString>>;
1794   static const Keys keys = {
1795     {"Format: ", s_format},
1796     {"Units: ", s_units},
1797     {"Type: ", s_type},
1798     {"Colorspace: ", s_colorSpace},
1799     {"Filesize: ", s_fileSize},
1800     {"Compression: ", s_compression}
1801   };
1802
1803   vector<pair<String, String>> ret;
1804   Array lines = HHVM_FN(explode)("\r\n", identify).toArray();
1805   ret.reserve(keys.size());
1806   for (ArrayIter it(lines); it; ++it) {
1807     String line = HHVM_FN(trim)(it.secondRefPlus().toString());
1808     auto key = std::find_if(keys.begin(), keys.end(),
1809         [=](Keys::const_reference i) {
1810           const string& prefix = i.first;
1811           return strncmp(line.c_str(), prefix.c_str(), prefix.length()) == 0;
1812         });
1813     if (key != keys.end()) {
1814       ret.push_back({key->second, line.substr(key->first.length())});
1815     }
1816   }
1817   return ret;
1818 }
1819
1820 static Array HHVM_METHOD(Imagick, identifyImage, bool appendRawOutput) {
1821   static const StaticString s_unknown("unknown");
1822   auto wand = getMagickWandResource(Object{this_});
1823   String identify = convertMagickString(MagickIdentifyImage(wand->getWand()));
1824   auto parsedIdentify = parseIdentify(identify);
1825   ArrayInit ret(parsedIdentify.size() + 6, ArrayInit::Map{});
1826
1827   ret.set(s_imageName,
1828     convertMagickString(MagickGetImageFilename(wand->getWand())));
1829
1830   String mimetype = HHVM_MN(Imagick, getImageMimeType)(this_);
1831   ret.set(s_mimetype, mimetype.empty() ? String(s_unknown) : mimetype);
1832
1833   for (const auto& i: parsedIdentify) {
1834     ret.setUnknownKey(i.first, i.second);
1835   }
1836
1837   ret.set(s_geometry, ImageGeometry(wand->getWand()).toArray());
1838
1839   double x, y;
1840   if (MagickGetImageResolution(wand->getWand(), &x, &y) == MagickTrue) {
1841     ret.set(s_resolution, make_map_array(s_x, x, s_y, y));
1842   }
1843
1844   ret.set(s_signature,
1845     convertMagickString(MagickGetImageSignature(wand->getWand())));
1846
1847   if (appendRawOutput) {
1848     ret.set(s_rawOutput, identify);
1849   }
1850
1851   return ret.toArray();
1852 }
1853
1854 static bool HHVM_METHOD(Imagick, implodeImage, double radius) {
1855   auto wand = getMagickWandResource(Object{this_});
1856   auto status = MagickImplodeImage(wand->getWand(), radius);
1857   if (status == MagickFalse) {
1858     IMAGICK_THROW("Unable to implode image");
1859   }
1860   return true;
1861 }
1862
1863 template<StorageType T>
1864 ALWAYS_INLINE
1865 static void importImagePixels(req::ptr<WandResource<MagickWand>> wand,
1866     int64_t x, int64_t y, int64_t width, int64_t height,
1867     const String& map, const vector<double>& array) {
1868   vector<typename StorageTypeCPPType<T>::T> data(array.begin(), array.end());
1869   auto status = MagickImportImagePixels(wand->getWand(),
1870     x, y, width, height, map.c_str(), T, data.data());
1871   if (status == MagickFalse) {
1872     IMAGICK_THROW("Unable to import image pixels");
1873   }
1874 }
1875
1876 static bool HHVM_METHOD(Imagick, importImagePixels,
1877                         int64_t x, int64_t y, int64_t width, int64_t height,
1878                         const String& map, int64_t storage_,
1879                         const Array& pixels) {
1880   auto wand = getMagickWandResource(Object{this_});
1881   ensurePageIsValid(x, y, width, height);
1882   ensureChannelMapIsValid(map);
1883   if (pixels.size() != width * height * map.size()) {
1884     IMAGICK_THROW("The array contains incorrect number of elements");
1885   }
1886   auto array = toDoubleArray(pixels);
1887   if (array.empty()) {
1888     IMAGICK_THROW("The array contains incorrect values");
1889   }
1890   auto storage = resolveStorageType((StorageType)storage_);
1891
1892   if (storage == CharPixel) {
1893     importImagePixels<CharPixel>(wand, x, y, width, height, map, array);
1894   } else if (storage == LongPixel) {
1895     importImagePixels<LongPixel>(wand, x, y, width, height, map, array);
1896   } else if (storage == DoublePixel) {
1897     importImagePixels<DoublePixel>(wand, x, y, width, height, map, array);
1898   } else {
1899     not_reached();
1900   }
1901   return true;
1902 }
1903
1904 static bool HHVM_METHOD(Imagick, labelImage, const String& label) {
1905   auto wand = getMagickWandResource(Object{this_});
1906   auto status = MagickLabelImage(wand->getWand(), label.c_str());
1907   if (status == MagickFalse) {
1908     IMAGICK_THROW("Unable to label image");
1909   }
1910   return true;
1911 }
1912
1913 static bool HHVM_METHOD(Imagick, levelImage,
1914     double blackPoint, double gamma, double whitePoint, int64_t channel) {
1915   auto wand = getMagickWandResource(Object{this_});
1916   auto status = MagickLevelImageChannel(
1917     wand->getWand(), (ChannelType)channel, blackPoint, gamma, whitePoint);
1918   if (status == MagickFalse) {
1919     IMAGICK_THROW("Unable to level image");
1920   }
1921   return true;
1922 }
1923
1924 static bool HHVM_METHOD(Imagick, linearStretchImage,
1925     double blackPoint, double whitePoint) {
1926   auto wand = getMagickWandResource(Object{this_});
1927   auto status = MagickLinearStretchImage(
1928     wand->getWand(), blackPoint, whitePoint);
1929   if (status == MagickFalse) {
1930     IMAGICK_THROW("Unable to linear strech image");
1931   }
1932   return true;
1933 }
1934
1935 static bool HHVM_METHOD(Imagick, liquidRescaleImage,
1936     int64_t width, int64_t height, double delta_x, double rigidity) {
1937   auto wand = getMagickWandResource(Object{this_});
1938   auto status = MagickLiquidRescaleImage(
1939     wand->getWand(), width, height, delta_x, rigidity);
1940   if (status == MagickFalse) {
1941     IMAGICK_THROW("Unable to liquid rescale image");
1942   }
1943   return true;
1944 }
1945
1946 static bool HHVM_METHOD(Imagick, magnifyImage) {
1947   auto wand = getMagickWandResource(Object{this_});
1948   auto status = MagickMagnifyImage(wand->getWand());
1949   if (status == MagickFalse) {
1950     IMAGICK_THROW("Unable to magnify image");
1951   }
1952   return true;
1953 }
1954
1955 static bool HHVM_METHOD(Imagick, mapImage, const Object& map, bool dither) {
1956   raiseDeprecated(s_Imagick.c_str(), "mapImage");
1957
1958   auto wand = getMagickWandResource(Object{this_});
1959   auto wand2 = getMagickWandResource(map);
1960 #pragma GCC diagnostic push
1961 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1962   auto status = MagickMapImage(
1963     wand->getWand(), wand2->getWand(), toMagickBool(dither));
1964 #pragma GCC diagnostic pop
1965   if (status == MagickFalse) {
1966     IMAGICK_THROW("Unable to map image");
1967   }
1968   return true;
1969 }
1970
1971 static bool HHVM_METHOD(Imagick, matteFloodfillImage,
1972     double alpha, double fuzz, const Variant& bordercolor,
1973     int64_t x, int64_t y) {
1974   raiseDeprecated(s_Imagick.c_str(), "matteFloodfillImage");
1975
1976   auto wand = getMagickWandResource(Object{this_});
1977   auto pixel = buildColorWand(bordercolor);
1978 #pragma GCC diagnostic push
1979 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1980   auto status = MagickMatteFloodfillImage(
1981     wand->getWand(), alpha, fuzz, pixel->getWand(), x, y);
1982 #pragma GCC diagnostic pop
1983   if (status == MagickFalse) {
1984     IMAGICK_THROW("Unable to matte floodfill image");
1985   }
1986   return true;
1987 }
1988
1989 static bool HHVM_METHOD(Imagick, medianFilterImage, double radius) {
1990   raiseDeprecated(s_Imagick.c_str(), "medianFilterImage");
1991
1992   auto wand = getMagickWandResource(Object{this_});
1993 #pragma GCC diagnostic push
1994 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1995   auto status = MagickMedianFilterImage(wand->getWand(), radius);
1996 #pragma GCC diagnostic pop
1997   if (status == MagickFalse) {
1998     IMAGICK_THROW("Unable to median filter image");
1999   }
2000   return true;
2001 }
2002
2003 static Object HHVM_METHOD(Imagick, mergeImageLayers, int64_t layer_method) {
2004   auto wand = getMagickWandResource(Object{this_});
2005   MagickSetFirstIterator(wand->getWand());
2006   auto magick = MagickMergeImageLayers(
2007     wand->getWand(), (ImageLayerMethod)layer_method);
2008   if (magick == nullptr) {
2009     IMAGICK_THROW("Unable to merge image layers");
2010   }
2011   return createImagick(magick);
2012 }
2013
2014 static bool HHVM_METHOD(Imagick, minifyImage) {
2015   auto wand = getMagickWandResource(Object{this_});
2016   auto status = MagickMinifyImage(wand->getWand());
2017   if (status == MagickFalse) {
2018     IMAGICK_THROW("Unable to minify image");
2019   }
2020   return true;
2021 }
2022
2023 static bool HHVM_METHOD(Imagick, modulateImage,
2024     double brightness, double saturation, double hue) {
2025   auto wand = getMagickWandResource(Object{this_});
2026   auto status = MagickModulateImage(
2027     wand->getWand(), brightness, saturation, hue);
2028   if (status == MagickFalse) {
2029     IMAGICK_THROW("Unable to modulate image");
2030   }
2031   return true;
2032 }
2033
2034 static Object HHVM_METHOD(Imagick, montageImage, const Object& draw,
2035     const String& tile_geometry, const String& thumbnail_geometry,
2036     int64_t montage_mode, const String& frame) {
2037   auto wand = getMagickWandResource(Object{this_});
2038   auto drawing = getDrawingWandResource(draw);
2039   auto magick = MagickMontageImage(
2040     wand->getWand(), drawing->getWand(),
2041     tile_geometry.c_str(), thumbnail_geometry.c_str(),
2042     (MontageMode)montage_mode, frame.c_str());
2043   if (magick == nullptr) {
2044     IMAGICK_THROW("Montage image failed");
2045   }
2046   return createImagick(magick);
2047 }
2048
2049 static Object HHVM_METHOD(Imagick, morphImages, int64_t number_frames) {
2050   auto wand = getMagickWandResource(Object{this_});
2051   auto magick = MagickMorphImages(wand->getWand(), number_frames);
2052   if (magick == nullptr) {
2053     IMAGICK_THROW("Morphing images failed");
2054   }
2055   return createImagick(magick);
2056 }
2057
2058 static Object HHVM_METHOD(Imagick, mosaicImages) {
2059   raiseDeprecated(s_Imagick.c_str(), "mosaicImages");
2060
2061   auto wand = getMagickWandResource(Object{this_});
2062   MagickSetFirstIterator(wand->getWand());
2063 #pragma GCC diagnostic push
2064 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
2065   auto magick = MagickMosaicImages(wand->getWand());
2066 #pragma GCC diagnostic pop
2067   if (magick == nullptr) {
2068     IMAGICK_THROW("Mosaic image failed");
2069   }
2070   return createImagick(magick);
2071 }
2072
2073 static bool HHVM_METHOD(Imagick, motionBlurImage,
2074     double radius, double sigma, double angle, int64_t channel) {
2075   auto wand = getMagickWandResource(Object{this_});
2076   auto status = MagickMotionBlurImageChannel(
2077     wand->getWand(), (ChannelType)channel, radius, sigma, angle);
2078   if (status == MagickFalse) {
2079     IMAGICK_THROW("Unable to motion blur image");
2080   }
2081   return true;
2082 }
2083
2084 static bool HHVM_METHOD(Imagick, negateImage, bool gray, int64_t channel) {
2085   auto wand = getMagickWandResource(Object{this_});
2086   auto status = MagickNegateImageChannel(
2087     wand->getWand(), (ChannelType)channel, toMagickBool(gray));
2088   if (status == MagickFalse) {
2089     IMAGICK_THROW("Unable to negate image");
2090   }
2091   return true;
2092 }
2093
2094 static bool HHVM_METHOD(Imagick, newImage,
2095     int64_t cols, int64_t rows, const Variant& background,
2096     const String& format) {
2097   auto wand = getMagickWandResource(Object{this_});
2098   auto pixel = buildColorWand(background);
2099   auto status = MagickNewImage(wand->getWand(), cols, rows, pixel->getWand());
2100   if (status == MagickFalse) {
2101     IMAGICK_THROW("Unable to create new image");
2102   }
2103
2104   if (!format.empty()) {
2105     auto status = MagickSetImageFormat(wand->getWand(), format.c_str());
2106     if (status == MagickFalse) {
2107       IMAGICK_THROW("Unable to set the image format");
2108     }
2109   }
2110
2111   return true;
2112 }
2113
2114 static bool HHVM_METHOD(Imagick, newPseudoImage,
2115     int64_t columns, int64_t rows, const String& pseudoString) {
2116   auto wand = getMagickWandResource(Object{this_});
2117   if (!isMagickPseudoFormat(pseudoString)) {
2118     IMAGICK_THROW("Invalid pseudo format string");
2119   }
2120   auto status = MagickSetSize(wand->getWand(), columns, rows);
2121   if (status == MagickFalse) {
2122     IMAGICK_THROW("Unable to create new pseudo image");
2123   }
2124   imagickReadOp(wand->getWand(), pseudoString, MagickReadImage);
2125   return true;
2126 }
2127
2128 static bool HHVM_METHOD(Imagick, nextImage) {
2129   auto wand = getMagickWandResource(Object{this_});
2130   auto status = MagickNextImage(wand->getWand());
2131   setImagePending(Object{this_}, status == MagickFalse);
2132   return status != MagickFalse;
2133 }
2134
2135 static bool HHVM_METHOD(Imagick, normalizeImage, int64_t channel) {
2136   auto wand = getMagickWandResource(Object{this_});
2137   auto status = MagickNormalizeImageChannel(
2138     wand->getWand(), (ChannelType)channel);
2139   if (status == MagickFalse) {
2140     IMAGICK_THROW("Unable to normalize image");
2141   }
2142   return true;
2143 }
2144
2145 static bool HHVM_METHOD(Imagick, oilPaintImage, double radius) {
2146   auto wand = getMagickWandResource(Object{this_});
2147   auto status = MagickOilPaintImage(wand->getWand(), radius);
2148   if (status == MagickFalse) {
2149     IMAGICK_THROW("Unable to oilpaint image");
2150   }
2151   return true;
2152 }
2153
2154 static bool HHVM_METHOD(Imagick, opaquePaintImage,
2155     const Variant& target, const Variant& fill,
2156     double fuzz, bool invert, int64_t channel) {
2157   auto wand = getMagickWandResource(Object{this_});
2158   auto fillPixel = buildColorWand(fill);
2159   auto targetPixel = buildColorWand(target);
2160   auto status = MagickOpaquePaintImageChannel(
2161     wand->getWand(), (ChannelType)channel, fillPixel->getWand(),
2162     targetPixel->getWand(), fuzz, toMagickBool(invert));
2163   if (status == MagickFalse) {
2164     IMAGICK_THROW("Unable to opaque paint image");
2165   }
2166   return true;
2167 }
2168
2169 static Object HHVM_METHOD(Imagick, optimizeImageLayers) {
2170   auto wand = getMagickWandResource(Object{this_});
2171   auto magick = MagickOptimizeImageLayers(wand->getWand());
2172   if (magick == nullptr) {
2173     IMAGICK_THROW("Optimize image layers failed");
2174   }
2175   return createImagick(magick);
2176 }
2177
2178 static bool HHVM_METHOD(Imagick, orderedPosterizeImage,
2179     const String& threshold_map, int64_t channel) {
2180   auto wand = getMagickWandResource(Object{this_});
2181   auto status = MagickOrderedPosterizeImageChannel(
2182     wand->getWand(), (ChannelType)channel, threshold_map.c_str());
2183   if (status == MagickFalse) {
2184     IMAGICK_THROW("Unable to posterize image");
2185   }
2186   return true;
2187 }
2188
2189 static bool HHVM_METHOD(Imagick, paintFloodfillImage,
2190                         const Variant& fill, double fuzz,
2191                         const Variant& bordercolor,
2192                         int64_t x, int64_t y, int64_t channel) {
2193   raiseDeprecated(s_Imagick.c_str(), "paintFloodfillImage");
2194   auto wand = getMagickWandResource(Object{this_});
2195   auto fillPixel = buildColorWand(fill);
2196   auto borderPixel = bordercolor.isNull()
2197                    ? req::make<WandResource<PixelWand>>(nullptr)
2198                    : buildColorWand(bordercolor);
2199 #pragma GCC diagnostic push
2200 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
2201   auto status = MagickPaintFloodfillImage(
2202     wand->getWand(), (ChannelType)channel,
2203     fillPixel->getWand(), fuzz, borderPixel->getWand(), x, y);
2204 #pragma GCC diagnostic pop
2205   if (status == MagickFalse) {
2206     IMAGICK_THROW("Unable to paint floodfill image");
2207   }
2208   return true;
2209 }
2210
2211 static bool HHVM_METHOD(Imagick, paintOpaqueImage,
2212     const Variant& target, const Variant& fill,
2213     double fuzz, int64_t channel) {
2214   raiseDeprecated(s_Imagick.c_str(), "paintOpaqueImage");
2215
2216   auto wand = getMagickWandResource(Object{this_});
2217   auto fillPixel = buildColorWand(fill);
2218   auto targetPixel = buildColorWand(target);
2219 #pragma GCC diagnostic push
2220 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
2221   auto status = MagickPaintOpaqueImageChannel(
2222     wand->getWand(), (ChannelType)channel,
2223     targetPixel->getWand(), fillPixel->getWand(), fuzz);
2224 #pragma GCC diagnostic pop
2225   if (status == MagickFalse) {
2226     IMAGICK_THROW("Unable paint opaque image");
2227   }
2228   return true;
2229 }
2230
2231 static bool HHVM_METHOD(Imagick, paintTransparentImage,
2232     const Variant& target, double alpha, double fuzz) {
2233   raiseDeprecated(s_Imagick.c_str(), "paintTransparentImage");
2234
2235   auto wand = getMagickWandResource(Object{this_});
2236   auto pixel = buildColorWand(target);
2237 #pragma GCC diagnostic push
2238 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
2239   auto status = MagickPaintTransparentImage(
2240     wand->getWand(), pixel->getWand(), alpha, fuzz);
2241 #pragma GCC diagnostic pop
2242   if (status == MagickFalse) {
2243     IMAGICK_THROW("Unable to paint transparent image");
2244   }
2245   return true;
2246 }
2247
2248 static bool HHVM_METHOD(Imagick, pingImage, const String& filename) {
2249   auto wand = getMagickWandResource(Object{this_});
2250   imagickReadOp(wand->getWand(), filename, MagickPingImage);
2251   return true;
2252 }
2253
2254 static bool HHVM_METHOD(Imagick, pingImageBlob, const String& image) {
2255   auto wand = getMagickWandResource(Object{this_});
2256   if (image.empty()) {
2257     IMAGICK_THROW("Empty image string passed");
2258   }
2259   auto status = MagickPingImageBlob(
2260     wand->getWand(), image.c_str(), image.size());
2261   if (status == MagickFalse) {
2262     IMAGICK_THROW("Unable to ping image blob");
2263   }
2264   return true;
2265 }
2266
2267 static bool HHVM_METHOD(Imagick, pingImageFile,
2268     const Resource& filehandle, const String& fileName) {
2269   auto wand = getMagickWandResource(Object{this_});
2270   imagickReadOp(wand->getWand(), filehandle, MagickPingImageFile);
2271   return true;
2272 }
2273
2274 static bool HHVM_METHOD(Imagick, polaroidImage,
2275     const Object& properties, double angle) {
2276   auto wand = getMagickWandResource(Object{this_});
2277   auto drawing = getDrawingWandResource(properties);
2278   auto status = MagickPolaroidImage(
2279     wand->getWand(), drawing->getWand(), angle);
2280   if (status == MagickFalse) {
2281     IMAGICK_THROW("Unable to polaroid image");
2282   }
2283   return true;
2284 }
2285
2286 static bool HHVM_METHOD(Imagick, posterizeImage,
2287     int64_t levels, bool dither) {
2288   auto wand = getMagickWandResource(Object{this_});
2289   auto status = MagickPosterizeImage(
2290     wand->getWand(), levels, toMagickBool(dither));
2291   if (status == MagickFalse) {
2292     IMAGICK_THROW("Unable to posterize image");
2293   }
2294   return true;
2295 }
2296
2297 static Object HHVM_METHOD(Imagick, previewImages, int64_t preview) {
2298   auto wand = getMagickWandResource(Object{this_});
2299   auto magick = MagickPreviewImages(wand->getWand(), (PreviewType)preview);
2300   if (magick == nullptr) {
2301     IMAGICK_THROW("Preview images failed");
2302   }
2303   return createImagick(magick);
2304 }
2305
2306 static bool HHVM_METHOD(Imagick, previousImage) {
2307   auto wand = getMagickWandResource(Object{this_});
2308   auto status = MagickPreviousImage(wand->getWand());
2309   setImagePending(Object{this_}, false);
2310   return status != MagickFalse;
2311 }
2312
2313 static bool HHVM_METHOD(Imagick, profileImage,
2314     const String& name, const String& profile) {
2315   auto wand = getMagickWandResource(Object{this_});
2316   auto status = MagickProfileImage(
2317     wand->getWand(), name.c_str(), profile.c_str(), profile.length());
2318   if (status == MagickFalse) {
2319     IMAGICK_THROW("Unable to profile image");
2320   }
2321   return true;
2322 }
2323
2324 static bool HHVM_METHOD(Imagick, quantizeImage,
2325     int64_t numberColors, int64_t colorspace,
2326     int64_t treedepth, bool dither, bool measureError) {
2327   auto wand = getMagickWandResource(Object{this_});
2328   auto status = MagickQuantizeImage(
2329     wand->getWand(), numberColors, (ColorspaceType)colorspace, treedepth,
2330     toMagickBool(dither), toMagickBool(measureError));
2331   if (status == MagickFalse) {
2332     IMAGICK_THROW("Unable to quantize image");
2333   }
2334   return true;
2335 }
2336
2337 static bool HHVM_METHOD(Imagick, quantizeImages,
2338     int64_t numberColors, int64_t colorspace,
2339     int64_t treedepth, bool dither, bool measureError) {
2340   auto wand = getMagickWandResource(Object{this_});
2341   auto status = MagickQuantizeImages(
2342     wand->getWand(), numberColors, (ColorspaceType)colorspace, treedepth,
2343     toMagickBool(dither), toMagickBool(measureError));
2344   if (status == MagickFalse) {
2345     IMAGICK_THROW("Unable to quantize images");
2346   }
2347   return true;
2348 }
2349
2350 static Array HHVM_METHOD(Imagick, queryFontMetrics,
2351     const Object& properties, const String& text,
2352     const Variant& query_multiline) {
2353   auto wand = getMagickWandResource(Object{this_});
2354   auto drawing = getDrawingWandResource(properties);
2355
2356   // No parameter passed, this means we should autodetect
2357   bool multiline = query_multiline.isNull()
2358                  ? text.find('\n') != String::npos
2359                  : query_multiline.toBoolean();
2360
2361   // wand is empty, create a 1x1 pixel image to use as a temporary canvas
2362   bool removeCanvas;
2363   if (MagickGetNumberImages(wand->getWand()) < 1) {
2364     auto pixel = newPixelWand();
2365     if (pixel->getWand() == nullptr) {
2366       IMAGICK_THROW(
2367         "Unable to allocate background color for the temporary canvas");
2368     }
2369     auto status = MagickNewImage(wand->getWand(), 1, 1, pixel->getWand());
2370     if (status == MagickFalse) {
2371       IMAGICK_THROW("Unable to allocate temporary canvas");
2372     }
2373     removeCanvas = true;
2374   } else {
2375     removeCanvas = false;
2376   }
2377
2378   // Multiline testing
2379   double* metrics;
2380   if (multiline) {
2381     metrics = MagickQueryMultilineFontMetrics(
2382       wand->getWand(), drawing->getWand(), text.c_str());
2383   } else {
2384     metrics = MagickQueryFontMetrics(
2385       wand->getWand(), drawing->getWand(), text.c_str());
2386   }
2387
2388   // Remove the image from the stack
2389   if (removeCanvas) {
2390     MagickRemoveImage(wand->getWand());
2391   }
2392
2393   if (metrics == nullptr) {
2394     IMAGICK_THROW("Failed to query the font metrics");
2395   } else {
2396     static const StaticString keys[] = {
2397       s_characterWidth, s_characterHeight, s_ascender, s_descender,
2398       s_textWidth, s_textHeight, s_maxHorizontalAdvance,
2399       // s_x1, s_y1, s_x2, s_y2,
2400       s_boundingBox, empty_string_ref, empty_string_ref, empty_string_ref,
2401       s_originX, s_originY
2402     };
2403     static const size_t boundingBoxOffset = 7;
2404     static const size_t size = 13;
2405
2406     ArrayInit ret(size - 3, ArrayInit::Map{});
2407     for (size_t i = 0; i < size; ++i) {
2408       if (keys[i] == s_boundingBox) {
2409         ret.set(s_boundingBox, make_map_array(
2410                 s_x1, metrics[boundingBoxOffset + 0],
2411                 s_y1, metrics[boundingBoxOffset + 1],
2412                 s_x2, metrics[boundingBoxOffset + 2],
2413                 s_y2, metrics[boundingBoxOffset + 3]));
2414       } else if (!keys[i].empty()) {
2415         ret.set(keys[i], metrics[i]);
2416       }
2417     }
2418     freeMagickMemory(metrics);
2419     return ret.toArray();
2420   }
2421 }
2422
2423 static Array HHVM_STATIC_METHOD(Imagick, queryFonts,
2424     const String& pattern) {
2425   return magickQueryFonts(pattern.c_str());
2426 }
2427
2428 static Array HHVM_STATIC_METHOD(Imagick, queryFormats,
2429     const String& pattern) {
2430   return magickQueryFormats(pattern.c_str());
2431 }
2432
2433 static bool HHVM_METHOD(Imagick, radialBlurImage,
2434     double angle, int64_t channel) {
2435   auto wand = getMagickWandResource(Object{this_});
2436   auto status = MagickRadialBlurImageChannel(
2437     wand->getWand(), (ChannelType)channel, angle);
2438   if (status == MagickFalse) {
2439     IMAGICK_THROW("Unable to radial blur image");
2440   }
2441   return true;
2442 }
2443
2444 static bool HHVM_METHOD(Imagick, raiseImage,
2445     int64_t width, int64_t height, int64_t x, int64_t y, bool raise) {
2446   auto wand = getMagickWandResource(Object{this_});
2447   auto status = MagickRaiseImage(
2448     wand->getWand(), width, height, x, y, toMagickBool(raise));
2449   if (status == MagickFalse) {
2450     IMAGICK_THROW("Unable to raise image");
2451   }
2452   return true;
2453 }
2454
2455 static bool HHVM_METHOD(Imagick, randomThresholdImage,
2456     double low, double high, int64_t channel) {
2457   auto wand = getMagickWandResource(Object{this_});
2458   auto status = MagickRandomThresholdImageChannel(
2459     wand->getWand(), (ChannelType)channel, low, high);
2460   if (status == MagickFalse) {
2461     IMAGICK_THROW("Unable to random threshold image");
2462   }
2463   return true;
2464 }
2465
2466 static bool HHVM_METHOD(Imagick, readImage, const String& filename) {
2467   auto wand = getMagickWandResource(Object{this_});
2468   imagickReadOp(wand->getWand(), filename, MagickReadImage);
2469   return true;
2470 }
2471
2472 static bool HHVM_METHOD(Imagick, readImageBlob,
2473     const String& image, const String& filename) {
2474   auto wand = getMagickWandResource(Object{this_});
2475   auto status = MagickReadImageBlob(
2476     wand->getWand(), image.c_str(), image.size());
2477   if (status == MagickFalse) {
2478     IMAGICK_THROW("Unable to read image blob");
2479   }
2480   if (!filename.empty()) {
2481     MagickSetImageFilename(wand->getWand(), filename.c_str());
2482   }
2483   MagickSetLastIterator(wand->getWand());
2484   return true;
2485 }
2486
2487 static bool HHVM_METHOD(Imagick, readImageFile,
2488     const Resource& filehandle, const String& fileName) {
2489   auto wand = getMagickWandResource(Object{this_});
2490   imagickReadOp(wand->getWand(), filehandle, MagickReadImageFile);
2491   if (!fileName.empty()) {
2492     MagickSetImageFilename(wand->getWand(), fileName.c_str());
2493   }
2494   MagickSetLastIterator(wand->getWand());
2495   return true;
2496 }
2497
2498 static bool HHVM_METHOD(Imagick, readImages, const Array& files) {
2499   auto wand = getMagickWandResource(Object{this_});
2500   for (ArrayIter it(files); it; ++it) {
2501     String file = it.secondRefPlus().toString();
2502     imagickReadOp(wand->getWand(), file, MagickReadImage);
2503   }
2504   return true;
2505 }
2506
2507 static bool HHVM_METHOD(Imagick, recolorImage, const Array& matrix) {
2508   raiseDeprecated(s_Imagick.c_str(), "recolorImage");
2509
2510   auto wand = getMagickWandResource(Object{this_});
2511   auto array = toDoubleArray(matrix);
2512   if (array.empty()) {
2513     IMAGICK_THROW("The map contains disallowed characters");
2514   }
2515   auto order = (size_t)sqrt(array.size());
2516   if (order * order != array.size()) {
2517     IMAGICK_THROW("The color matrix must contain a square number of elements");
2518   }
2519 #pragma GCC diagnostic push
2520 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
2521   auto status = MagickRecolorImage(wand->getWand(), order, array.data());
2522 #pragma GCC diagnostic pop
2523   if (status == MagickFalse) {
2524     IMAGICK_THROW("Unable to recolor image");
2525   }
2526   return true;
2527 }
2528
2529 static bool HHVM_METHOD(Imagick, reduceNoiseImage, double radius) {
2530   raiseDeprecated(s_Imagick.c_str(), "reduceNoiseImage");
2531
2532   auto wand = getMagickWandResource(Object{this_});
2533 #pragma GCC diagnostic push
2534 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
2535   auto status = MagickReduceNoiseImage(wand->getWand(), radius);
2536 #pragma GCC diagnostic pop
2537   if (status == MagickFalse) {
2538     IMAGICK_THROW("Unable to reduce image noise");
2539   }
2540   return true;
2541 }
2542
2543 static bool HHVM_METHOD(Imagick, remapImage,
2544     const Object& replacement, int64_t dither) {
2545   auto wand = getMagickWandResource(Object{this_});
2546   auto wand2 = getMagickWandResource(replacement);
2547   auto status = MagickRemapImage(
2548     wand->getWand(), wand2->getWand(), (DitherMethod)dither);
2549   if (status == MagickFalse) {
2550     IMAGICK_THROW("Unable to remap image");
2551   }
2552   return true;
2553 }
2554
2555 static bool HHVM_METHOD(Imagick, removeImage) {
2556   auto wand = getMagickWandResource(Object{this_});
2557   auto status = MagickRemoveImage(wand->getWand());
2558   if (status == MagickFalse) {
2559     IMAGICK_THROW("Unable to remove image");
2560   }
2561   MagickSetLastIterator(wand->getWand());
2562   setImagePending(Object{this_}, true);
2563   return true;
2564 }
2565
2566 static String HHVM_METHOD(Imagick, removeImageProfile, const String& name) {
2567   auto wand = getMagickWandResource(Object{this_});
2568   size_t length;
2569   auto profile = MagickRemoveImageProfile(
2570     wand->getWand(), name.c_str(), &length);
2571   if (profile == nullptr) {
2572     IMAGICK_THROW("The image profile does not exist");
2573   } else {
2574     return convertMagickData(length, profile);
2575   }
2576 }
2577
2578 static bool HHVM_METHOD(Imagick, resampleImage,
2579     double x_resolution, double y_resolution, int64_t filter, double blur) {
2580   auto wand = getMagickWandResource(Object{this_});
2581   auto status = MagickResampleImage(
2582     wand->getWand(), x_resolution, y_resolution, (FilterTypes)filter, blur);
2583   if (status == MagickFalse) {
2584     IMAGICK_THROW("Unable to resample image");
2585   }
2586   return true;
2587 }
2588
2589 static bool HHVM_METHOD(Imagick, resetImagePage, const String& page) {
2590   auto wand = getMagickWandResource(Object{this_});
2591   auto status = MagickResetImagePage(wand->getWand(), page.c_str());
2592   if (status == MagickFalse) {
2593     IMAGICK_THROW("Unable to reset image page");
2594   }
2595   return true;
2596 }
2597
2598 static bool HHVM_METHOD(Imagick, resizeImage,
2599     int64_t columns, int64_t rows,
2600     int64_t filter, double blur, bool bestfit) {
2601   auto wand = getMagickWandResource(Object{this_});
2602   auto geometry = ImageGeometry(wand->getWand()).toThumbnail(
2603     {columns, rows}, bestfit);
2604   if (geometry.empty()) {
2605     IMAGICK_THROW("Invalid image geometry");
2606   }
2607   auto status = MagickResizeImage(
2608     wand->getWand(), geometry.getWidth(), geometry.getHeight(),
2609     (FilterTypes)filter, blur);
2610   if (status == MagickFalse) {
2611     IMAGICK_THROW("Unable to resize image");
2612   }
2613   return true;
2614 }
2615
2616 static bool HHVM_METHOD(Imagick, rollImage, int64_t x, int64_t y) {
2617   auto wand = getMagickWandResource(Object{this_});
2618   auto status = MagickRollImage(wand->getWand(), x, y);
2619   if (status == MagickFalse) {
2620     IMAGICK_THROW("Unable to roll image");
2621   }
2622   return true;
2623 }
2624
2625 static bool HHVM_METHOD(Imagick, rotateImage,
2626     const Variant& background, double degrees) {
2627   auto wand = getMagickWandResource(Object{this_});
2628   auto pixel = buildColorWand(background);
2629   auto status = MagickRotateImage(wand->getWand(), pixel->getWand(), degrees);
2630   if (status == MagickFalse) {
2631     IMAGICK_THROW("Unable to rotate image");
2632   }
2633   return true;
2634 }
2635
2636 static bool HHVM_METHOD(Imagick, roundCornersImage,
2637     double x_rounding, double y_rounding,
2638     double stroke_width, double displace, double size_correction) {
2639   auto wand = getMagickWandResource(Object{this_});
2640   auto geometry = ImageGeometry(wand->getWand());
2641
2642   if (geometry.empty()) {
2643     IMAGICK_THROW("Unable to round corners on empty image");
2644   }
2645
2646   if (MagickSetImageMatte(wand->getWand(), MagickTrue) == MagickFalse) {
2647     IMAGICK_THROW("Unable to set image matte");
2648   }
2649
2650   auto pixel = newPixelWand();
2651   if (pixel->getWand() == nullptr) {
2652     IMAGICK_THROW("Failed to allocate PixelWand structure");
2653   }
2654
2655   auto drawing = req::make<WandResource<DrawingWand>>(NewDrawingWand());
2656   if (drawing->getWand() == nullptr) {
2657     IMAGICK_THROW("Failed to allocate DrawingWand structure");
2658   }
2659
2660   auto magick = req::make<WandResource<MagickWand>>(NewMagickWand());
2661   if (magick->getWand() == nullptr) {
2662     IMAGICK_THROW("Failed to allocate MagickWand structure");
2663   }
2664
2665   if (PixelSetColor(pixel->getWand(), "transparent") == MagickFalse) {
2666     IMAGICK_THROW("Unable to set pixel color");
2667   }
2668
2669   if (MagickNewImage(magick->getWand(),
2670                      geometry.getWidth(),
2671                      geometry.getHeight(),
2672                      pixel->getWand()) == MagickFalse) {
2673     IMAGICK_THROW("Unable to allocate mask image");
2674   }
2675   MagickSetImageBackgroundColor(magick->getWand(), pixel->getWand());
2676
2677   if (PixelSetColor(pixel->getWand(), "white") == MagickFalse) {
2678     IMAGICK_THROW("Unable to set pixel color");
2679   }
2680   DrawSetFillColor(drawing->getWand(), pixel->getWand());
2681
2682   if (PixelSetColor(pixel->getWand(), "black") == MagickFalse) {
2683     IMAGICK_THROW("Unable to set pixel color");
2684   }
2685   DrawSetStrokeColor(drawing->getWand(), pixel->getWand());
2686   DrawSetStrokeWidth(drawing->getWand(), stroke_width);
2687   DrawRoundRectangle(drawing->getWand(), displace, displace,
2688                      geometry.getWidth() + size_correction,
2689                      geometry.getHeight() + size_correction,
2690                      x_rounding, y_rounding);
2691
2692   auto status = withMagickLocaleFix([&magick, &drawing](){
2693     return MagickDrawImage(magick->getWand(), drawing->getWand());
2694   });
2695   if (status == MagickFalse) {
2696     IMAGICK_THROW("Unable to draw on image");
2697   }
2698
2699   if (MagickCompositeImage(wand->getWand(), magick->getWand(),
2700                            DstInCompositeOp, 0, 0) == MagickFalse) {
2701     IMAGICK_THROW("Unable to composite image");
2702   }
2703
2704   return true;
2705 }
2706
2707 static bool HHVM_METHOD(Imagick, roundCorners,
2708     double x_rounding, double y_rounding,
2709     double stroke_width, double displace, double size_correction) {
2710   // raiseDeprecated(s_Imagick.c_str(), "roundCorners",
2711   //                 s_Imagick.c_str(), "roundCornersImage");
2712   return HHVM_MN(Imagick, roundCornersImage)(
2713     this_, x_rounding, y_rounding,
2714     stroke_width, displace, size_correction);
2715 }
2716
2717 static bool HHVM_METHOD(Imagick, sampleImage,
2718     int64_t columns, int64_t rows) {
2719   auto wand = getMagickWandResource(Object{this_});
2720   auto status = MagickSampleImage(wand->getWand(), columns, rows);
2721   if (status == MagickFalse) {
2722     IMAGICK_THROW("Unable to sample image");
2723   }
2724   return true;
2725 }
2726
2727 static bool HHVM_METHOD(Imagick, scaleImage,
2728     int64_t cols, int64_t rows, bool bestfit) {
2729   auto wand = getMagickWandResource(Object{this_});
2730   auto geometry = ImageGeometry(wand->getWand()).toThumbnail(
2731     {cols, rows}, bestfit);
2732   if (geometry.empty()) {
2733     IMAGICK_THROW("Invalid image geometry");
2734   }
2735   auto status = MagickScaleImage(
2736     wand->getWand(), geometry.getWidth(), geometry.getHeight());
2737   if (status == MagickFalse) {
2738     IMAGICK_THROW("Unable to scale image");
2739   }
2740   return true;
2741 }
2742
2743 static bool HHVM_METHOD(Imagick, segmentImage, int64_t colorspace,
2744     double cluster_threshold, double smooth_threshold, bool verbose) {
2745   auto wand = getMagickWandResource(Object{this_});
2746   auto status = MagickSegmentImage(
2747     wand->getWand(), (ColorspaceType)colorspace,
2748     toMagickBool(verbose), cluster_threshold, smooth_threshold);
2749   if (status == MagickFalse) {
2750     IMAGICK_THROW("Unable to segment image");
2751   }
2752   return true;
2753 }
2754
2755 static bool HHVM_METHOD(Imagick, separateImageChannel, int64_t channel) {
2756   auto wand = getMagickWandResource(Object{this_});
2757   auto status = MagickSeparateImageChannel(
2758     wand->getWand(), (ChannelType)channel);
2759   if (status == MagickFalse) {
2760     IMAGICK_THROW("Unable to separate image channel");
2761   }
2762   return true;
2763 }
2764
2765 static bool HHVM_METHOD(Imagick, sepiaToneImage, double threshold) {
2766   auto wand = getMagickWandResource(Object{this_});
2767   auto status = MagickSepiaToneImage(wand->getWand(), threshold);
2768   if (status == MagickFalse) {
2769     IMAGICK_THROW("Unable to sepia tone image");
2770   }
2771   return true;
2772 }
2773
2774 static bool HHVM_METHOD(Imagick, setBackgroundColor,
2775     const Variant& background) {
2776   auto wand = getMagickWandResource(Object{this_});
2777   auto pixel = buildColorWand(background);
2778   auto status = MagickSetBackgroundColor(wand->getWand(), pixel->getWand());
2779   if (status == MagickFalse) {
2780     IMAGICK_THROW("Unable to set background color");
2781   }
2782   return true;
2783 }
2784
2785 static bool HHVM_METHOD(Imagick, setColorspace, int64_t colorspace) {
2786   auto wand = getMagickWandResource(Object{this_});
2787   return MagickSetColorspace(
2788     wand->getWand(), (ColorspaceType)colorspace) != MagickFalse;
2789 }
2790
2791 static bool HHVM_METHOD(Imagick, setCompression, int64_t compression) {
2792   auto wand = getMagickWandResource(Object{this_});
2793   auto status = MagickSetCompression(
2794     wand->getWand(), (CompressionType)compression);
2795   if (status == MagickFalse) {
2796     IMAGICK_THROW("Unable to set compression");
2797   }
2798   return true;
2799 }
2800
2801 static bool HHVM_METHOD(Imagick, setCompressionQuality, int64_t quality) {
2802   auto wand = getMagickWandResource(Object{this_});
2803   auto status = MagickSetCompressionQuality(wand->getWand(), quality);
2804   if (status == MagickFalse) {
2805     IMAGICK_THROW("Unable to set compression quality");
2806   }
2807   return true;
2808 }
2809
2810 static bool HHVM_METHOD(Imagick, setFilename, const String& filename) {
2811   auto wand = getMagickWandResource(Object{this_});
2812   auto status = MagickSetFilename(wand->getWand(), filename.c_str());
2813   if (status == MagickFalse) {
2814     IMAGICK_THROW("Unable to set filename");
2815   }
2816   return true;
2817 }
2818
2819 static bool HHVM_METHOD(Imagick, setFirstIterator) {
2820   auto wand = getMagickWandResource(Object{this_});
2821   MagickSetFirstIterator(wand->getWand());
2822   setImagePending(Object{this_}, false);
2823   return true;
2824 }
2825
2826 static bool HHVM_METHOD(Imagick, setFont, const String& fontName) {
2827   auto wand = getMagickWandResource(Object{this_});
2828   auto font = magickResolveFont(fontName);
2829   if (font.isNull() ||
2830       MagickSetFont(wand->getWand(), font.c_str()) == MagickFalse) {
2831     IMAGICK_THROW("Unable to set font");
2832   }
2833   return true;
2834 }
2835
2836 static bool HHVM_METHOD(Imagick, setFormat, const String& format) {
2837   auto wand = getMagickWandResource(Object{this_});
2838   auto status = MagickSetFormat(wand->getWand(), format.c_str());
2839   if (status == MagickFalse) {
2840     IMAGICK_THROW("Unable to set format");
2841   }
2842   return true;
2843 }
2844
2845 static bool HHVM_METHOD(Imagick, setGravity, int64_t gravity) {
2846   auto wand = getMagickWandResource(Object{this_});
2847   auto status = MagickSetGravity(wand->getWand(), (GravityType)gravity);
2848   if (status == MagickFalse) {
2849     IMAGICK_THROW("Unable to set gravity");
2850   }
2851   return true;
2852 }
2853
2854 static bool HHVM_METHOD(Imagick, setImage, const Object& replace) {
2855   auto wand = getMagickWandResource(Object{this_});
2856   auto wand2 = getMagickWandResource(replace);
2857   auto status = MagickSetImage(wand->getWand(), wand2->getWand());
2858   if (status == MagickFalse) {
2859     IMAGICK_THROW("Unable to set the image");
2860   }
2861   return true;
2862 }
2863
2864 static bool HHVM_METHOD(Imagick, setImageAlphaChannel, int64_t mode) {
2865   auto wand = getMagickWandResource(Object{this_});
2866   auto status = MagickSetImageAlphaChannel(
2867     wand->getWand(), (AlphaChannelType)mode);
2868   if (status == MagickFalse) {
2869     IMAGICK_THROW("Unable to set image alpha channel");
2870   }
2871   return true;
2872 }
2873
2874 static bool HHVM_METHOD(Imagick, setImageArtifact,
2875     const String& artifact, const String& value) {
2876   auto wand = getMagickWandResource(Object{this_});
2877   auto status = MagickSetImageArtifact(
2878     wand->getWand(), artifact.c_str(), value.c_str());
2879   if (status == MagickFalse) {
2880     IMAGICK_THROW("Unable to set image artifact");
2881   }
2882   return true;
2883 }
2884
2885 static bool HHVM_METHOD(Imagick, setImageBackgroundColor,
2886     const Variant& background) {
2887   auto wand = getMagickWandResource(Object{this_});
2888   auto pixel = buildColorWand(background);
2889   auto status = MagickSetImageBackgroundColor(
2890     wand->getWand(), pixel->getWand());
2891   if (status == MagickFalse) {
2892     IMAGICK_THROW("Unable to set image background color");
2893   }
2894   return true;
2895 }
2896
2897 static bool HHVM_METHOD(Imagick, setImageBias, double bias) {
2898   auto wand = getMagickWandResource(Object{this_});
2899   auto status = MagickSetImageBias(wand->getWand(), bias);
2900   if (status == MagickFalse) {
2901     IMAGICK_THROW("Unable to set image bias");
2902   }
2903   return true;
2904 }
2905
2906 static bool HHVM_METHOD(Imagick, setImageBluePrimary, double x, double y) {
2907   auto wand = getMagickWandResource(Object{this_});
2908   auto status = MagickSetImageBluePrimary(wand->getWand(), x, y);
2909   if (status == MagickFalse) {
2910     IMAGICK_THROW("Unable to set image blue primary");
2911   }
2912   return true;
2913 }
2914
2915 static bool HHVM_METHOD(Imagick, setImageBorderColor, const Variant& border) {
2916   auto wand = getMagickWandResource(Object{this_});
2917   auto pixel = buildColorWand(border);
2918   auto status = MagickSetImageBorderColor(wand->getWand(), pixel->getWand());
2919   if (status == MagickFalse) {
2920     IMAGICK_THROW("Unable to set image border color");
2921   }
2922   return true;
2923 }
2924
2925 static bool HHVM_METHOD(Imagick, setImageChannelDepth,
2926     int64_t channel, int64_t depth) {
2927   auto wand = getMagickWandResource(Object{this_});
2928   auto status = MagickSetImageChannelDepth(
2929     wand->getWand(), (ChannelType)channel, depth);
2930   if (status == MagickFalse) {
2931     IMAGICK_THROW("Unable to set image channel depth");
2932   }
2933   return true;
2934 }
2935
2936 static bool HHVM_METHOD(Imagick, setImageClipMask, const Object& clip_mask) {
2937   auto wand = getMagickWandResource(Object{this_});
2938   auto wand2 = getMagickWandResource(clip_mask);
2939   auto status = MagickSetImageClipMask(wand->getWand(), wand2->getWand());
2940   if (status == MagickFalse) {
2941     IMAGICK_THROW("Unable to set image clip mask");
2942   }
2943   return true;
2944 }
2945
2946 static bool HHVM_METHOD(Imagick, setImageColormapColor,
2947     int64_t index, const Object& color) {
2948   auto wand = getMagickWandResource(Object{this_});
2949   auto pixel = buildColorWand(color);
2950   auto status = MagickSetImageColormapColor(
2951     wand->getWand(), index, pixel->getWand());
2952   if (status == MagickFalse) {
2953     IMAGICK_THROW("Unable to set image color map color");
2954   }
2955   return true;
2956 }
2957
2958 static bool HHVM_METHOD(Imagick, setImageColorspace, int64_t colorspace) {
2959   auto wand = getMagickWandResource(Object{this_});
2960   auto status = MagickSetImageColorspace(
2961     wand->getWand(), (ColorspaceType)colorspace);
2962   if (status == MagickFalse) {
2963     IMAGICK_THROW("Unable to set image colorspace");
2964   }
2965   return true;
2966 }
2967
2968 static bool HHVM_METHOD(Imagick, setImageCompose, int64_t compose) {
2969   auto wand = getMagickWandResource(Object{this_});
2970   auto status = MagickSetImageCompose(
2971     wand->getWand(), (CompositeOperator)compose);
2972   if (status == MagickFalse) {
2973     IMAGICK_THROW("Unable to set image composite operator");
2974   }
2975   return true;
2976 }
2977
2978 static bool HHVM_METHOD(Imagick, setImageCompression, int64_t compression) {
2979   auto wand = getMagickWandResource(Object{this_});
2980   auto status = MagickSetImageCompression(
2981     wand->getWand(), (CompressionType)compression);
2982   if (status == MagickFalse) {
2983     IMAGICK_THROW("Unable to set image compression");
2984   }
2985   return true;
2986 }
2987
2988 static bool HHVM_METHOD(Imagick, setImageCompressionQuality,
2989     int64_t quality) {
2990   auto wand = getMagickWandResource(Object{this_});
2991   auto status = MagickSetImageCompressionQuality(wand->getWand(), quality);
2992   if (status == MagickFalse) {
2993     IMAGICK_THROW("Unable to set image compression quality");
2994   }
2995   return true;
2996 }
2997
2998 static bool HHVM_METHOD(Imagick, setImageDelay, int64_t delay) {
2999   auto wand = getMagickWandResource(Object{this_});
3000   auto status = MagickSetImageDelay(wand->getWand(), delay);
3001   if (status == MagickFalse) {
3002     IMAGICK_THROW("Unable to set image delay");
3003   }
3004   return true;
3005 }
3006
3007 static bool HHVM_METHOD(Imagick, setImageDepth, int64_t depth) {
3008   auto wand = getMagickWandResource(Object{this_});
3009   auto status = MagickSetImageDepth(wand->getWand(), depth);
3010   if (status == MagickFalse) {
3011     IMAGICK_THROW("Unable to set image depth");
3012   }
3013   return true;
3014 }
3015
3016 static bool HHVM_METHOD(Imagick, setImageDispose, int64_t dispose) {
3017   auto wand = getMagickWandResource(Object{this_});
3018   auto status = MagickSetImageDispose(
3019     wand->getWand(), (DisposeType)dispose);
3020   if (status == MagickFalse) {
3021     IMAGICK_THROW("Unable to set image dispose");
3022   }
3023   return true;
3024 }
3025
3026 static bool HHVM_METHOD(Imagick, setImageExtent,
3027     int64_t columns, int64_t rows) {
3028   auto wand = getMagickWandResource(Object{this_});
3029   auto status = MagickSetImageExtent(wand->getWand(), columns, rows);
3030   if (status == MagickFalse) {
3031     IMAGICK_THROW("Unable to set image extent");
3032   }
3033   return true;
3034 }
3035
3036 static bool HHVM_METHOD(Imagick, setImageFilename, const String& filename) {
3037   auto wand = getMagickWandResource(Object{this_});
3038   auto status = MagickSetImageFilename(wand->getWand(), filename.c_str());
3039   if (status == MagickFalse) {
3040     IMAGICK_THROW("Unable to set image filename");
3041   }
3042   return true;
3043 }
3044
3045 static bool HHVM_METHOD(Imagick, setImageFormat, const String& format) {
3046   auto wand = getMagickWandResource(Object{this_});
3047   auto status = MagickSetImageFormat(wand->getWand(), format.c_str());
3048   if (status == MagickFalse) {
3049     IMAGICK_THROW("Unable to set image format");
3050   }
3051   return true;
3052 }
3053
3054 static bool HHVM_METHOD(Imagick, setImageGamma, double gamma) {
3055   auto wand = getMagickWandResource(Object{this_});
3056   auto status = MagickSetImageGamma(wand->getWand(), gamma);
3057   if (status == MagickFalse) {
3058     IMAGICK_THROW("Unable to set image gamma");
3059   }
3060   return true;
3061 }
3062
3063 static bool HHVM_METHOD(Imagick, setImageGravity, int64_t gravity) {
3064   auto wand = getMagickWandResource(Object{this_});
3065   auto status = MagickSetImageGravity(
3066     wand->getWand(), (GravityType)gravity);
3067   if (status == MagickFalse) {
3068     IMAGICK_THROW("Unable to set image gravity");
3069   }
3070   return true;
3071 }
3072
3073 static bool HHVM_METHOD(Imagick, setImageGreenPrimary, double x, double y) {
3074   auto wand = getMagickWandResource(Object{this_});
3075   auto status = MagickSetImageGreenPrimary(wand->getWand(), x, y);
3076   if (status == MagickFalse) {
3077     IMAGICK_THROW("Unable to set image green primary");
3078   }
3079   return true;
3080 }
3081
3082 static bool HHVM_METHOD(Imagick, setImageIndex, int64_t index) {
3083   raiseDeprecated(s_Imagick.c_str(), "setImageIndex");
3084
3085   auto wand = getMagickWandResource(Object{this_});
3086 #pragma GCC diagnostic push
3087 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
3088   auto status = MagickSetImageIndex(wand->getWand(), index);
3089 #pragma GCC diagnostic pop
3090   if (status == MagickFalse) {
3091     IMAGICK_THROW("Unable to set image index");
3092   }
3093   setImagePending(Object{this_}, false);
3094   return true;
3095 }
3096
3097 static bool HHVM_METHOD(Imagick, setImageInterlaceScheme,
3098     int64_t interlace_scheme) {
3099   auto wand = getMagickWandResource(Object{this_});
3100   auto status = MagickSetImageInterlaceScheme(
3101     wand->getWand(), (InterlaceType)interlace_scheme);
3102   if (status == MagickFalse) {
3103     IMAGICK_THROW("Unable to set image interlace scheme");
3104   }
3105   return true;
3106 }
3107
3108 static bool HHVM_METHOD(Imagick, setImageInterpolateMethod, int64_t method) {
3109   auto wand = getMagickWandResource(Object{this_});
3110   auto status = MagickSetImageInterpolateMethod(
3111     wand->getWand(), (InterpolatePixelMethod)method);
3112   if (status == MagickFalse) {
3113     IMAGICK_THROW("Unable to set the image interpolate method");
3114   }
3115   return true;
3116 }
3117
3118 static bool HHVM_METHOD(Imagick, setImageIterations, int64_t iterations) {
3119   auto wand = getMagickWandResource(Object{this_});
3120   auto status = MagickSetImageIterations(wand->getWand(), iterations);
3121   if (status == MagickFalse) {
3122     IMAGICK_THROW("Unable to set image iterations");
3123   }
3124   return true;
3125 }
3126
3127 static bool HHVM_METHOD(Imagick, setImageMatte, bool matte) {
3128   auto wand = getMagickWandResource(Object{this_});
3129   auto status = MagickSetImageMatte(wand->getWand(), toMagickBool(matte));
3130   if (status == MagickFalse) {
3131     IMAGICK_THROW("Unable to set image matte");
3132   }
3133   return true;
3134 }
3135
3136 static bool HHVM_METHOD(Imagick, setImageMatteColor, const Variant& matte) {
3137   auto wand = getMagickWandResource(Object{this_});
3138   auto pixel = buildColorWand(matte);
3139   auto status = MagickSetImageMatteColor(wand->getWand(), pixel->getWand());
3140   if (status == MagickFalse) {
3141     IMAGICK_THROW("Unable to set image matte color");
3142   }
3143   return true;
3144 }
3145
3146 static bool HHVM_METHOD(Imagick, setImageOpacity, double opacity) {
3147   auto wand = getMagickWandResource(Object{this_});
3148   auto status = MagickSetImageOpacity(wand->getWand(), opacity);
3149   if (status == MagickFalse) {
3150     IMAGICK_THROW("Unable to set image opacity");
3151   }
3152   return true;
3153 }
3154
3155 static bool HHVM_METHOD(Imagick, setImageOrientation, int64_t orientation) {
3156   auto wand = getMagickWandResource(Object{this_});
3157   auto status = MagickSetImageOrientation(
3158     wand->getWand(), (OrientationType)orientation);
3159   if (status == MagickFalse) {
3160     IMAGICK_THROW("Unable to set image orientation");
3161   }
3162   return true;
3163 }
3164
3165 static bool HHVM_METHOD(Imagick, setImagePage,
3166     int64_t width, int64_t height, int64_t x, int64_t y) {
3167   auto wand = getMagickWandResource(Object{this_});
3168   auto status = MagickSetImagePage(wand->getWand(), width, height, x, y);
3169   if (status == MagickFalse) {
3170     IMAGICK_THROW("Unable to set image page");
3171   }
3172   return true;
3173 }
3174
3175 static bool HHVM_METHOD(Imagick, setImageProfile,
3176     const String& name, const String& profile) {
3177   auto wand = getMagickWandResource(Object{this_});
3178   auto status = MagickSetImageProfile(
3179     wand->getWand(), name.c_str(), profile.c_str(), profile.length());
3180   if (status == MagickFalse) {
3181     IMAGICK_THROW("Unable to set image profile");
3182   }
3183   return true;
3184 }
3185
3186 static bool HHVM_METHOD(Imagick, setImageProperty,
3187     const String& name, const String& value) {
3188   auto wand = getMagickWandResource(Object{this_});
3189   auto status = MagickSetImageProperty(
3190     wand->getWand(), name.c_str(), value.c_str());
3191   if (status == MagickFalse) {
3192     IMAGICK_THROW("Unable to set image property");
3193   }
3194   return true;
3195 }
3196
3197 static bool HHVM_METHOD(Imagick, setImageRedPrimary, double x, double y) {
3198   auto wand = getMagickWandResource(Object{this_});
3199   auto status = MagickSetImageRedPrimary(wand->getWand(), x, y);
3200   if (status == MagickFalse) {
3201     IMAGICK_THROW("Unable to set image red primary");
3202   }
3203   return true;
3204 }
3205
3206 static bool HHVM_METHOD(Imagick, setImageRenderingIntent,
3207     int64_t rendering_intent) {
3208   auto wand = getMagickWandResource(Object{this_});
3209   auto status = MagickSetImageRenderingIntent(
3210     wand->getWand(), (RenderingIntent)rendering_intent);
3211   if (status == MagickFalse) {
3212     IMAGICK_THROW("Unable to set image rendering intent");
3213   }
3214   return true;
3215 }
3216
3217 static bool HHVM_METHOD(Imagick, setImageResolution,
3218     double x_resolution, double y_resolution) {
3219   auto wand = getMagickWandResource(Object{this_});
3220   auto status = MagickSetImageResolution(
3221     wand->getWand(), x_resolution, y_resolution);
3222   if (status == MagickFalse) {
3223     IMAGICK_THROW("Unable to set image resolution");
3224   }
3225   return true;
3226 }
3227
3228 static bool HHVM_METHOD(Imagick, setImageScene, int64_t scene) {
3229   auto wand = getMagickWandResource(Object{this_});
3230   auto status = MagickSetImageScene(wand->getWand(), scene);
3231   if (status == MagickFalse) {
3232     IMAGICK_THROW("Unable to set image scene");
3233   }
3234   return true;
3235 }
3236
3237 static bool HHVM_METHOD(Imagick, setImageTicksPerSecond,
3238     int64_t ticks_per_second) {
3239   auto wand = getMagickWandResource(Object{this_});
3240   auto status = MagickSetImageTicksPerSecond(
3241     wand->getWand(), ticks_per_second);
3242   if (status == MagickFalse) {
3243     IMAGICK_THROW("Unable to set image ticks per second");
3244   }
3245   return true;
3246 }
3247
3248 static bool HHVM_METHOD(Imagick, setImageType, int64_t image_type) {
3249   auto wand = getMagickWandResource(Object{this_});
3250   auto status = MagickSetImageType(
3251     wand->getWand(), (ImageType)image_type);
3252   if (status == MagickFalse) {
3253     IMAGICK_THROW("Unable to set image type");
3254   }
3255   return true;
3256 }
3257
3258 static bool HHVM_METHOD(Imagick, setImageUnits, int64_t units) {
3259   auto wand = getMagickWandResource(Object{this_});
3260   auto status = MagickSetImageUnits(
3261     wand->getWand(), (ResolutionType)units);
3262   if (status == MagickFalse) {
3263     IMAGICK_THROW("Unable to set image units");
3264   }
3265   return true;
3266 }
3267
3268 static bool HHVM_METHOD(Imagick, setImageVirtualPixelMethod,
3269     int64_t method) {
3270   auto wand = getMagickWandResource(Object{this_});
3271   MagickSetImageVirtualPixelMethod(
3272     wand->getWand(), (VirtualPixelMethod)method);
3273   return true;
3274 }
3275
3276 static bool HHVM_METHOD(Imagick, setImageWhitePoint, double x, double y) {
3277   auto wand = getMagickWandResource(Object{this_});
3278   auto status = MagickSetImageWhitePoint(wand->getWand(), x, y);
3279   if (status == MagickFalse) {
3280     IMAGICK_THROW("Unable to set image white point");
3281   }
3282   return true;
3283 }
3284
3285 static bool HHVM_METHOD(Imagick, setInterlaceScheme,
3286     int64_t interlace_scheme) {
3287   auto wand = getMagickWandResource(Object{this_});
3288   auto status = MagickSetInterlaceScheme(
3289     wand->getWand(), (InterlaceType)interlace_scheme);
3290   if (status == MagickFalse) {
3291     IMAGICK_THROW("Unable to set interlace scheme");
3292   }
3293   return true;
3294 }
3295
3296 static bool HHVM_METHOD(Imagick, setIteratorIndex, int64_t index) {
3297   auto wand = getMagickWandResource(Object{this_});
3298   auto status = MagickSetIteratorIndex(wand->getWand(), index);
3299   if (status == MagickFalse) {
3300     IMAGICK_THROW("Unable to set iterator index");
3301   }
3302   setImagePending(Object{this_}, false);
3303   return true;
3304 }
3305
3306 static bool HHVM_METHOD(Imagick, setLastIterator) {
3307   auto wand = getMagickWandResource(Object{this_});
3308   MagickSetLastIterator(wand->getWand());
3309   setImagePending(Object{this_}, true);
3310   return true;
3311 }
3312
3313 static bool HHVM_METHOD(Imagick, setOption,
3314     const String& key, const String& value) {
3315   auto wand = getMagickWandResource(Object{this_});
3316   auto status = MagickSetOption(wand->getWand(), key.c_str(), value.c_str());
3317   if (status == MagickFalse) {
3318     IMAGICK_THROW("Unable to set option");
3319   }
3320   return true;
3321 }
3322
3323 static bool HHVM_METHOD(Imagick, setPage,
3324     int64_t width, int64_t height, int64_t x, int64_t y) {
3325   auto wand = getMagickWandResource(Object{this_});
3326   auto status = MagickSetPage(wand->getWand(), width, height, x, y);
3327   if (status == MagickFalse) {
3328     IMAGICK_THROW("Unable to set page");
3329   }
3330   return true;
3331 }
3332
3333 static bool HHVM_METHOD(Imagick, setPointSize, double point_size) {
3334   auto wand = getMagickWandResource(Object{this_});
3335   auto status = MagickSetPointsize(wand->getWand(), point_size);
3336   if (status == MagickFalse) {
3337     IMAGICK_THROW("Unable to set point size");
3338   }
3339   return true;
3340 }
3341
3342 static bool HHVM_METHOD(Imagick, setResolution,
3343     double x_resolution, double y_resolution) {
3344   auto wand = getMagickWandResource(Object{this_});
3345   auto status = MagickSetResolution(
3346     wand->getWand(), x_resolution, y_resolution);
3347   if (status == MagickFalse) {
3348     IMAGICK_THROW("Unable to set resolution");
3349   }
3350   return true;
3351 }
3352
3353 static bool HHVM_STATIC_METHOD(Imagick, setResourceLimit,
3354     int64_t type, int64_t limit) {
3355   auto status = MagickSetResourceLimit((ResourceType)type, limit);
3356   if (status == MagickFalse) {
3357     IMAGICK_THROW("Unable to set resource limit");
3358   }
3359   return true;
3360 }
3361
3362 static bool HHVM_METHOD(Imagick, setSamplingFactors, const Array& factors) {
3363   auto wand = getMagickWandResource(Object{this_});
3364   auto array = toDoubleArray(factors);
3365   if (array.empty()) {
3366     IMAGICK_THROW("Can't read array");
3367   }
3368   auto status = MagickSetSamplingFactors(
3369     wand->getWand(), array.size(), array.data());
3370   if (status == MagickFalse) {
3371     IMAGICK_THROW("Unable to set sampling factors");
3372   }
3373   return true;
3374 }
3375
3376 static bool HHVM_METHOD(Imagick, setSize, int64_t columns, int64_t rows) {
3377   auto wand = getMagickWandResource(Object{this_});
3378   auto status = MagickSetSize(wand->getWand(), columns, rows);
3379   if (status == MagickFalse) {
3380     IMAGICK_THROW("Unable to set size");
3381   }
3382   return true;
3383 }
3384
3385 static bool HHVM_METHOD(Imagick, setSizeOffset,
3386     int64_t columns, int64_t rows, int64_t offset) {
3387   auto wand = getMagickWandResource(Object{this_});
3388   auto status = MagickSetSizeOffset(wand->getWand(), columns, rows, offset);
3389   if (status == MagickFalse) {
3390     IMAGICK_THROW("Unable to set size offset");
3391   }
3392   return true;
3393 }
3394
3395 static bool HHVM_METHOD(Imagick, setType, int64_t image_type) {
3396   auto wand = getMagickWandResource(Object{this_});
3397   auto status = MagickSetType(
3398     wand->getWand(), (ImageType)image_type);
3399   if (status == MagickFalse) {
3400     IMAGICK_THROW("Unable to set type");
3401   }
3402   return true;
3403 }
3404
3405 static bool HHVM_METHOD(Imagick, shadeImage,
3406     bool gray, double azimuth, double elevation) {
3407   auto wand = getMagickWandResource(Object{this_});
3408   auto status = MagickShadeImage(
3409     wand->getWand(), toMagickBool(gray), azimuth, elevation);
3410   if (status == MagickFalse) {
3411     IMAGICK_THROW("Unable to shade image");
3412   }
3413   return true;
3414 }
3415
3416 static bool HHVM_METHOD(Imagick, shadowImage,
3417     double opacity, double sigma, int64_t x, int64_t y) {
3418   auto wand = getMagickWandResource(Object{this_});
3419   auto status = MagickShadowImage(wand->getWand(), opacity, sigma, x, y);
3420   if (status == MagickFalse) {
3421     IMAGICK_THROW("Unable to shadow image");
3422   }
3423   return true;
3424 }
3425
3426 static bool HHVM_METHOD(Imagick, sharpenImage,
3427     double radius, double sigma, int64_t channel) {
3428   auto wand = getMagickWandResource(Object{this_});
3429   auto status = MagickSharpenImageChannel(
3430     wand->getWand(), (ChannelType)channel, radius, sigma);
3431   if (status == MagickFalse) {
3432     IMAGICK_THROW("Unable to sharpen image");
3433   }
3434   return true;
3435 }
3436
3437 static bool HHVM_METHOD(Imagick, shaveImage, int64_t columns, int64_t rows) {
3438   auto wand = getMagickWandResource(Object{this_});
3439   auto status = MagickShaveImage(wand->getWand(), columns, rows);
3440   if (status == MagickFalse) {
3441     IMAGICK_THROW("Unable to shave image");
3442   }
3443   return true;
3444 }
3445
3446 static bool HHVM_METHOD(Imagick, shearImage,
3447     const Variant& background, double x_shear, double y_shear) {
3448   auto wand = getMagickWandResource(Object{this_});
3449   auto pixel = buildColorWand(background);
3450   auto status = MagickShearImage(
3451     wand->getWand(), pixel->getWand(), x_shear, y_shear);
3452   if (status == MagickFalse) {
3453     IMAGICK_THROW("Unable to shear image");
3454   }
3455   return true;
3456 }
3457
3458 static bool HHVM_METHOD(Imagick, sigmoidalContrastImage,
3459     bool sharpen, double alpha, double beta, int64_t channel) {
3460   auto wand = getMagickWandResource(Object{this_});
3461   auto status = MagickSigmoidalContrastImageChannel(
3462     wand->getWand(), (ChannelType)channel, toMagickBool(sharpen), alpha, beta);
3463   if (status == MagickFalse) {
3464     IMAGICK_THROW("Unable to sigmoidal contrast image");
3465   }
3466   return true;
3467 }
3468
3469 static bool HHVM_METHOD(Imagick, sketchImage,
3470     double radius, double sigma, double angle) {
3471   auto wand = getMagickWandResource(Object{this_});
3472   auto status = MagickSketchImage(wand->getWand(), radius, sigma, angle);
3473   if (status == MagickFalse) {
3474     IMAGICK_THROW("Unable to sketch image");
3475   }
3476   return true;
3477 }
3478
3479 static bool HHVM_METHOD(Imagick, solarizeImage, int64_t threshold) {
3480   auto wand = getMagickWandResource(Object{this_});
3481   auto status = MagickSolarizeImage(wand->getWand(), threshold);
3482   if (status == MagickFalse) {
3483     IMAGICK_THROW("Unable to solarize image");
3484   }
3485   return true;
3486 }
3487
3488 static bool HHVM_METHOD(Imagick, sparseColorImage,
3489     int64_t sparse, const Array& arguments, int64_t channel) {
3490   auto wand = getMagickWandResource(Object{this_});
3491   auto array = toDoubleArray(arguments);
3492   if (array.empty()) {
3493     IMAGICK_THROW("The map must contain only numeric values");
3494   }
3495   auto status = MagickSparseColorImage(
3496     wand->getWand(), (ChannelType)channel, (SparseColorMethod)sparse,
3497     array.size(), array.data());
3498   if (status == MagickFalse) {
3499     IMAGICK_THROW("Unable to sparse color image");
3500   }
3501   return true;
3502 }
3503
3504 static bool HHVM_METHOD(Imagick, spliceImage,
3505     int64_t width, int64_t height, int64_t x, int64_t y) {
3506   auto wand = getMagickWandResource(Object{this_});
3507   auto status = MagickSpliceImage(wand->getWand(), width, height, x, y);
3508   if (status == MagickFalse) {
3509     IMAGICK_THROW("Unable to splice image");
3510   }
3511   return true;
3512 }
3513
3514 static bool HHVM_METHOD(Imagick, spreadImage, double radius) {
3515   auto wand = getMagickWandResource(Object{this_});
3516   auto status = MagickSpreadImage(wand->getWand(), radius);
3517   if (status == MagickFalse) {
3518     IMAGICK_THROW("Unable to spread image");
3519   }
3520   return true;
3521 }
3522
3523 static Object HHVM_METHOD(Imagick, steganoImage,
3524     const Object& watermark_wand, int64_t offset) {
3525   auto wand = getMagickWandResource(Object{this_});
3526   auto wand2 = getMagickWandResource(watermark_wand);
3527   auto magick = MagickSteganoImage(wand->getWand(), wand2->getWand(), offset);
3528   if (magick == nullptr) {
3529     IMAGICK_THROW("Stegano image failed");
3530   }
3531   return createImagick(magick);
3532 }
3533
3534 static Object HHVM_METHOD(Imagick, stereoImage, const Object& offset_wand) {
3535   auto wand = getMagickWandResource(Object{this_});
3536   auto wand2 = getMagickWandResource(offset_wand);
3537   auto magick = MagickStereoImage(wand->getWand(), wand2->getWand());
3538   if (magick == nullptr) {
3539     IMAGICK_THROW("Stereo image failed");
3540   }
3541   return createImagick(magick);
3542 }
3543
3544 static bool HHVM_METHOD(Imagick, stripImage) {
3545   auto wand = getMagickWandResource(Object{this_});
3546   auto status = MagickStripImage(wand->getWand());
3547   if (status == MagickFalse) {
3548     IMAGICK_THROW("Unable to strip image");
3549   }
3550   return true;
3551 }
3552
3553 static bool HHVM_METHOD(Imagick, swirlImage, double degrees) {
3554   auto wand = getMagickWandResource(Object{this_});
3555   auto status = MagickSwirlImage(wand->getWand(), degrees);
3556   if (status == MagickFalse) {
3557     IMAGICK_THROW("Unable to swirl image");
3558   }
3559   return true;
3560 }
3561
3562 static Object HHVM_METHOD(Imagick, textureImage, const Object& texture_wand) {
3563   auto wand = getMagickWandResource(Object{this_});
3564   auto wand2 = getMagickWandResource(texture_wand);
3565   auto magick = MagickTextureImage(wand->getWand(), wand2->getWand());
3566   if (magick == nullptr) {
3567     IMAGICK_THROW("Texture image failed");
3568   }
3569   return createImagick(magick);
3570 }
3571
3572 static bool HHVM_METHOD(Imagick, thresholdImage,
3573     double threshold, int64_t channel) {
3574   auto wand = getMagickWandResource(Object{this_});
3575   auto status = MagickThresholdImageChannel(
3576     wand->getWand(), (ChannelType)channel, threshold);
3577   if (status == MagickFalse) {
3578     IMAGICK_THROW("Unable to threshold image");
3579   }
3580   return true;
3581 }
3582
3583 static bool HHVM_METHOD(Imagick, thumbnailImage,
3584     int64_t cols, int64_t rows, bool bestfit, bool fill) {
3585   auto wand = getMagickWandResource(Object{this_});
3586   auto geometry = ImageGeometry(wand->getWand()).toThumbnail(
3587       {cols, rows}, bestfit);
3588
3589   if (geometry.empty()) {
3590     IMAGICK_THROW("Invalid image geometry");
3591   }
3592
3593   // Resize the image to the new size
3594   auto status = MagickThumbnailImage(
3595     wand->getWand(), geometry.getWidth(), geometry.getHeight());
3596   if (status == MagickFalse) {
3597     IMAGICK_THROW("Unable to thumbnail image");
3598   }
3599
3600   // If the image does not fill the box completely the box is filled with
3601   // image's background color.
3602   if (bestfit && fill) {
3603     auto extent_x = std::max<ssize_t>(0, (cols - geometry.getWidth()) / 2);
3604     auto extent_y = std::max<ssize_t>(0, (rows - geometry.getHeight()) / 2);
3605     auto status = MagickExtentImage(
3606       wand->getWand(), cols, rows, -extent_x, -extent_y);
3607     if (status == MagickFalse) {
3608       IMAGICK_THROW("Unable to resize and fill image");
3609     }
3610   }
3611
3612   return true;
3613 }
3614
3615 static bool HHVM_METHOD(Imagick, tintImage,
3616     const Variant& tint, const Variant& opacity) {
3617   auto wand = getMagickWandResource(Object{this_});
3618   auto pixel = buildColorWand(tint);
3619   auto opacityPixel = buildOpacityWand(opacity);
3620   auto status = MagickTintImage(
3621     wand->getWand(), pixel->getWand(), opacityPixel->getWand());
3622   if (status == MagickFalse) {
3623     IMAGICK_THROW("Unable tint image");
3624   }
3625   return true;
3626 }
3627
3628 static Object HHVM_METHOD(Imagick, transformImage,
3629     const String& crop, const String& geometry) {
3630   auto wand = getMagickWandResource(Object{this_});
3631   auto magick = MagickTransformImage(
3632     wand->getWand(), crop.c_str(), geometry.c_str());
3633   if (!magick) {
3634     IMAGICK_THROW("Transforming image failed");
3635   }
3636   return createImagick(magick);
3637 }
3638
3639 static bool HHVM_METHOD(Imagick, transparentPaintImage,
3640     const Variant& target, double alpha, double fuzz, bool invert) {
3641   auto wand = getMagickWandResource(Object{this_});
3642   auto targetPixel = buildColorWand(target);
3643   auto status = MagickTransparentPaintImage(
3644     wand->getWand(), targetPixel->getWand(),
3645     alpha, fuzz, toMagickBool(invert));
3646   if (status == MagickFalse) {
3647     IMAGICK_THROW("Unable to paint transparent image");
3648   }
3649   return true;
3650 }
3651
3652 static bool HHVM_METHOD(Imagick, transposeImage) {
3653   auto wand = getMagickWandResource(Object{this_});
3654   auto status = MagickTransposeImage(wand->getWand());
3655   if (status == MagickFalse) {
3656     IMAGICK_THROW("Unable to transpose image");
3657   }
3658   return true;
3659 }
3660
3661 static bool HHVM_METHOD(Imagick, transverseImage) {
3662   auto wand = getMagickWandResource(Object{this_});
3663   auto status = MagickTransverseImage(wand->getWand());
3664   if (status == MagickFalse) {
3665     IMAGICK_THROW("Unable to transverse image");
3666   }
3667   return true;
3668 }
3669
3670 static bool HHVM_METHOD(Imagick, trimImage, double fuzz) {
3671   auto wand = getMagickWandResource(Object{this_});
3672   auto status = MagickTrimImage(wand->getWand(), fuzz);
3673   if (status == MagickFalse) {
3674     IMAGICK_THROW("Unable to trim image");
3675   }
3676   return true;
3677 }
3678
3679 static bool HHVM_METHOD(Imagick, uniqueImageColors) {
3680   auto wand = getMagickWandResource(Object{this_});
3681   auto status = MagickUniqueImageColors(wand->getWand());
3682   if (status == MagickFalse) {
3683     IMAGICK_THROW("Unable to get unique image colors");
3684   }
3685   return true;
3686 }
3687
3688 static bool HHVM_METHOD(Imagick, unsharpMaskImage,
3689     double radius, double sigma, double amount, double threshold,
3690     int64_t channel) {
3691   auto wand = getMagickWandResource(Object{this_});
3692   auto status = MagickUnsharpMaskImageChannel(
3693     wand->getWand(), (ChannelType)channel, radius, sigma, amount, threshold);
3694   if (status == MagickFalse) {
3695     IMAGICK_THROW("Unable to unsharp mask image");
3696   }
3697   return true;
3698 }
3699
3700 static bool HHVM_METHOD(Imagick, vignetteImage,
3701     double blackPoint, double whitePoint, int64_t x, int64_t y) {
3702   auto wand = getMagickWandResource(Object{this_});
3703   auto status = MagickVignetteImage(
3704     wand->getWand(), blackPoint, whitePoint, x, y);
3705   if (status == MagickFalse) {
3706     IMAGICK_THROW("Unable to apply vignette filter");
3707   }
3708   return true;
3709 }
3710
3711 static bool HHVM_METHOD(Imagick, waveImage,
3712     double amplitude, double length) {
3713   auto wand = getMagickWandResource(Object{this_});
3714   auto status = MagickWaveImage(wand->getWand(), amplitude, length);
3715   if (status == MagickFalse) {
3716     IMAGICK_THROW("Unable to wave image");
3717   }
3718   return true;
3719 }
3720
3721 static bool HHVM_METHOD(Imagick, whiteThresholdImage,
3722     const Variant& threshold) {
3723   auto wand = getMagickWandResource(Object{this_});
3724   auto pixel = buildColorWand(threshold);
3725   auto status = MagickWhiteThresholdImage(wand->getWand(), pixel->getWand());
3726   if (status == MagickFalse) {
3727     IMAGICK_THROW("Unable to white threshold image");
3728   }
3729   return true;
3730 }
3731
3732 static bool HHVM_METHOD(Imagick, writeImage, const String& filename) {
3733   auto wand = getMagickWandResource(Object{this_});
3734   imagickWriteOp(wand->getWand(), filename, MagickWriteImage);
3735   return true;
3736 }
3737
3738 static bool HHVM_METHOD(Imagick, writeImageFile,
3739     const Resource& filehandle, const String& format) {
3740   auto wand = getMagickWandResource(Object{this_});
3741   imagickWriteOp(wand->getWand(), filehandle, format, MagickWriteImageFile);
3742   return true;
3743 }
3744
3745 static bool HHVM_METHOD(Imagick, writeImages,
3746     const String& filename, bool adjoin) {
3747   auto wand = getMagickWandResource(Object{this_});
3748   imagickWriteOp(wand->getWand(), filename,
3749     [=](MagickWand* magick, const char* path) {
3750       return MagickWriteImages(magick, path, toMagickBool(adjoin));
3751     });
3752   return true;
3753 }
3754
3755 static bool HHVM_METHOD(Imagick, writeImagesFile,
3756     const Resource& filehandle, const String& format) {
3757   auto wand = getMagickWandResource(Object{this_});
3758   imagickWriteOp(wand->getWand(), filehandle, format, MagickWriteImagesFile);
3759   return true;
3760 }
3761
3762 // Countable interface
3763 static int HHVM_METHOD(Imagick, count) {
3764   return HHVM_MN(Imagick, getNumberImages)(this_);
3765 }
3766
3767 // Iterator interface
3768 static Object HHVM_METHOD(Imagick, current) {
3769   return Object{this_};
3770 }
3771
3772 static int HHVM_METHOD(Imagick, key) {
3773   return HHVM_MN(Imagick, getIteratorIndex)(this_);
3774 }
3775
3776 static void HHVM_METHOD(Imagick, next) {
3777   HHVM_MN(Imagick, nextImage)(this_);
3778 }
3779
3780 static void HHVM_METHOD(Imagick, rewind) {
3781   HHVM_MN(Imagick, setFirstIterator)(this_);
3782 }
3783
3784 static bool HHVM_METHOD(Imagick, valid) {
3785   return !getImagePending(Object{this_});
3786 }
3787
3788 #undef IMAGICK_THROW
3789
3790 void loadImagickClass() {
3791   HHVM_ME(Imagick, adaptiveBlurImage);
3792   HHVM_ME(Imagick, adaptiveResizeImage);
3793   HHVM_ME(Imagick, adaptiveSharpenImage);
3794   HHVM_ME(Imagick, adaptiveThresholdImage);
3795   HHVM_ME(Imagick, addImage);
3796   HHVM_ME(Imagick, addNoiseImage);
3797   HHVM_ME(Imagick, affineTransformImage);
3798   HHVM_ME(Imagick, animateImages);
3799   HHVM_ME(Imagick, annotateImage);
3800   HHVM_ME(Imagick, appendImages);
3801   HHVM_ME(Imagick, averageImages);
3802   HHVM_ME(Imagick, blackThresholdImage);
3803   HHVM_ME(Imagick, blurImage);
3804   HHVM_ME(Imagick, borderImage);
3805   HHVM_ME(Imagick, charcoalImage);
3806   HHVM_ME(Imagick, chopImage);
3807   HHVM_ME(Imagick, clear);
3808   HHVM_ME(Imagick, clipImage);
3809   HHVM_ME(Imagick, clipPathImage);
3810   HHVM_ME(Imagick, __clone);
3811   HHVM_ME(Imagick, clutImage);
3812   HHVM_ME(Imagick, coalesceImages);
3813   HHVM_ME(Imagick, colorFloodfillImage);
3814   HHVM_ME(Imagick, colorizeImage);
3815   HHVM_ME(Imagick, combineImages);
3816   HHVM_ME(Imagick, commentImage);
3817   HHVM_ME(Imagick, compareImageChannels);
3818   HHVM_ME(Imagick, compareImageLayers);
3819   HHVM_ME(Imagick, compareImages);
3820   HHVM_ME(Imagick, compositeImage);
3821   HHVM_ME(Imagick, __construct);
3822   HHVM_ME(Imagick, contrastImage);
3823   HHVM_ME(Imagick, contrastStretchImage);
3824   HHVM_ME(Imagick, convolveImage);
3825   HHVM_ME(Imagick, cropImage);
3826   HHVM_ME(Imagick, cropThumbnailImage);
3827   HHVM_ME(Imagick, cycleColormapImage);
3828   HHVM_ME(Imagick, decipherImage);
3829   HHVM_ME(Imagick, deconstructImages);
3830   HHVM_ME(Imagick, deleteImageArtifact);
3831   HHVM_ME(Imagick, deskewImage);
3832   HHVM_ME(Imagick, despeckleImage);
3833   HHVM_ME(Imagick, destroy);
3834   HHVM_ME(Imagick, displayImage);
3835   HHVM_ME(Imagick, displayImages);
3836   HHVM_ME(Imagick, distortImage);
3837   HHVM_ME(Imagick, drawImage);
3838   HHVM_ME(Imagick, edgeImage);
3839   HHVM_ME(Imagick, embossImage);
3840   HHVM_ME(Imagick, encipherImage);
3841   HHVM_ME(Imagick, enhanceImage);
3842   HHVM_ME(Imagick, equalizeImage);
3843   HHVM_ME(Imagick, evaluateImage);
3844   HHVM_ME(Imagick, exportImagePixels);
3845   HHVM_ME(Imagick, extentImage);
3846   HHVM_ME(Imagick, flattenImages);
3847   HHVM_ME(Imagick, flipImage);
3848   HHVM_ME(Imagick, floodFillPaintImage);
3849   HHVM_ME(Imagick, flopImage);
3850   HHVM_ME(Imagick, frameImage);
3851   HHVM_ME(Imagick, functionImage);
3852   HHVM_ME(Imagick, fxImage);
3853   HHVM_ME(Imagick, gammaImage);
3854   HHVM_ME(Imagick, gaussianBlurImage);
3855   HHVM_ME(Imagick, getColorspace);
3856   HHVM_ME(Imagick, getCompression);
3857   HHVM_ME(Imagick, getCompressionQuality);
3858   HHVM_STATIC_ME(Imagick, getCopyright);
3859   HHVM_ME(Imagick, getFilename);
3860   HHVM_ME(Imagick, getFont);
3861   HHVM_ME(Imagick, getFormat);
3862   HHVM_ME(Imagick, getGravity);
3863   HHVM_STATIC_ME(Imagick, getHomeURL);
3864   HHVM_ME(Imagick, getImage);
3865   HHVM_ME(Imagick, getImageAlphaChannel);
3866   HHVM_ME(Imagick, getImageArtifact);
3867   HHVM_ME(Imagick, getImageBackgroundColor);
3868   HHVM_ME(Imagick, getImageBlob);
3869   HHVM_ME(Imagick, getImageBluePrimary);
3870   HHVM_ME(Imagick, getImageBorderColor);
3871   HHVM_ME(Imagick, getImageChannelDepth);
3872   HHVM_ME(Imagick, getImageChannelDistortion);
3873   HHVM_ME(Imagick, getImageChannelDistortions);
3874   HHVM_ME(Imagick, getImageChannelExtrema);
3875   HHVM_ME(Imagick, getImageChannelKurtosis);
3876   HHVM_ME(Imagick, getImageChannelMean);
3877   HHVM_ME(Imagick, getImageChannelRange);
3878   HHVM_ME(Imagick, getImageChannelStatistics);
3879   HHVM_ME(Imagick, getImageClipMask);
3880   HHVM_ME(Imagick, getImageColormapColor);
3881   HHVM_ME(Imagick, getImageColors);
3882   HHVM_ME(Imagick, getImageColorspace);
3883   HHVM_ME(Imagick, getImageCompose);
3884   HHVM_ME(Imagick, getImageCompression);
3885   HHVM_ME(Imagick, getImageDelay);
3886   HHVM_ME(Imagick, getImageDepth);
3887   HHVM_ME(Imagick, getImageDispose);
3888   HHVM_ME(Imagick, getImageDistortion);
3889   HHVM_ME(Imagick, getImageExtrema);
3890   HHVM_ME(Imagick, getImageFilename);
3891   HHVM_ME(Imagick, getImageFormat);
3892   HHVM_ME(Imagick, getImageGamma);
3893   HHVM_ME(Imagick, getImageGeometry);
3894   HHVM_ME(Imagick, getImageGravity);
3895   HHVM_ME(Imagick, getImageGreenPrimary);
3896   HHVM_ME(Imagick, getImageHeight);
3897   HHVM_ME(Imagick, getImageHistogram);
3898   HHVM_ME(Imagick, getImageIndex);
3899   HHVM_ME(Imagick, getImageInterlaceScheme);
3900   HHVM_ME(Imagick, getImageInterpolateMethod);
3901   HHVM_ME(Imagick, getImageIterations);
3902   HHVM_ME(Imagick, getImageLength);
3903   HHVM_ME(Imagick, getImageMatte);
3904   HHVM_ME(Imagick, getImageMatteColor);
3905   HHVM_ME(Imagick, getImageMimeType);
3906   HHVM_ME(Imagick, getImageOrientation);
3907   HHVM_ME(Imagick, getImagePage);
3908   HHVM_ME(Imagick, getImagePixelColor);
3909   HHVM_ME(Imagick, getImageProfile);
3910   HHVM_ME(Imagick, getImageProfiles);
3911   HHVM_ME(Imagick, getImageProperties);
3912   HHVM_ME(Imagick, getImageProperty);
3913   HHVM_ME(Imagick, getImageRedPrimary);
3914   HHVM_ME(Imagick, getImageRegion);
3915   HHVM_ME(Imagick, getImageRenderingIntent);
3916   HHVM_ME(Imagick, getImageResolution);
3917   HHVM_ME(Imagick, getImagesBlob);
3918   HHVM_ME(Imagick, getImageScene);
3919   HHVM_ME(Imagick, getImageSignature);
3920   HHVM_ME(Imagick, getImageSize);
3921   HHVM_ME(Imagick, getImageTicksPerSecond);
3922   HHVM_ME(Imagick, getImageTotalInkDensity);
3923   HHVM_ME(Imagick, getImageType);
3924   HHVM_ME(Imagick, getImageUnits);
3925   HHVM_ME(Imagick, getImageVirtualPixelMethod);
3926   HHVM_ME(Imagick, getImageWhitePoint);
3927   HHVM_ME(Imagick, getImageWidth);
3928   HHVM_ME(Imagick, getInterlaceScheme);
3929   HHVM_ME(Imagick, getIteratorIndex);
3930   HHVM_ME(Imagick, getNumberImages);
3931   HHVM_ME(Imagick, getOption);
3932   HHVM_STATIC_ME(Imagick, getPackageName);
3933   HHVM_ME(Imagick, getPage);
3934   HHVM_ME(Imagick, getPixelIterator);
3935   HHVM_ME(Imagick, getPixelRegionIterator);
3936   HHVM_ME(Imagick, getPointSize);
3937   HHVM_STATIC_ME(Imagick, getQuantumDepth);
3938   HHVM_STATIC_ME(Imagick, getQuantumRange);
3939   HHVM_STATIC_ME(Imagick, getReleaseDate);
3940   HHVM_STATIC_ME(Imagick, getResource);
3941   HHVM_STATIC_ME(Imagick, getResourceLimit);
3942   HHVM_ME(Imagick, getSamplingFactors);
3943   HHVM_ME(Imagick, getSize);
3944   HHVM_ME(Imagick, getSizeOffset);
3945   HHVM_STATIC_ME(Imagick, getVersion);
3946   HHVM_ME(Imagick, haldClutImage);
3947   HHVM_ME(Imagick, hasNextImage);
3948   HHVM_ME(Imagick, hasPreviousImage);
3949   HHVM_ME(Imagick, identifyImage);
3950   HHVM_ME(Imagick, implodeImage);
3951   HHVM_ME(Imagick, importImagePixels);
3952   HHVM_ME(Imagick, labelImage);
3953   HHVM_ME(Imagick, levelImage);
3954   HHVM_ME(Imagick, linearStretchImage);
3955   HHVM_ME(Imagick, liquidRescaleImage);
3956   HHVM_ME(Imagick, magnifyImage);
3957   HHVM_ME(Imagick, mapImage);
3958   HHVM_ME(Imagick, matteFloodfillImage);
3959   HHVM_ME(Imagick, medianFilterImage);
3960   HHVM_ME(Imagick, mergeImageLayers);
3961   HHVM_ME(Imagick, minifyImage);
3962   HHVM_ME(Imagick, modulateImage);
3963   HHVM_ME(Imagick, montageImage);
3964   HHVM_ME(Imagick, morphImages);
3965   HHVM_ME(Imagick, mosaicImages);
3966   HHVM_ME(Imagick, motionBlurImage);
3967   HHVM_ME(Imagick, negateImage);
3968   HHVM_ME(Imagick, newImage);
3969   HHVM_ME(Imagick, newPseudoImage);
3970   HHVM_ME(Imagick, nextImage);
3971   HHVM_ME(Imagick, normalizeImage);
3972   HHVM_ME(Imagick, oilPaintImage);
3973   HHVM_ME(Imagick, opaquePaintImage);
3974   HHVM_ME(Imagick, optimizeImageLayers);
3975   HHVM_ME(Imagick, orderedPosterizeImage);
3976   HHVM_ME(Imagick, paintFloodfillImage);
3977   HHVM_ME(Imagick, paintOpaqueImage);
3978   HHVM_ME(Imagick, paintTransparentImage);
3979   HHVM_ME(Imagick, pingImage);
3980   HHVM_ME(Imagick, pingImageBlob);
3981   HHVM_ME(Imagick, pingImageFile);
3982   HHVM_ME(Imagick, polaroidImage);
3983   HHVM_ME(Imagick, posterizeImage);
3984   HHVM_ME(Imagick, previewImages);
3985   HHVM_ME(Imagick, previousImage);
3986   HHVM_ME(Imagick, profileImage);
3987   HHVM_ME(Imagick, quantizeImage);
3988   HHVM_ME(Imagick, quantizeImages);
3989   HHVM_ME(Imagick, queryFontMetrics);
3990   HHVM_STATIC_ME(Imagick, queryFonts);
3991   HHVM_STATIC_ME(Imagick, queryFormats);
3992   HHVM_ME(Imagick, radialBlurImage);
3993   HHVM_ME(Imagick, raiseImage);
3994   HHVM_ME(Imagick, randomThresholdImage);
3995   HHVM_ME(Imagick, readImage);
3996   HHVM_ME(Imagick, readImageBlob);
3997   HHVM_ME(Imagick, readImageFile);
3998   HHVM_ME(Imagick, readImages);
3999   HHVM_ME(Imagick, recolorImage);
4000   HHVM_ME(Imagick, reduceNoiseImage);
4001   HHVM_ME(Imagick, remapImage);
4002   HHVM_ME(Imagick, removeImage);
4003   HHVM_ME(Imagick, removeImageProfile);
4004   HHVM_ME(Imagick, resampleImage);
4005   HHVM_ME(Imagick, resetImagePage);
4006   HHVM_ME(Imagick, resizeImage);
4007   HHVM_ME(Imagick, rollImage);
4008   HHVM_ME(Imagick, rotateImage);
4009   HHVM_ME(Imagick, roundCorners);
4010   HHVM_ME(Imagick, roundCornersImage);
4011   HHVM_ME(Imagick, sampleImage);
4012   HHVM_ME(Imagick, scaleImage);
4013   HHVM_ME(Imagick, segmentImage);
4014   HHVM_ME(Imagick, separateImageChannel);
4015   HHVM_ME(Imagick, sepiaToneImage);
4016   HHVM_ME(Imagick, setBackgroundColor);
4017   HHVM_ME(Imagick, setColorspace);
4018   HHVM_ME(Imagick, setCompression);
4019   HHVM_ME(Imagick, setCompressionQuality);
4020   HHVM_ME(Imagick, setFilename);
4021   HHVM_ME(Imagick, setFirstIterator);
4022   HHVM_ME(Imagick, setFont);
4023   HHVM_ME(Imagick, setFormat);
4024   HHVM_ME(Imagick, setGravity);
4025   HHVM_ME(Imagick, setImage);
4026   HHVM_ME(Imagick, setImageAlphaChannel);
4027   HHVM_ME(Imagick, setImageArtifact);
4028   HHVM_ME(Imagick, setImageBackgroundColor);
4029   HHVM_ME(Imagick, setImageBias);
4030   HHVM_ME(Imagick, setImageBluePrimary);
4031   HHVM_ME(Imagick, setImageBorderColor);
4032   HHVM_ME(Imagick, setImageChannelDepth);
4033   HHVM_ME(Imagick, setImageClipMask);
4034   HHVM_ME(Imagick, setImageColormapColor);
4035   HHVM_ME(Imagick, setImageColorspace);
4036   HHVM_ME(Imagick, setImageCompose);
4037   HHVM_ME(Imagick, setImageCompression);
4038   HHVM_ME(Imagick, setImageCompressionQuality);
4039   HHVM_ME(Imagick, setImageDelay);
4040   HHVM_ME(Imagick, setImageDepth);
4041   HHVM_ME(Imagick, setImageDispose);
4042   HHVM_ME(Imagick, setImageExtent);
4043   HHVM_ME(Imagick, setImageFilename);
4044   HHVM_ME(Imagick, setImageFormat);
4045   HHVM_ME(Imagick, setImageGamma);
4046   HHVM_ME(Imagick, setImageGravity);
4047   HHVM_ME(Imagick, setImageGreenPrimary);
4048   HHVM_ME(Imagick, setImageIndex);
4049   HHVM_ME(Imagick, setImageInterlaceScheme);
4050   HHVM_ME(Imagick, setImageInterpolateMethod);
4051   HHVM_ME(Imagick, setImageIterations);
4052   HHVM_ME(Imagick, setImageMatte);
4053   HHVM_ME(Imagick, setImageMatteColor);
4054   HHVM_ME(Imagick, setImageOpacity);
4055   HHVM_ME(Imagick, setImageOrientation);
4056   HHVM_ME(Imagick, setImagePage);
4057   HHVM_ME(Imagick, setImageProfile);
4058   HHVM_ME(Imagick, setImageProperty);
4059   HHVM_ME(Imagick, setImageRedPrimary);
4060   HHVM_ME(Imagick, setImageRenderingIntent);
4061   HHVM_ME(Imagick, setImageResolution);
4062   HHVM_ME(Imagick, setImageScene);
4063   HHVM_ME(Imagick, setImageTicksPerSecond);
4064   HHVM_ME(Imagick, setImageType);
4065   HHVM_ME(Imagick, setImageUnits);
4066   HHVM_ME(Imagick, setImageVirtualPixelMethod);
4067   HHVM_ME(Imagick, setImageWhitePoint);
4068   HHVM_ME(Imagick, setInterlaceScheme);
4069   HHVM_ME(Imagick, setIteratorIndex);
4070   HHVM_ME(Imagick, setLastIterator);
4071   HHVM_ME(Imagick, setOption);
4072   HHVM_ME(Imagick, setPage);
4073   HHVM_ME(Imagick, setPointSize);
4074   HHVM_ME(Imagick, setResolution);
4075   HHVM_STATIC_ME(Imagick, setResourceLimit);
4076   HHVM_ME(Imagick, setSamplingFactors);
4077   HHVM_ME(Imagick, setSize);
4078   HHVM_ME(Imagick, setSizeOffset);
4079   HHVM_ME(Imagick, setType);
4080   HHVM_ME(Imagick, shadeImage);
4081   HHVM_ME(Imagick, shadowImage);
4082   HHVM_ME(Imagick, sharpenImage);
4083   HHVM_ME(Imagick, shaveImage);
4084   HHVM_ME(Imagick, shearImage);
4085   HHVM_ME(Imagick, sigmoidalContrastImage);
4086   HHVM_ME(Imagick, sketchImage);
4087   HHVM_ME(Imagick, solarizeImage);
4088   HHVM_ME(Imagick, sparseColorImage);
4089   HHVM_ME(Imagick, spliceImage);
4090   HHVM_ME(Imagick, spreadImage);
4091   HHVM_ME(Imagick, steganoImage);
4092   HHVM_ME(Imagick, stereoImage);
4093   HHVM_ME(Imagick, stripImage);
4094   HHVM_ME(Imagick, swirlImage);
4095   HHVM_ME(Imagick, textureImage);
4096   HHVM_ME(Imagick, thresholdImage);
4097   HHVM_ME(Imagick, thumbnailImage);
4098   HHVM_ME(Imagick, tintImage);
4099   HHVM_ME(Imagick, transformImage);
4100   HHVM_ME(Imagick, transparentPaintImage);
4101   HHVM_ME(Imagick, transposeImage);
4102   HHVM_ME(Imagick, transverseImage);
4103   HHVM_ME(Imagick, trimImage);
4104   HHVM_ME(Imagick, uniqueImageColors);
4105   HHVM_ME(Imagick, unsharpMaskImage);
4106   HHVM_ME(Imagick, vignetteImage);
4107   HHVM_ME(Imagick, waveImage);
4108   HHVM_ME(Imagick, whiteThresholdImage);
4109   HHVM_ME(Imagick, writeImage);
4110   HHVM_ME(Imagick, writeImageFile);
4111   HHVM_ME(Imagick, writeImages);
4112   HHVM_ME(Imagick, writeImagesFile);
4113   // Countable interface
4114   HHVM_ME(Imagick, count);
4115   // Iterator interface
4116   HHVM_ME(Imagick, current);
4117   HHVM_ME(Imagick, key);
4118   HHVM_ME(Imagick, next);
4119   HHVM_ME(Imagick, rewind);
4120   HHVM_ME(Imagick, valid);
4121 }
4122
4123 //////////////////////////////////////////////////////////////////////////////
4124 } // namespace HPHP