granicus.if.org Git - imagemagick/blob - Magick++/lib/Image.cpp

   1 // This may look like C code, but it is really -*- C++ -*-
   2 //
   3 // Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
   4 //
   5 // Implementation of Image
   6 //
   7
   8 #define MAGICKCORE_IMPLEMENTATION  1
   9 #define MAGICK_PLUSPLUS_IMPLEMENTATION 1
  10
  11 #include "Magick++/Include.h"
  12 #include <cstdlib>
  13 #include <string>
  14 #include <string.h>
  15 #include <errno.h>
  16 #include <math.h>
  17
  18 using namespace std;
  19
  20 #include "Magick++/Image.h"
  21 #include "Magick++/Functions.h"
  22 #include "Magick++/Pixels.h"
  23 #include "Magick++/Options.h"
  24 #include "Magick++/ImageRef.h"
  25
  26 #define AbsoluteValue(x)  ((x) < 0 ? -(x) : (x))
  27 #define MagickPI  3.14159265358979323846264338327950288419716939937510
  28 #define DegreesToRadians(x)  (MagickPI*(x)/180.0)
  29
  30 MagickPPExport const char *Magick::borderGeometryDefault="6x6+0+0";
  31 MagickPPExport const char *Magick::frameGeometryDefault="25x25+6+6";
  32 MagickPPExport const char *Magick::raiseGeometryDefault="6x6+0+0";
  33
  34 MagickPPExport int Magick::operator == (const Magick::Image &left_,
  35   const Magick::Image &right_)
  36 {
  37   // If image pixels and signature are the same, then the image is identical
  38   return((left_.rows() == right_.rows()) &&
  39     (left_.columns() == right_.columns()) &&
  40     (left_.signature() == right_.signature()));
  41 }
  42
  43 MagickPPExport int Magick::operator != (const Magick::Image &left_,
  44   const Magick::Image &right_)
  45 {
  46   return(!(left_ == right_));
  47 }
  48
  49 MagickPPExport int Magick::operator > (const Magick::Image &left_,
  50   const Magick::Image &right_)
  51 {
  52   return(!(left_ < right_) && (left_ != right_));
  53 }
  54
  55 MagickPPExport int Magick::operator < (const Magick::Image &left_,
  56   const Magick::Image &right_)
  57 {
  58   // If image pixels are less, then image is smaller
  59   return((left_.rows() * left_.columns()) <
  60     (right_.rows() * right_.columns()));
  61 }
  62
  63 MagickPPExport int Magick::operator >= (const Magick::Image &left_,
  64   const Magick::Image &right_)
  65 {
  66   return((left_ > right_) || (left_ == right_));
  67 }
  68
  69 MagickPPExport int Magick::operator <= (const Magick::Image &left_,
  70   const Magick::Image &right_)
  71 {
  72   return((left_ < right_) || ( left_ == right_));
  73 }
  74
  75 Magick::Image::Image(void)
  76   : _imgRef(new ImageRef)
  77 {
  78 }
  79
  80 Magick::Image::Image(const Blob &blob_)
  81   : _imgRef(new ImageRef)
  82 {
  83   try
  84   {
  85     // Initialize, Allocate and Read images
  86     read(blob_);
  87   }
  88   catch(const Warning &/*warning_*/)
  89   {
  90     // FIXME: need a way to report warnings in constructor
  91   }
  92   catch (const Error &/*error_*/)
  93   {
  94     // Release resources
  95     delete _imgRef;
  96     throw;
  97   }
  98 }
  99
 100 Magick::Image::Image(const Blob &blob_,const Geometry &size_)
 101   : _imgRef(new ImageRef)
 102 {
 103   try
 104   {
 105     // Read from Blob
 106     read(blob_, size_);
 107   }
 108   catch(const Warning &/*warning_*/)
 109   {
 110     // FIXME: need a way to report warnings in constructor
 111   }
 112   catch(const Error &/*error_*/)
 113   {
 114     // Release resources
 115     delete _imgRef;
 116     throw;
 117   }
 118 }
 119
 120 Magick::Image::Image(const Blob &blob_,const Geometry &size_,
 121   const size_t depth_)
 122   : _imgRef(new ImageRef)
 123 {
 124   try
 125   {
 126     // Read from Blob
 127     read(blob_,size_,depth_);
 128   }
 129   catch(const Warning &/*warning_*/)
 130   {
 131     // FIXME: need a way to report warnings in constructor
 132   }
 133   catch(const Error &/*error_*/)
 134   {
 135     // Release resources
 136     delete _imgRef;
 137     throw;
 138   }
 139 }
 140
 141 Magick::Image::Image(const Blob &blob_,const Geometry &size_,
 142   const size_t depth_,const std::string &magick_)
 143   : _imgRef(new ImageRef)
 144 {
 145   try
 146   {
 147     // Read from Blob
 148     read(blob_,size_,depth_,magick_);
 149   }
 150   catch(const Warning &/*warning_*/)
 151   {
 152     // FIXME: need a way to report warnings in constructor
 153   }
 154   catch(const Error &/*error_*/)
 155   {
 156     // Release resources
 157     delete _imgRef;
 158     throw;
 159   }
 160 }
 161
 162 Magick::Image::Image(const Blob &blob_,const Geometry &size_,
 163   const std::string &magick_)
 164   : _imgRef(new ImageRef)
 165 {
 166   try
 167   {
 168     // Read from Blob
 169     read(blob_,size_,magick_);
 170   }
 171   catch(const Warning &/*warning_*/)
 172   {
 173     // FIXME: need a way to report warnings in constructor
 174   }
 175   catch(const Error &/*error_*/)
 176   {
 177     // Release resources
 178     delete _imgRef;
 179     throw;
 180   }
 181 }
 182
 183 Magick::Image::Image(const Geometry &size_,const Color &color_)
 184   : _imgRef(new ImageRef)
 185 {
 186   // xc: prefix specifies an X11 color string
 187   std::string imageSpec("xc:");
 188   imageSpec+=color_;
 189
 190   try
 191   {
 192     // Set image size
 193     size(size_);
 194
 195     // Initialize, Allocate and Read images
 196     read(imageSpec);
 197   }
 198   catch(const Warning &/*warning_*/)
 199   {
 200     // FIXME: need a way to report warnings in constructor
 201   }
 202   catch(const Error & /*error_*/)
 203   {
 204     // Release resources
 205     delete _imgRef;
 206     throw;
 207   }
 208 }
 209
 210 Magick::Image::Image(const Image &image_)
 211   : _imgRef(image_._imgRef)
 212 {
 213   Lock(&_imgRef->_mutexLock);
 214
 215   // Increase reference count
 216   ++_imgRef->_refCount;
 217 }
 218
 219 Magick::Image::Image(const size_t width_,const size_t height_,
 220   const std::string &map_,const StorageType type_,const void *pixels_)
 221   : _imgRef(new ImageRef)
 222 {
 223   try
 224   {
 225     read(width_,height_,map_.c_str(),type_,pixels_);
 226   }
 227   catch(const Warning &/*warning_*/)
 228   {
 229     // FIXME: need a way to report warnings in constructor
 230   }
 231   catch(const Error &/*error_*/)
 232   {
 233     // Release resources
 234     delete _imgRef;
 235     throw;
 236   }
 237 }
 238
 239 Magick::Image::Image(const std::string &imageSpec_)
 240   : _imgRef(new ImageRef)
 241 {
 242   try
 243   {
 244     // Initialize, Allocate and Read images
 245     read(imageSpec_);
 246   }
 247   catch(const Warning &/*warning_*/)
 248   {
 249     // FIXME: need a way to report warnings in constructor
 250   }
 251   catch(const Error &/*error_*/)
 252   {
 253     // Release resources
 254     delete _imgRef;
 255     throw;
 256   }
 257 }
 258
 259 Magick::Image::~Image()
 260 {
 261   bool
 262     doDelete=false;
 263
 264   {
 265     Lock(&_imgRef->_mutexLock);
 266     if (--_imgRef->_refCount == 0)
 267       doDelete=true;
 268   }
 269
 270   if (doDelete)
 271     delete _imgRef;
 272
 273   _imgRef=0;
 274 }
 275
 276 Magick::Image& Magick::Image::operator=(const Magick::Image &image_)
 277 {
 278   if(this != &image_)
 279     {
 280       bool
 281         doDelete=false;
 282
 283       {
 284         Lock(&image_._imgRef->_mutexLock);
 285         ++image_._imgRef->_refCount;
 286       }
 287
 288       {
 289         Lock(&_imgRef->_mutexLock);
 290         if (--_imgRef->_refCount == 0)
 291           doDelete=true;
 292       }
 293
 294       if (doDelete)
 295         {
 296           // Delete old image reference with associated image and options.
 297           delete _imgRef;
 298           _imgRef=0;
 299         }
 300       // Use new image reference
 301       _imgRef=image_._imgRef;
 302     }
 303
 304   return(*this);
 305 }
 306
 307 void Magick::Image::adjoin(const bool flag_)
 308 {
 309   modifyImage();
 310   options()->adjoin(flag_);
 311 }
 312
 313 bool Magick::Image::adjoin(void) const
 314 {
 315   return(constOptions()->adjoin());
 316 }
 317
 318 void Magick::Image::alpha(const bool matteFlag_)
 319 {
 320   modifyImage();
 321
 322   // If matte channel is requested, but image doesn't already have a
 323   // matte channel, then create an opaque matte channel.  Likewise, if
 324   // the image already has a matte channel but a matte channel is not
 325   // desired, then set the matte channel to opaque.
 326   GetPPException;
 327   if ((matteFlag_ && !constImage()->alpha_trait) ||
 328       (constImage()->alpha_trait && !matteFlag_))
 329     SetImageAlpha(image(),OpaqueAlpha,&exceptionInfo);
 330   ThrowPPException;
 331
 332   image()->alpha_trait=matteFlag_ ? BlendPixelTrait : UndefinedPixelTrait;
 333 }
 334
 335 bool Magick::Image::alpha(void) const
 336 {
 337   if (constImage()->alpha_trait == BlendPixelTrait)
 338     return(true);
 339   else
 340     return(false);
 341 }
 342
 343 void Magick::Image::alphaColor(const Color &alphaColor_)
 344 {
 345   modifyImage();
 346
 347   if (alphaColor_.isValid())
 348     {
 349       image()->matte_color=alphaColor_;
 350       options()->matteColor(alphaColor_);
 351     }
 352   else
 353     {
 354       // Set to default matte color
 355       Color tmpColor("#BDBDBD");
 356       image()->matte_color=tmpColor;
 357       options()->matteColor(tmpColor);
 358     }
 359 }
 360
 361 Magick::Color Magick::Image::alphaColor(void) const
 362 {
 363   return(Color(ClampToQuantum(constImage()->matte_color.red),
 364     ClampToQuantum(constImage()->matte_color.green),
 365     ClampToQuantum(constImage()->matte_color.blue)));
 366 }
 367
 368 void Magick::Image::antiAlias(const bool flag_)
 369 {
 370   modifyImage();
 371   options()->antiAlias(static_cast<size_t>(flag_));
 372 }
 373
 374 bool Magick::Image::antiAlias(void)
 375 {
 376   return(static_cast<bool>(options()->antiAlias()));
 377 }
 378
 379 void Magick::Image::animationDelay(const size_t delay_)
 380 {
 381   modifyImage();
 382   image()->delay=delay_;
 383 }
 384
 385 size_t Magick::Image::animationDelay(void) const
 386 {
 387   return(constImage()->delay);
 388 }
 389
 390 void Magick::Image::animationIterations(const size_t iterations_)
 391 {
 392   modifyImage();
 393   image()->iterations=iterations_;
 394 }
 395
 396 size_t Magick::Image::animationIterations(void) const
 397 {
 398   return(constImage()->iterations);
 399 }
 400
 401 void Magick::Image::attenuate(const double attenuate_)
 402 {
 403   char
 404     value[MaxTextExtent];
 405
 406   modifyImage();
 407   FormatLocaleString(value,MaxTextExtent,"%.20g",attenuate_);
 408   (void) SetImageArtifact(image(),"attenuate",value);
 409 }
 410
 411 void Magick::Image::backgroundColor(const Color &backgroundColor_)
 412 {
 413   modifyImage();
 414
 415   if (backgroundColor_.isValid())
 416     image()->background_color=backgroundColor_;
 417   else
 418     image()->background_color=Color();
 419
 420   options()->backgroundColor(backgroundColor_);
 421 }
 422
 423 Magick::Color Magick::Image::backgroundColor(void) const
 424 {
 425   return(constOptions()->backgroundColor());
 426 }
 427
 428 void Magick::Image::backgroundTexture(const std::string &backgroundTexture_)
 429 {
 430   modifyImage();
 431   options()->backgroundTexture(backgroundTexture_);
 432 }
 433
 434 std::string Magick::Image::backgroundTexture(void) const
 435 {
 436   return(constOptions()->backgroundTexture());
 437 }
 438
 439 size_t Magick::Image::baseColumns(void) const
 440 {
 441   return(constImage()->magick_columns);
 442 }
 443
 444 std::string Magick::Image::baseFilename(void) const
 445 {
 446   return(std::string(constImage()->magick_filename));
 447 }
 448
 449 size_t Magick::Image::baseRows(void) const
 450 {
 451   return(constImage()->magick_rows);
 452 }
 453
 454 void Magick::Image::blackPointCompensation(const bool flag_)
 455 {
 456   image()->black_point_compensation=(MagickBooleanType) flag_;
 457 }
 458
 459 bool Magick::Image::blackPointCompensation(void) const
 460 {
 461   return(static_cast<bool>(constImage()->black_point_compensation));
 462 }
 463
 464 void Magick::Image::borderColor(const Color &borderColor_)
 465 {
 466   modifyImage();
 467
 468   if (borderColor_.isValid())
 469     image()->border_color=borderColor_;
 470   else
 471     image()->border_color=Color();
 472
 473   options()->borderColor(borderColor_);
 474 }
 475
 476 Magick::Color Magick::Image::borderColor(void) const
 477 {
 478   return(constOptions()->borderColor());
 479 }
 480
 481 Magick::Geometry Magick::Image::boundingBox(void) const
 482 {
 483   RectangleInfo
 484     bbox;
 485
 486   GetPPException;
 487   bbox=GetImageBoundingBox(constImage(),&exceptionInfo);
 488   ThrowPPException;
 489   return(Geometry(bbox));
 490 }
 491
 492 void Magick::Image::boxColor(const Color &boxColor_)
 493 {
 494   modifyImage();
 495   options()->boxColor(boxColor_);
 496 }
 497
 498 Magick::Color Magick::Image::boxColor(void) const
 499 {
 500   return(constOptions()->boxColor());
 501 }
 502
 503 void Magick::Image::channelDepth(const size_t depth_)
 504 {
 505   modifyImage();
 506   GetPPException;
 507   SetImageDepth(image(),depth_,&exceptionInfo);
 508   ThrowPPException;
 509 }
 510
 511 size_t Magick::Image::channelDepth()
 512 {
 513   size_t
 514     channel_depth;
 515
 516   GetPPException;
 517   channel_depth=GetImageDepth(constImage(),&exceptionInfo);
 518   ThrowPPException;
 519   return(channel_depth);
 520 }
 521
 522 size_t Magick::Image::channels() const
 523 {
 524   return(constImage()->number_channels);
 525 }
 526
 527 void Magick::Image::classType(const ClassType class_)
 528 {
 529   if (classType() == PseudoClass && class_ == DirectClass)
 530     {
 531       // Use SyncImage to synchronize the DirectClass pixels with the
 532       // color map and then set to DirectClass type.
 533       modifyImage();
 534       GetPPException;
 535       SyncImage(image(),&exceptionInfo);
 536       ThrowPPException;
 537       image()->colormap=(PixelInfo *)RelinquishMagickMemory(image()->colormap);
 538       image()->storage_class=static_cast<MagickCore::ClassType>(DirectClass);
 539       return;
 540     }
 541
 542   if (classType() == DirectClass && class_ == PseudoClass)
 543     {
 544       // Quantize to create PseudoClass color map
 545       modifyImage();
 546       quantizeColors(MaxColormapSize);
 547       quantize();
 548       image()->storage_class=static_cast<MagickCore::ClassType>(PseudoClass);
 549     }
 550 }
 551
 552 Magick::ClassType Magick::Image::classType(void) const
 553 {
 554   return static_cast<Magick::ClassType>(constImage()->storage_class);
 555 }
 556
 557 void Magick::Image::clipMask(const Magick::Image &clipMask_)
 558 {
 559   modifyImage();
 560
 561   GetPPException;
 562   if (clipMask_.isValid())
 563     SetImageMask(image(),clipMask_.constImage(),&exceptionInfo);
 564   else
 565     SetImageMask(image(),0,&exceptionInfo);
 566   ThrowPPException;
 567 }
 568
 569 Magick::Image Magick::Image::clipMask(void) const
 570 {
 571   MagickCore::Image
 572     *image;
 573
 574   GetPPException;
 575   image=GetImageMask(constImage(),&exceptionInfo);
 576   ThrowPPException;
 577   if (image == (MagickCore::Image *) NULL)
 578     return(Magick::Image());
 579   else
 580     return(Magick::Image(image));
 581 }
 582
 583 void Magick::Image::colorFuzz(const double fuzz_)
 584 {
 585   modifyImage();
 586   image()->fuzz=fuzz_;
 587   options()->colorFuzz(fuzz_);
 588 }
 589
 590 double Magick::Image::colorFuzz(void) const
 591 {
 592   return(constOptions()->colorFuzz());
 593 }
 594
 595 void Magick::Image::colorMapSize(const size_t entries_)
 596 {
 597   if (entries_ >MaxColormapSize)
 598     throwExceptionExplicit(OptionError,
 599       "Colormap entries must not exceed MaxColormapSize");
 600
 601   modifyImage();
 602   GetPPException;
 603   (void) AcquireImageColormap(image(),entries_,&exceptionInfo);
 604   ThrowPPException;
 605 }
 606
 607 size_t Magick::Image::colorMapSize(void) const
 608 {
 609   if (!constImage()->colormap)
 610     throwExceptionExplicit(OptionError,"Image does not contain a colormap");
 611
 612   return(constImage()->colors);
 613 }
 614
 615 void Magick::Image::colorSpace(const ColorspaceType colorSpace_)
 616 {
 617   if (image()->colorspace == colorSpace_)
 618     return;
 619
 620   modifyImage();
 621   GetPPException;
 622   TransformImageColorspace(image(),colorSpace_,&exceptionInfo);
 623   ThrowPPException;
 624 }
 625
 626 Magick::ColorspaceType Magick::Image::colorSpace(void) const
 627 {
 628   return (constImage()->colorspace);
 629 }
 630
 631 void Magick::Image::colorSpaceType(const ColorspaceType colorSpace_)
 632 {
 633   modifyImage();
 634   GetPPException;
 635   SetImageColorspace(image(),colorSpace_,&exceptionInfo);
 636   ThrowPPException;
 637   options()->colorspaceType(colorSpace_);
 638 }
 639
 640 Magick::ColorspaceType Magick::Image::colorSpaceType(void) const
 641 {
 642   return(constOptions()->colorspaceType());
 643 }
 644
 645 size_t Magick::Image::columns(void) const
 646 {
 647   return(constImage()->columns);
 648 }
 649
 650 void Magick::Image::comment(const std::string &comment_)
 651 {
 652   modifyImage();
 653   GetPPException;
 654   SetImageProperty(image(),"Comment",NULL,&exceptionInfo);
 655   if (comment_.length() > 0)
 656     SetImageProperty(image(),"Comment",comment_.c_str(),&exceptionInfo);
 657   ThrowPPException;
 658 }
 659
 660 std::string Magick::Image::comment(void) const
 661 {
 662   const char
 663     *value;
 664
 665   GetPPException;
 666   value=GetImageProperty(constImage(),"Comment",&exceptionInfo);
 667   ThrowPPException;
 668
 669   if (value)
 670     return(std::string(value));
 671
 672   return(std::string()); // Intentionally no exception
 673 }
 674
 675 void Magick::Image::compose(const CompositeOperator compose_)
 676 {
 677   image()->compose=compose_;
 678 }
 679
 680 Magick::CompositeOperator Magick::Image::compose(void) const
 681 {
 682   return(constImage()->compose);
 683 }
 684
 685 void Magick::Image::compressType(const CompressionType compressType_)
 686 {
 687   modifyImage();
 688   image()->compression=compressType_;
 689   options()->compressType(compressType_);
 690 }
 691
 692 Magick::CompressionType Magick::Image::compressType(void) const
 693 {
 694   return(constImage()->compression);
 695 }
 696
 697 void Magick::Image::debug(const bool flag_)
 698 {
 699   modifyImage();
 700   options()->debug(flag_);
 701 }
 702
 703 bool Magick::Image::debug(void) const
 704 {
 705   return(constOptions()->debug());
 706 }
 707
 708 void Magick::Image::density(const Geometry &density_)
 709 {
 710   modifyImage();
 711   options()->density(density_);
 712   if (density_.isValid())
 713     {
 714       image()->resolution.x=density_.width();
 715       if (density_.height() != 0)
 716         image()->resolution.y=density_.height();
 717       else
 718         image()->resolution.y=density_.width();
 719     }
 720   else
 721     {
 722       // Reset to default
 723       image()->resolution.x=0;
 724       image()->resolution.y=0;
 725     }
 726 }
 727
 728 Magick::Geometry Magick::Image::density(void) const
 729 {
 730   if (isValid())
 731     {
 732       ssize_t
 733         x_resolution=72,
 734         y_resolution=72;
 735
 736       if (constImage()->resolution.x > 0.0)
 737         x_resolution=static_cast<ssize_t>(constImage()->resolution.x + 0.5);
 738
 739       if (constImage()->resolution.y > 0.0)
 740         y_resolution=static_cast<ssize_t>(constImage()->resolution.y + 0.5);
 741
 742       return(Geometry(x_resolution,y_resolution));
 743     }
 744
 745   return(constOptions()->density());
 746 }
 747
 748 void Magick::Image::depth(const size_t depth_)
 749 {
 750   size_t
 751     depth = depth_;
 752
 753   if (depth > MAGICKCORE_QUANTUM_DEPTH)
 754     depth=MAGICKCORE_QUANTUM_DEPTH;
 755
 756   modifyImage();
 757   image()->depth=depth;
 758   options()->depth(depth);
 759 }
 760
 761 size_t Magick::Image::depth(void) const
 762 {
 763   return(constImage()->depth);
 764 }
 765
 766 std::string Magick::Image::directory(void) const
 767 {
 768   if (constImage()->directory)
 769     return(std::string(constImage()->directory));
 770
 771   throwExceptionExplicit(CorruptImageWarning,
 772     "Image does not contain a directory");
 773
 774   return(std::string());
 775 }
 776
 777 void Magick::Image::endian(const Magick::EndianType endian_)
 778 {
 779   modifyImage();
 780   options()->endian(endian_);
 781   image()->endian=endian_;
 782 }
 783
 784 Magick::EndianType Magick::Image::endian(void) const
 785 {
 786   return(constImage()->endian);
 787 }
 788
 789 void Magick::Image::exifProfile(const Magick::Blob &exifProfile_)
 790 {
 791   modifyImage();
 792
 793   if (exifProfile_.data() != 0)
 794     {
 795       StringInfo
 796         *exif_profile;
 797
 798       exif_profile=AcquireStringInfo(exifProfile_.length());
 799       SetStringInfoDatum(exif_profile,(unsigned char *) exifProfile_.data());
 800       GetPPException;
 801       (void) SetImageProfile(image(),"exif",exif_profile,&exceptionInfo);
 802       exif_profile=DestroyStringInfo(exif_profile);
 803       ThrowPPException;
 804     }
 805 }
 806
 807 Magick::Blob Magick::Image::exifProfile(void) const
 808 {
 809   const StringInfo
 810     *exif_profile;
 811
 812   exif_profile=GetImageProfile(constImage(),"exif");
 813   if (exif_profile == (StringInfo *) NULL)
 814     return(Blob());
 815   return(Blob(GetStringInfoDatum(exif_profile),
 816     GetStringInfoLength(exif_profile)));
 817 }
 818
 819 void Magick::Image::fileName(const std::string &fileName_)
 820 {
 821   modifyImage();
 822
 823   fileName_.copy(image()->filename,sizeof(image()->filename)-1);
 824   image()->filename[fileName_.length()]=0; // Null terminate
 825
 826   options()->fileName(fileName_);
 827 }
 828
 829 std::string Magick::Image::fileName(void) const
 830 {
 831   return(constOptions()->fileName());
 832 }
 833
 834 MagickCore::MagickSizeType Magick::Image::fileSize(void) const
 835 {
 836   return(GetBlobSize(constImage()));
 837 }
 838
 839 void Magick::Image::fillColor(const Magick::Color &fillColor_)
 840 {
 841   std::string
 842     value;
 843
 844   modifyImage();
 845   options()->fillColor(fillColor_);
 846   value=fillColor_;
 847   artifact("fill",value);
 848 }
 849
 850 Magick::Color Magick::Image::fillColor(void) const
 851 {
 852   return(constOptions()->fillColor());
 853 }
 854
 855 void Magick::Image::fillRule(const Magick::FillRule &fillRule_)
 856 {
 857   modifyImage();
 858   options()->fillRule(fillRule_);
 859 }
 860
 861 Magick::FillRule Magick::Image::fillRule(void) const
 862 {
 863   return constOptions()->fillRule();
 864 }
 865
 866 void Magick::Image::fillPattern(const Image &fillPattern_)
 867 {
 868   modifyImage();
 869   if (fillPattern_.isValid())
 870     options()->fillPattern(fillPattern_.constImage());
 871   else
 872     options()->fillPattern(static_cast<MagickCore::Image*>(NULL));
 873 }
 874
 875 Magick::Image Magick::Image::fillPattern(void) const
 876 {
 877   // FIXME: This is inordinately innefficient
 878   const MagickCore::Image
 879     *tmpTexture;
 880
 881   Image
 882     texture;
 883
 884   tmpTexture=constOptions()->fillPattern();
 885
 886   if (tmpTexture)
 887     {
 888       MagickCore::Image
 889         *image;
 890
 891       GetPPException;
 892       image=CloneImage(tmpTexture,0,0,MagickTrue,&exceptionInfo);
 893       texture.replaceImage(image);
 894       ThrowPPException;
 895     }
 896   return(texture);
 897 }
 898
 899 void Magick::Image::filterType(const Magick::FilterTypes filterType_)
 900 {
 901   modifyImage();
 902   image()->filter=filterType_;
 903 }
 904
 905 Magick::FilterTypes Magick::Image::filterType(void) const
 906 {
 907   return(constImage()->filter);
 908 }
 909
 910 void Magick::Image::font(const std::string &font_)
 911 {
 912   modifyImage();
 913   options()->font(font_);
 914 }
 915
 916 std::string Magick::Image::font(void) const
 917 {
 918   return(constOptions()->font());
 919 }
 920
 921 void Magick::Image::fontPointsize(const double pointSize_)
 922 {
 923   modifyImage();
 924   options()->fontPointsize(pointSize_);
 925 }
 926
 927 double Magick::Image::fontPointsize(void) const
 928 {
 929   return(constOptions()->fontPointsize());
 930 }
 931
 932 std::string Magick::Image::format(void) const
 933 {
 934   const MagickInfo
 935    *magick_info;
 936
 937   GetPPException;
 938   magick_info=GetMagickInfo(constImage()->magick,&exceptionInfo);
 939   ThrowPPException;
 940
 941   if ((magick_info != 0) && (*magick_info->description != '\0'))
 942     return(std::string(magick_info->description));
 943
 944   throwExceptionExplicit(CorruptImageWarning,"Unrecognized image magick type");
 945   return(std::string());
 946 }
 947
 948 std::string Magick::Image::formatExpression(const std::string expression)
 949 {
 950   char
 951     *text;
 952
 953   std::string
 954     result;
 955
 956   GetPPException;
 957   text=InterpretImageProperties(imageInfo(),image(),expression.c_str(),
 958     &exceptionInfo);
 959   if (text != (char *) NULL)
 960     {
 961       result=std::string(text);
 962       text=DestroyString(text);
 963     }
 964   ThrowPPException;
 965   return(result);
 966 }
 967
 968 double Magick::Image::gamma(void) const
 969 {
 970   return(constImage()->gamma);
 971 }
 972
 973 Magick::Geometry Magick::Image::geometry(void) const
 974 {
 975   if (constImage()->geometry)
 976     return Geometry(constImage()->geometry);
 977
 978   throwExceptionExplicit(OptionWarning,"Image does not contain a geometry");
 979
 980   return(Geometry());
 981 }
 982
 983 void Magick::Image::gifDisposeMethod(
 984   const MagickCore::DisposeType disposeMethod_)
 985 {
 986   modifyImage();
 987   image()->dispose=disposeMethod_;
 988 }
 989
 990 MagickCore::DisposeType Magick::Image::gifDisposeMethod(void) const
 991 {
 992   return(constImage()->dispose);
 993 }
 994
 995 void Magick::Image::highlightColor(const Color color_)
 996 {
 997   std::string
 998     value;
 999
1000   value=color_;
1001   artifact("highlight-color",value);
1002 }
1003
1004 void Magick::Image::iccColorProfile(const Magick::Blob &colorProfile_)
1005 {
1006   profile("icm",colorProfile_);
1007 }
1008
1009 Magick::Blob Magick::Image::iccColorProfile(void) const
1010 {
1011   const StringInfo
1012     *color_profile;
1013
1014   color_profile=GetImageProfile(constImage(),"icc");
1015   if (color_profile == (StringInfo *) NULL)
1016     return(Blob());
1017   return(Blob(GetStringInfoDatum(color_profile),GetStringInfoLength(
1018     color_profile)));
1019 }
1020
1021 void Magick::Image::interlaceType(const Magick::InterlaceType interlace_)
1022 {
1023   modifyImage();
1024   image()->interlace=interlace_;
1025   options()->interlaceType(interlace_);
1026 }
1027
1028 Magick::InterlaceType Magick::Image::interlaceType(void) const
1029 {
1030   return(constImage()->interlace);
1031 }
1032
1033 void Magick::Image::interpolate(const PixelInterpolateMethod interpolate_)
1034 {
1035   modifyImage();
1036   image()->interpolate=interpolate_;
1037 }
1038
1039 Magick::PixelInterpolateMethod Magick::Image::interpolate(void) const
1040 {
1041   return constImage()->interpolate;
1042 }
1043
1044 void Magick::Image::iptcProfile(const Magick::Blob &iptcProfile_)
1045 {
1046   modifyImage();
1047   if (iptcProfile_.data() != 0)
1048     {
1049       StringInfo
1050         *iptc_profile;
1051
1052       iptc_profile=AcquireStringInfo(iptcProfile_.length());
1053       SetStringInfoDatum(iptc_profile,(unsigned char *) iptcProfile_.data());
1054       GetPPException;
1055       (void) SetImageProfile(image(),"iptc",iptc_profile,&exceptionInfo);
1056       iptc_profile=DestroyStringInfo(iptc_profile);
1057       ThrowPPException;
1058     }
1059 }
1060
1061 Magick::Blob Magick::Image::iptcProfile(void) const
1062 {
1063   const StringInfo
1064     *iptc_profile;
1065
1066   iptc_profile=GetImageProfile(constImage(),"iptc");
1067   if (iptc_profile == (StringInfo *) NULL)
1068     return(Blob());
1069   return(Blob(GetStringInfoDatum(iptc_profile),GetStringInfoLength(
1070     iptc_profile)));
1071 }
1072
1073 void Magick::Image::isValid(const bool isValid_)
1074 {
1075   if (!isValid_)
1076     {
1077       delete _imgRef;
1078       _imgRef=new ImageRef;
1079     }
1080   else if (!isValid())
1081     {
1082       // Construct with single-pixel black image to make
1083       // image valid. This is an obvious hack.
1084       size(Geometry(1,1));
1085       read("xc:black");
1086     }
1087 }
1088
1089 bool Magick::Image::isValid(void) const
1090 {
1091   return rows() && columns();
1092 }
1093
1094 void Magick::Image::label(const std::string &label_)
1095 {
1096   modifyImage();
1097   GetPPException;
1098   (void) SetImageProperty(image(),"Label",NULL,&exceptionInfo);
1099   if (label_.length() > 0)
1100     (void) SetImageProperty(image(),"Label",label_.c_str(),&exceptionInfo);
1101   ThrowPPException;
1102 }
1103
1104 std::string Magick::Image::label(void) const
1105 {
1106   const char
1107     *value;
1108
1109   GetPPException;
1110   value=GetImageProperty(constImage(),"Label",&exceptionInfo);
1111   ThrowPPException;
1112
1113   if (value)
1114     return(std::string(value));
1115
1116   return(std::string());
1117 }
1118
1119 void Magick::Image::lowlightColor(const Color color_)
1120 {
1121   std::string
1122     value;
1123
1124   value=color_;
1125   artifact("lowlight-color",value);
1126 }
1127
1128 void Magick::Image::magick(const std::string &magick_)
1129 {
1130   modifyImage();
1131
1132   magick_.copy(image()->magick,sizeof(image()->magick)-1);
1133   image()->magick[magick_.length()]=0;
1134
1135   options()->magick(magick_);
1136 }
1137
1138 std::string Magick::Image::magick(void) const
1139 {
1140   if (*(constImage()->magick) != '\0')
1141     return(std::string(constImage()->magick));
1142
1143   return(constOptions()->magick());
1144 }
1145
1146 double Magick::Image::meanErrorPerPixel(void) const
1147 {
1148   return(constImage()->error.mean_error_per_pixel);
1149 }
1150
1151 void Magick::Image::modulusDepth(const size_t depth_)
1152 {
1153   modifyImage();
1154   GetPPException;
1155   SetImageDepth(image(),depth_,&exceptionInfo);
1156   ThrowPPException;
1157   options()->depth(depth_);
1158 }
1159
1160 size_t Magick::Image::modulusDepth(void) const
1161 {
1162   size_t
1163     depth;
1164
1165   GetPPException;
1166   depth=GetImageDepth(constImage(),&exceptionInfo);
1167   ThrowPPException;
1168   return(depth);
1169 }
1170
1171 void Magick::Image::monochrome(const bool monochromeFlag_)
1172 {
1173   modifyImage();
1174   options()->monochrome(monochromeFlag_);
1175 }
1176
1177 bool Magick::Image::monochrome(void) const
1178 {
1179   return(constOptions()->monochrome());
1180 }
1181
1182 Magick::Geometry Magick::Image::montageGeometry(void) const
1183 {
1184   if (constImage()->montage)
1185     return Magick::Geometry(constImage()->montage);
1186
1187   throwExceptionExplicit(CorruptImageWarning,
1188     "Image does not contain a montage");
1189
1190   return(Magick::Geometry());
1191 }
1192
1193 double Magick::Image::normalizedMaxError(void) const
1194 {
1195   return(constImage()->error.normalized_maximum_error);
1196 }
1197
1198 double Magick::Image::normalizedMeanError(void) const
1199 {
1200   return(constImage()->error.normalized_mean_error);
1201 }
1202
1203 void Magick::Image::orientation(const Magick::OrientationType orientation_)
1204 {
1205   modifyImage();
1206   image()->orientation=orientation_;
1207 }
1208
1209 Magick::OrientationType Magick::Image::orientation(void) const
1210 {
1211   return(constImage()->orientation);
1212 }
1213
1214 void Magick::Image::page(const Magick::Geometry &pageSize_)
1215 {
1216   modifyImage();
1217   options()->page(pageSize_);
1218   image()->page=pageSize_;
1219 }
1220
1221 Magick::Geometry Magick::Image::page(void) const
1222 {
1223   return(Geometry(constImage()->page.width,constImage()->page.height,
1224     AbsoluteValue(constImage()->page.x),AbsoluteValue(constImage()->page.y),
1225     constImage()->page.x < 0 ? true : false,
1226     constImage()->page.y < 0 ? true : false));
1227 }
1228
1229 void Magick::Image::quality(const size_t quality_)
1230 {
1231   modifyImage();
1232   image()->quality=quality_;
1233   options()->quality(quality_);
1234 }
1235
1236 size_t Magick::Image::quality(void) const
1237 {
1238   return(constImage()->quality);
1239 }
1240
1241 void Magick::Image::quantizeColors(const size_t colors_)
1242 {
1243   modifyImage();
1244   options()->quantizeColors(colors_);
1245 }
1246
1247 size_t Magick::Image::quantizeColors(void) const
1248 {
1249   return(constOptions()->quantizeColors());
1250 }
1251
1252 void Magick::Image::quantizeColorSpace(
1253   const Magick::ColorspaceType colorSpace_)
1254 {
1255   modifyImage();
1256   options()->quantizeColorSpace(colorSpace_);
1257 }
1258
1259 Magick::ColorspaceType Magick::Image::quantizeColorSpace(void) const
1260 {
1261   return(constOptions()->quantizeColorSpace());
1262 }
1263
1264 void Magick::Image::quantizeDither(const bool ditherFlag_)
1265 {
1266   modifyImage();
1267   options()->quantizeDither(ditherFlag_);
1268 }
1269
1270 bool Magick::Image::quantizeDither(void) const
1271 {
1272   return(constOptions()->quantizeDither());
1273 }
1274
1275 void Magick::Image::quantizeDitherMethod(const DitherMethod ditherMethod_)
1276 {
1277   modifyImage();
1278   options()->quantizeDitherMethod(ditherMethod_);
1279 }
1280
1281 MagickCore::DitherMethod Magick::Image::quantizeDitherMethod(void) const
1282 {
1283   return(constOptions()->quantizeDitherMethod());
1284 }
1285
1286 void Magick::Image::quantizeTreeDepth(const size_t treeDepth_)
1287 {
1288   modifyImage();
1289   options()->quantizeTreeDepth(treeDepth_);
1290 }
1291
1292 size_t Magick::Image::quantizeTreeDepth() const
1293 {
1294   return(constOptions()->quantizeTreeDepth());
1295 }
1296
1297 void Magick::Image::renderingIntent(
1298   const Magick::RenderingIntent renderingIntent_)
1299 {
1300   modifyImage();
1301   image()->rendering_intent=renderingIntent_;
1302 }
1303
1304 Magick::RenderingIntent Magick::Image::renderingIntent(void) const
1305 {
1306   return(static_cast<Magick::RenderingIntent>(constImage()->rendering_intent));
1307 }
1308
1309 void Magick::Image::resolutionUnits(
1310   const Magick::ResolutionType resolutionUnits_)
1311 {
1312   modifyImage();
1313   image()->units=resolutionUnits_;
1314   options()->resolutionUnits(resolutionUnits_);
1315 }
1316
1317 Magick::ResolutionType Magick::Image::resolutionUnits(void) const
1318 {
1319   return(constOptions()->resolutionUnits());
1320 }
1321
1322 size_t Magick::Image::rows(void) const
1323 {
1324   return(constImage()->rows);
1325 }
1326
1327 void Magick::Image::scene(const size_t scene_)
1328 {
1329   modifyImage();
1330   image()->scene=scene_;
1331 }
1332
1333 size_t Magick::Image::scene(void) const
1334 {
1335   return(constImage()->scene);
1336 }
1337
1338 void Magick::Image::size(const Geometry &geometry_)
1339 {
1340   modifyImage();
1341   options()->size(geometry_);
1342   image()->rows=geometry_.height();
1343   image()->columns=geometry_.width();
1344 }
1345
1346 Magick::Geometry Magick::Image::size(void) const
1347 {
1348   return(Magick::Geometry(constImage()->columns,constImage()->rows));
1349 }
1350
1351 void Magick::Image::strokeAntiAlias(const bool flag_)
1352 {
1353   modifyImage();
1354   options()->strokeAntiAlias(flag_);
1355 }
1356
1357 bool Magick::Image::strokeAntiAlias(void) const
1358 {
1359   return(constOptions()->strokeAntiAlias());
1360 }
1361
1362 void Magick::Image::strokeColor(const Magick::Color &strokeColor_)
1363 {
1364   std::string
1365     value;
1366
1367   modifyImage();
1368   options()->strokeColor(strokeColor_);
1369   value=strokeColor_;
1370   artifact("stroke",value);
1371 }
1372
1373 Magick::Color Magick::Image::strokeColor(void) const
1374 {
1375   return(constOptions()->strokeColor());
1376 }
1377
1378 void Magick::Image::strokeDashArray(const double *strokeDashArray_)
1379 {
1380   modifyImage();
1381   options()->strokeDashArray(strokeDashArray_);
1382 }
1383
1384 const double* Magick::Image::strokeDashArray(void) const
1385 {
1386   return(constOptions()->strokeDashArray());
1387 }
1388
1389 void Magick::Image::strokeDashOffset(const double strokeDashOffset_)
1390 {
1391   modifyImage();
1392   options()->strokeDashOffset(strokeDashOffset_);
1393 }
1394
1395 double Magick::Image::strokeDashOffset(void) const
1396 {
1397   return(constOptions()->strokeDashOffset());
1398 }
1399
1400 void Magick::Image::strokeLineCap(const Magick::LineCap lineCap_)
1401 {
1402   modifyImage();
1403   options()->strokeLineCap(lineCap_);
1404 }
1405
1406 Magick::LineCap Magick::Image::strokeLineCap(void) const
1407 {
1408   return(constOptions()->strokeLineCap());
1409 }
1410
1411 void Magick::Image::strokeLineJoin(const Magick::LineJoin lineJoin_)
1412 {
1413   modifyImage();
1414   options()->strokeLineJoin(lineJoin_);
1415 }
1416
1417 Magick::LineJoin Magick::Image::strokeLineJoin(void) const
1418 {
1419   return(constOptions()->strokeLineJoin());
1420 }
1421
1422 void Magick::Image::strokeMiterLimit(const size_t strokeMiterLimit_)
1423 {
1424   modifyImage();
1425   options()->strokeMiterLimit(strokeMiterLimit_);
1426 }
1427
1428 size_t Magick::Image::strokeMiterLimit(void) const
1429 {
1430   return(constOptions()->strokeMiterLimit());
1431 }
1432
1433 void Magick::Image::strokePattern(const Image &strokePattern_)
1434 {
1435   modifyImage();
1436   if(strokePattern_.isValid())
1437     options()->strokePattern(strokePattern_.constImage());
1438   else
1439     options()->strokePattern(static_cast<MagickCore::Image*>(NULL));
1440 }
1441
1442 Magick::Image Magick::Image::strokePattern(void) const
1443 {
1444   // FIXME: This is inordinately innefficient
1445   const MagickCore::Image
1446     *tmpTexture;
1447
1448   Image
1449     texture;
1450
1451   tmpTexture=constOptions()->strokePattern();
1452
1453   if (tmpTexture)
1454     {
1455       MagickCore::Image
1456         *image;
1457
1458       GetPPException;
1459       image=CloneImage(tmpTexture,0,0,MagickTrue,&exceptionInfo);
1460       texture.replaceImage(image);
1461       ThrowPPException;
1462     }
1463   return(texture);
1464 }
1465
1466 void Magick::Image::strokeWidth(const double strokeWidth_)
1467 {
1468   char
1469     value[MaxTextExtent];
1470
1471   modifyImage();
1472   options()->strokeWidth(strokeWidth_);
1473   FormatLocaleString(value,MaxTextExtent,"%.20g",strokeWidth_);
1474   (void) SetImageArtifact(image(),"strokewidth",value);
1475 }
1476
1477 double Magick::Image::strokeWidth(void) const
1478 {
1479   return(constOptions()->strokeWidth());
1480 }
1481
1482 void Magick::Image::subImage(const size_t subImage_)
1483 {
1484   modifyImage();
1485   options()->subImage(subImage_);
1486 }
1487
1488 size_t Magick::Image::subImage(void) const
1489 {
1490   return(constOptions()->subImage());
1491 }
1492
1493 void Magick::Image::subRange(const size_t subRange_)
1494 {
1495   modifyImage();
1496   options()->subRange(subRange_);
1497 }
1498
1499 size_t Magick::Image::subRange(void) const
1500 {
1501   return(constOptions()->subRange());
1502 }
1503
1504 void Magick::Image::textDirection(DirectionType direction_)
1505 {
1506   modifyImage();
1507   options()->textDirection(direction_);
1508 }
1509
1510 Magick::DirectionType Magick::Image::textDirection(void) const
1511 {
1512   return(constOptions()->textDirection());
1513 }
1514
1515 void Magick::Image::textEncoding(const std::string &encoding_)
1516 {
1517   modifyImage();
1518   options()->textEncoding(encoding_);
1519 }
1520
1521 std::string Magick::Image::textEncoding(void) const
1522 {
1523   return(constOptions()->textEncoding());
1524 }
1525
1526 void Magick::Image::textGravity(GravityType gravity_)
1527 {
1528   modifyImage();
1529   options()->textGravity(gravity_);
1530 }
1531
1532 Magick::GravityType Magick::Image::textGravity(void) const
1533 {
1534   return(constOptions()->textGravity());
1535 }
1536
1537 void Magick::Image::textInterlineSpacing(double spacing_)
1538 {
1539   modifyImage();
1540   options()->textInterlineSpacing(spacing_);
1541 }
1542
1543 double Magick::Image::textInterlineSpacing(void) const
1544 {
1545   return(constOptions()->textInterlineSpacing());
1546 }
1547
1548 void Magick::Image::textInterwordSpacing(double spacing_)
1549 {
1550   modifyImage();
1551   options()->textInterwordSpacing(spacing_);
1552 }
1553
1554 double Magick::Image::textInterwordSpacing(void) const
1555 {
1556   return(constOptions()->textInterwordSpacing());
1557 }
1558
1559 void Magick::Image::textKerning(double kerning_)
1560 {
1561   modifyImage();
1562   options()->textKerning(kerning_);
1563 }
1564
1565 double Magick::Image::textKerning(void) const
1566 {
1567   return(constOptions()->textKerning());
1568 }
1569
1570 size_t Magick::Image::totalColors(void) const
1571 {
1572   size_t
1573     colors;
1574
1575   GetPPException;
1576   colors=GetNumberColors(constImage(),0,&exceptionInfo);
1577   ThrowPPException;
1578   return colors;
1579 }
1580
1581 void Magick::Image::transformRotation(const double angle_)
1582 {
1583   modifyImage();
1584   options()->transformRotation(angle_);
1585 }
1586
1587 void Magick::Image::transformSkewX(const double skewx_)
1588 {
1589   modifyImage();
1590   options()->transformSkewX(skewx_);
1591 }
1592
1593 void Magick::Image::transformSkewY(const double skewy_)
1594 {
1595   modifyImage();
1596   options()->transformSkewY(skewy_);
1597 }
1598
1599 Magick::ImageType Magick::Image::type(void) const
1600 {
1601   if (constOptions()->type() != UndefinedType)
1602     return(constOptions()->type());
1603   else if (constImage()->type != UndefinedType)
1604     return(constImage()->type);
1605   else
1606     return(determineType());
1607 }
1608
1609 void Magick::Image::type(const Magick::ImageType type_)
1610 {
1611   modifyImage();
1612   options()->type(type_);
1613   GetPPException;
1614   SetImageType(image(),type_,&exceptionInfo);
1615   ThrowPPException;
1616 }
1617
1618 void Magick::Image::verbose(const bool verboseFlag_)
1619 {
1620   modifyImage();
1621   options()->verbose(verboseFlag_);
1622 }
1623
1624 bool Magick::Image::verbose(void) const
1625 {
1626   return(constOptions()->verbose());
1627 }
1628
1629 void Magick::Image::view(const std::string &view_)
1630 {
1631   modifyImage();
1632   options()->view(view_);
1633 }
1634
1635 std::string Magick::Image::view(void) const
1636 {
1637   return(constOptions()->view());
1638 }
1639
1640 void Magick::Image::virtualPixelMethod(
1641   const VirtualPixelMethod virtualPixelMethod_)
1642 {
1643   modifyImage();
1644   GetPPException;
1645   SetImageVirtualPixelMethod(image(),virtualPixelMethod_,&exceptionInfo);
1646   ThrowPPException;
1647 }
1648
1649 Magick::VirtualPixelMethod Magick::Image::virtualPixelMethod(void) const
1650 {
1651   return(GetImageVirtualPixelMethod(constImage()));
1652 }
1653
1654 void Magick::Image::x11Display(const std::string &display_)
1655 {
1656   modifyImage();
1657   options()->x11Display(display_);
1658 }
1659
1660 std::string Magick::Image::x11Display(void) const
1661 {
1662   return(constOptions()->x11Display());
1663 }
1664
1665 double Magick::Image::xResolution(void) const
1666 {
1667   return(constImage()->resolution.x);
1668 }
1669
1670 double Magick::Image::yResolution(void) const
1671 {
1672   return(constImage()->resolution.y);
1673 }
1674
1675 void Magick::Image::adaptiveBlur(const double radius_,const double sigma_)
1676 {
1677   MagickCore::Image
1678     *newImage;
1679
1680   GetPPException;
1681   newImage=AdaptiveBlurImage(constImage(),radius_,sigma_,&exceptionInfo);
1682   replaceImage(newImage);
1683   ThrowPPException;
1684 }
1685
1686 void Magick::Image::adaptiveResize(const Geometry &geometry_)
1687 {
1688   MagickCore::Image
1689     *newImage;
1690
1691   size_t
1692     height=rows(),
1693     width=columns();
1694
1695   ssize_t
1696     x=0,
1697     y=0;
1698
1699   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
1700     &height);
1701
1702   GetPPException;
1703   newImage=AdaptiveResizeImage(constImage(),width,height,&exceptionInfo);
1704   replaceImage(newImage);
1705   ThrowPPException;
1706 }
1707
1708 void Magick::Image::adaptiveSharpen(const double radius_,const double sigma_)
1709 {
1710   MagickCore::Image
1711     *newImage;
1712
1713   GetPPException;
1714   newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,&exceptionInfo);
1715   replaceImage(newImage);
1716   ThrowPPException;
1717 }
1718
1719 void Magick::Image::adaptiveSharpenChannel(const ChannelType channel_,
1720   const double radius_,const double sigma_ )
1721 {
1722   MagickCore::Image
1723     *newImage;
1724
1725   GetPPException;
1726   SetPPChannelMask(channel_);
1727   newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,&exceptionInfo);
1728   RestorePPChannelMask;
1729   replaceImage(newImage);
1730   ThrowPPException;
1731 }
1732
1733 void Magick::Image::adaptiveThreshold(const size_t width_,const size_t height_,
1734   const ssize_t offset_)
1735 {
1736
1737   MagickCore::Image
1738     *newImage;
1739
1740   GetPPException;
1741   newImage=AdaptiveThresholdImage(constImage(),width_,height_,offset_,
1742     &exceptionInfo);
1743   replaceImage(newImage);
1744   ThrowPPException;
1745 }
1746
1747 void Magick::Image::addNoise(const NoiseType noiseType_)
1748 {
1749   MagickCore::Image
1750     *newImage;
1751
1752   GetPPException;
1753   newImage=AddNoiseImage(constImage(),noiseType_,1.0,&exceptionInfo);
1754   replaceImage(newImage);
1755   ThrowPPException;
1756 }
1757
1758 void Magick::Image::addNoiseChannel(const ChannelType channel_,
1759   const NoiseType noiseType_)
1760 {
1761   MagickCore::Image
1762     *newImage;
1763
1764   GetPPException;
1765   SetPPChannelMask(channel_);
1766   newImage=AddNoiseImage(constImage(),noiseType_,1.0,&exceptionInfo);
1767   RestorePPChannelMask;
1768   replaceImage(newImage);
1769   ThrowPPException;
1770 }
1771
1772 void Magick::Image::affineTransform(const DrawableAffine &affine_)
1773 {
1774   AffineMatrix
1775     _affine;
1776
1777   MagickCore::Image
1778     *newImage;
1779
1780   _affine.sx=affine_.sx();
1781   _affine.sy=affine_.sy();
1782   _affine.rx=affine_.rx();
1783   _affine.ry=affine_.ry();
1784   _affine.tx=affine_.tx();
1785   _affine.ty=affine_.ty();
1786
1787   GetPPException;
1788   newImage=AffineTransformImage(constImage(),&_affine,&exceptionInfo);
1789   replaceImage(newImage);
1790   ThrowPPException;
1791 }
1792
1793 void Magick::Image::alpha(const unsigned int alpha_)
1794 {
1795   modifyImage();
1796   GetPPException;
1797   SetImageAlpha(image(),alpha_,&exceptionInfo);
1798   ThrowPPException;
1799 }
1800
1801 void Magick::Image::alphaChannel(AlphaChannelOption alphaOption_)
1802 {
1803   modifyImage();
1804   GetPPException;
1805   SetImageAlphaChannel(image(),alphaOption_,&exceptionInfo);
1806   ThrowPPException;
1807 }
1808
1809 void Magick::Image::alphaFloodfill(const Color &target_,
1810   const unsigned int alpha_,const ssize_t x_,const ssize_t y_,
1811   const Magick::PaintMethod method_)
1812 {
1813   PixelInfo
1814     target;
1815
1816   modifyImage();
1817   GetPixelInfo(constImage(),&target);
1818   target.red=static_cast<PixelInfo>(target_).red;
1819   target.green=static_cast<PixelInfo>(target_).green;
1820   target.blue=static_cast<PixelInfo>(target_).blue;
1821   target.alpha=alpha_;
1822   GetPPException;
1823   SetPPChannelMask(AlphaChannel);
1824   FloodfillPaintImage(image(),options()->drawInfo(),&target,x_,y_,
1825     method_ == FloodfillMethod ? MagickFalse : MagickTrue,&exceptionInfo);
1826   RestorePPChannelMask;
1827   ThrowPPException;
1828 }
1829
1830 void Magick::Image::annotate(const std::string &text_,
1831   const Geometry &location_)
1832 {
1833   annotate(text_,location_,NorthWestGravity,0.0);
1834 }
1835
1836 void Magick::Image::annotate(const std::string &text_,
1837   const Geometry &boundingArea_,const GravityType gravity_)
1838 {
1839   annotate(text_,boundingArea_,gravity_,0.0);
1840 }
1841
1842 void Magick::Image::annotate(const std::string &text_,
1843   const Geometry &boundingArea_,const GravityType gravity_,
1844   const double degrees_)
1845 {
1846   AffineMatrix
1847     oaffine;
1848
1849   char
1850     boundingArea[MaxTextExtent];
1851
1852   DrawInfo
1853     *drawInfo;
1854
1855   modifyImage();
1856
1857   drawInfo=options()->drawInfo();
1858   drawInfo->text=const_cast<char *>(text_.c_str());
1859   drawInfo->geometry=0;
1860
1861   if (boundingArea_.isValid())
1862     {
1863       if (boundingArea_.width() == 0 || boundingArea_.height() == 0)
1864         {
1865           FormatLocaleString(boundingArea,MaxTextExtent,"%+.20g%+.20g",
1866             (double) boundingArea_.xOff(),(double) boundingArea_.yOff());
1867         }
1868       else
1869         {
1870           (void) CopyMagickString(boundingArea,string(boundingArea_).c_str(),
1871             MaxTextExtent);
1872         }
1873       drawInfo->geometry=boundingArea;
1874     }
1875
1876   drawInfo->gravity=gravity_;
1877
1878   oaffine=drawInfo->affine;
1879   if (degrees_ != 0.0)
1880     {
1881        AffineMatrix
1882          affine,
1883          current;
1884
1885        affine.sx=1.0;
1886        affine.rx=0.0;
1887        affine.ry=0.0;
1888        affine.sy=1.0;
1889        affine.tx=0.0;
1890        affine.ty=0.0;
1891
1892        current=drawInfo->affine;
1893        affine.sx=cos(DegreesToRadians(fmod(degrees_,360.0)));
1894        affine.rx=sin(DegreesToRadians(fmod(degrees_,360.0)));
1895        affine.ry=(-sin(DegreesToRadians(fmod(degrees_,360.0))));
1896        affine.sy=cos(DegreesToRadians(fmod(degrees_,360.0)));
1897
1898        drawInfo->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
1899        drawInfo->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
1900        drawInfo->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
1901        drawInfo->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
1902        drawInfo->affine.tx=current.sx*affine.tx+current.ry*affine.ty
1903          +current.tx;
1904     }
1905
1906   GetPPException;
1907   AnnotateImage(image(),drawInfo,&exceptionInfo);
1908
1909   // Restore original values
1910   drawInfo->affine=oaffine;
1911   drawInfo->text=0;
1912   drawInfo->geometry=0;
1913
1914   ThrowPPException;
1915 }
1916
1917 void Magick::Image::annotate(const std::string &text_,
1918   const GravityType gravity_)
1919 {
1920   DrawInfo
1921     *drawInfo;
1922
1923   modifyImage();
1924
1925   drawInfo=options()->drawInfo();
1926   drawInfo->text=const_cast<char *>(text_.c_str());
1927   drawInfo->gravity=gravity_;
1928
1929   GetPPException;
1930   AnnotateImage(image(),drawInfo,&exceptionInfo);
1931
1932   drawInfo->gravity=NorthWestGravity;
1933   drawInfo->text=0;
1934
1935   ThrowPPException;
1936 }
1937
1938 void Magick::Image::artifact(const std::string &name_,const std::string &value_)
1939 {
1940   modifyImage();
1941   (void) SetImageArtifact(image(),name_.c_str(),value_.c_str());
1942 }
1943
1944 std::string Magick::Image::artifact(const std::string &name_)
1945 {
1946   const char
1947     *value;
1948
1949   value=GetImageArtifact(constImage(),name_.c_str());
1950   if (value)
1951     return(std::string(value));
1952   return(std::string());
1953 }
1954
1955 void Magick::Image::attribute(const std::string name_,const std::string value_)
1956 {
1957   modifyImage();
1958   GetPPException;
1959   SetImageProperty(image(),name_.c_str(),value_.c_str(),&exceptionInfo);
1960   ThrowPPException;
1961 }
1962
1963 std::string Magick::Image::attribute(const std::string name_)
1964 {
1965   const char
1966     *value;
1967
1968   GetPPException;
1969   value=GetImageProperty(constImage(),name_.c_str(),&exceptionInfo);
1970   ThrowPPException;
1971
1972   if (value)
1973     return(std::string(value));
1974
1975   return(std::string()); // Intentionally no exception
1976 }
1977
1978 void Magick::Image::autoGamma(void)
1979 {
1980   modifyImage();
1981   GetPPException;
1982   (void) SyncImageSettings(imageInfo(),image(),&exceptionInfo);
1983   (void) AutoGammaImage(image(),&exceptionInfo);
1984   ThrowPPException;
1985 }
1986
1987 void Magick::Image::autoGammaChannel(const ChannelType channel_)
1988 {
1989   modifyImage();
1990   GetPPException;
1991   SetPPChannelMask(channel_);
1992   (void) SyncImageSettings(imageInfo(),image(),&exceptionInfo);
1993   (void) AutoGammaImage(image(),&exceptionInfo);
1994   RestorePPChannelMask;
1995   ThrowPPException;
1996 }
1997
1998 void Magick::Image::autoLevel(void)
1999 {
2000   modifyImage();
2001   GetPPException;
2002   (void) SyncImageSettings(imageInfo(),image(),&exceptionInfo);
2003   (void) AutoLevelImage(image(),&exceptionInfo);
2004   ThrowPPException;
2005 }
2006
2007 void Magick::Image::autoLevelChannel(const ChannelType channel_)
2008 {
2009   modifyImage();
2010   GetPPException;
2011   SetPPChannelMask(channel_);
2012   (void) SyncImageSettings(imageInfo(),image(),&exceptionInfo);
2013   (void) AutoLevelImage(image(),&exceptionInfo);
2014   RestorePPChannelMask;
2015   ThrowPPException;
2016 }
2017
2018 void Magick::Image::autoOrient(void)
2019 {
2020   MagickCore::Image
2021     *newImage;
2022
2023   if (image()->orientation == UndefinedOrientation ||
2024       image()->orientation == TopLeftOrientation)
2025     return;
2026
2027   GetPPException;
2028   (void) SyncImageSettings(imageInfo(),image(),&exceptionInfo);
2029   newImage=AutoOrientImage(constImage(),image()->orientation,&exceptionInfo);
2030   replaceImage(newImage);
2031   ThrowPPException;
2032 }
2033
2034 void Magick::Image::blackThreshold(const std::string &threshold_)
2035 {
2036   modifyImage();
2037   GetPPException;
2038   BlackThresholdImage(image(),threshold_.c_str(),&exceptionInfo);
2039   ThrowPPException;
2040 }
2041
2042 void Magick::Image::blackThresholdChannel(const ChannelType channel_,
2043   const std::string &threshold_)
2044 {
2045   modifyImage();
2046   GetPPException;
2047   SetPPChannelMask(channel_);
2048   BlackThresholdImage(image(),threshold_.c_str(),&exceptionInfo);
2049   RestorePPChannelMask;
2050   ThrowPPException;
2051 }
2052
2053 void Magick::Image::blueShift(const double factor_)
2054 {
2055   MagickCore::Image
2056     *newImage;
2057
2058   GetPPException;
2059   newImage=BlueShiftImage(constImage(),factor_,&exceptionInfo);
2060   replaceImage(newImage);
2061   ThrowPPException;
2062 }
2063
2064 void Magick::Image::blur(const double radius_,const double sigma_)
2065 {
2066   MagickCore::Image
2067     *newImage;
2068
2069   GetPPException;
2070   newImage=BlurImage(constImage(),radius_,sigma_,&exceptionInfo);
2071   replaceImage(newImage);
2072   ThrowPPException;
2073 }
2074
2075 void Magick::Image::blurChannel(const ChannelType channel_,
2076   const double radius_,const double sigma_)
2077 {
2078   MagickCore::Image
2079     *newImage;
2080
2081   GetPPException;
2082   SetPPChannelMask(channel_);
2083   newImage=BlurImage(constImage(),radius_,sigma_,&exceptionInfo);
2084   RestorePPChannelMask;
2085   replaceImage(newImage);
2086   ThrowPPException;
2087 }
2088
2089 void Magick::Image::border(const Geometry &geometry_)
2090 {
2091   MagickCore::Image
2092     *newImage;
2093
2094   RectangleInfo
2095     borderInfo=geometry_;
2096
2097   GetPPException;
2098   newImage=BorderImage(constImage(),&borderInfo,image()->compose,
2099     &exceptionInfo);
2100   replaceImage(newImage);
2101   ThrowPPException;
2102 }
2103
2104 void Magick::Image::brightnessContrast(const double brightness_,
2105   const double contrast_)
2106 {
2107   modifyImage();
2108   GetPPException;
2109   BrightnessContrastImage(image(),brightness_,contrast_,&exceptionInfo);
2110   ThrowPPException;
2111 }
2112
2113 void Magick::Image::brightnessContrastChannel(const ChannelType channel_,
2114   const double brightness_,const double contrast_)
2115 {
2116   modifyImage();
2117   GetPPException;
2118   SetPPChannelMask(channel_);
2119   BrightnessContrastImage(image(),brightness_,contrast_,&exceptionInfo);
2120   RestorePPChannelMask;
2121   ThrowPPException;
2122 }
2123
2124 void Magick::Image::cannyEdge(const double radius_,const double sigma_,
2125   const double lowerPercent_,const double upperPercent_)
2126 {
2127   MagickCore::Image
2128     *newImage;
2129
2130   modifyImage();
2131   GetPPException;
2132   newImage=CannyEdgeImage(constImage(),radius_,sigma_,lowerPercent_,
2133     upperPercent_,&exceptionInfo);
2134   replaceImage(newImage);
2135   ThrowPPException;
2136 }
2137
2138 void Magick::Image::channel(const ChannelType channel_)
2139 {
2140   MagickCore::Image
2141     *newImage;
2142
2143   GetPPException;
2144   newImage=SeparateImage(image(),channel_,&exceptionInfo);
2145   replaceImage(newImage);
2146   ThrowPPException;
2147 }
2148
2149 void Magick::Image::charcoal(const double radius_,const double sigma_)
2150 {
2151   MagickCore::Image
2152     *newImage;
2153
2154   GetPPException;
2155   newImage=CharcoalImage(image(),radius_,sigma_,&exceptionInfo);
2156   replaceImage(newImage);
2157   ThrowPPException;
2158 }
2159
2160 void Magick::Image::chop(const Geometry &geometry_)
2161 {
2162   MagickCore::Image
2163     *newImage;
2164
2165   RectangleInfo
2166     chopInfo=geometry_;
2167
2168   GetPPException;
2169   newImage=ChopImage(image(),&chopInfo,&exceptionInfo);
2170   replaceImage(newImage);
2171   ThrowPPException;
2172 }
2173
2174 void Magick::Image::chromaBluePrimary(const double x_,const double y_)
2175 {
2176   modifyImage();
2177   image()->chromaticity.blue_primary.x=x_;
2178   image()->chromaticity.blue_primary.y=y_;
2179 }
2180
2181 void Magick::Image::chromaBluePrimary(double *x_,double *y_) const
2182 {
2183   *x_=constImage()->chromaticity.blue_primary.x;
2184   *y_=constImage()->chromaticity.blue_primary.y;
2185 }
2186
2187 void Magick::Image::chromaGreenPrimary(const double x_,const double y_)
2188 {
2189   modifyImage();
2190   image()->chromaticity.green_primary.x=x_;
2191   image()->chromaticity.green_primary.y=y_;
2192 }
2193
2194 void Magick::Image::chromaGreenPrimary(double *x_,double *y_) const
2195 {
2196   *x_=constImage()->chromaticity.green_primary.x;
2197   *y_=constImage()->chromaticity.green_primary.y;
2198 }
2199
2200 void Magick::Image::chromaRedPrimary(const double x_,const double y_)
2201 {
2202   modifyImage();
2203   image()->chromaticity.red_primary.x=x_;
2204   image()->chromaticity.red_primary.y=y_;
2205 }
2206
2207 void Magick::Image::chromaRedPrimary(double *x_,double *y_) const
2208 {
2209   *x_=constImage()->chromaticity.red_primary.x;
2210   *y_=constImage()->chromaticity.red_primary.y;
2211 }
2212
2213 void Magick::Image::chromaWhitePoint(const double x_,const double y_)
2214 {
2215   modifyImage();
2216   image()->chromaticity.white_point.x=x_;
2217   image()->chromaticity.white_point.y=y_;
2218 }
2219
2220 void Magick::Image::chromaWhitePoint(double *x_,double *y_) const
2221 {
2222   *x_=constImage()->chromaticity.white_point.x;
2223   *y_=constImage()->chromaticity.white_point.y;
2224 }
2225
2226 void Magick::Image::cdl(const std::string &cdl_)
2227 {
2228   modifyImage();
2229   GetPPException;
2230   (void) ColorDecisionListImage(image(),cdl_.c_str(),&exceptionInfo);
2231   ThrowPPException;
2232 }
2233
2234 void Magick::Image::clamp(void)
2235 {
2236   modifyImage();
2237   GetPPException;
2238   ClampImage(image(),&exceptionInfo);
2239   ThrowPPException;
2240 }
2241
2242 void Magick::Image::clampChannel(const ChannelType channel_)
2243 {
2244   modifyImage();
2245   GetPPException;
2246   SetPPChannelMask(channel_);
2247   ClampImage(image(),&exceptionInfo);
2248   RestorePPChannelMask;
2249   ThrowPPException;
2250 }
2251
2252 void Magick::Image::clip(void)
2253 {
2254   modifyImage();
2255   GetPPException;
2256   ClipImage(image(),&exceptionInfo);
2257   ThrowPPException;
2258 }
2259
2260 void Magick::Image::clipPath(const std::string pathname_,const bool inside_)
2261 {
2262   modifyImage();
2263   GetPPException;
2264   ClipImagePath(image(),pathname_.c_str(),(MagickBooleanType) inside_,
2265     &exceptionInfo);
2266   ThrowPPException;
2267 }
2268
2269 void Magick::Image::clut(const Image &clutImage_,
2270   const PixelInterpolateMethod method)
2271 {
2272   modifyImage();
2273   GetPPException;
2274   ClutImage(image(),clutImage_.constImage(),method,&exceptionInfo);
2275   ThrowPPException;
2276 }
2277
2278 void Magick::Image::clutChannel(const ChannelType channel_,
2279   const Image &clutImage_,const PixelInterpolateMethod method)
2280 {
2281   modifyImage();
2282   GetPPException;
2283   SetPPChannelMask(channel_);
2284   ClutImage(image(),clutImage_.constImage(),method,&exceptionInfo);
2285   RestorePPChannelMask;
2286   ThrowPPException;
2287 }
2288
2289 void Magick::Image::colorize(const unsigned int alpha_,const Color &penColor_)
2290 {
2291   colorize(alpha_,alpha_,alpha_,penColor_);
2292 }
2293
2294 void Magick::Image::colorize(const unsigned int alphaRed_,
2295   const unsigned int alphaGreen_,const unsigned int alphaBlue_,
2296   const Color &penColor_)
2297 {
2298   char
2299     blend[MaxTextExtent];
2300
2301   MagickCore::Image
2302     *newImage;
2303
2304   PixelInfo
2305     pixel,
2306     target;
2307
2308   if (!penColor_.isValid())
2309     throwExceptionExplicit(OptionError,"Pen color argument is invalid");
2310
2311   FormatLocaleString(blend,MaxTextExtent,"%u/%u/%u",alphaRed_,alphaGreen_,
2312     alphaBlue_);
2313
2314   GetPixelInfo(image(),&target);
2315   pixel=static_cast<PixelInfo>(penColor_);
2316   target.red=pixel.red;
2317   target.green=pixel.green;
2318   target.blue=pixel.blue;
2319   target.alpha=pixel.alpha;
2320   GetPPException;
2321   newImage=ColorizeImage(image(),blend,&target,&exceptionInfo);
2322   replaceImage(newImage);
2323   ThrowPPException;
2324 }
2325
2326 void Magick::Image::colorMap(const size_t index_,const Color &color_)
2327 {
2328   MagickCore::Image
2329     *imageptr;
2330
2331   imageptr=image();
2332
2333   if (index_ > (MaxColormapSize-1))
2334     throwExceptionExplicit(OptionError,
2335       "Colormap index must be less than MaxColormapSize");
2336
2337   if (!color_.isValid())
2338     throwExceptionExplicit(OptionError,"Color argument is invalid");
2339
2340   modifyImage();
2341
2342   // Ensure that colormap size is large enough
2343   if (colorMapSize() < (index_+1))
2344     colorMapSize(index_+1);
2345
2346   // Set color at index in colormap
2347   (imageptr->colormap)[index_]=color_;
2348 }
2349
2350 Magick::Color Magick::Image::colorMap(const size_t index_) const
2351 {
2352   if (!constImage()->colormap)
2353     {
2354       throwExceptionExplicit(OptionError,"Image does not contain a colormap");
2355       return(Color());
2356     }
2357
2358   if (index_ > constImage()->colors-1)
2359     throwExceptionExplicit(OptionError,"Index out of range");
2360
2361   return(Magick::Color((constImage()->colormap)[index_]));
2362 }
2363
2364 void Magick::Image::colorMatrix(const size_t order_,
2365   const double *color_matrix_)
2366 {
2367   KernelInfo
2368     *kernel_info;
2369
2370   GetPPException;
2371   kernel_info=AcquireKernelInfo((const char *) NULL);
2372   if (kernel_info != (KernelInfo *) NULL)
2373     {
2374       kernel_info->width=order_;
2375       kernel_info->height=order_;
2376       kernel_info->values=(MagickRealType *) AcquireAlignedMemory(order_,
2377         order_*sizeof(*kernel_info->values));
2378       if (kernel_info->values != (MagickRealType *) NULL)
2379         {
2380           MagickCore::Image
2381             *newImage;
2382
2383           for (ssize_t i=0; i < (ssize_t) (order_*order_); i++)
2384             kernel_info->values[i]=color_matrix_[i];
2385           newImage=ColorMatrixImage(image(),kernel_info,&exceptionInfo);
2386           replaceImage(newImage);
2387         }
2388       kernel_info=DestroyKernelInfo(kernel_info);
2389     }
2390   ThrowPPException;
2391 }
2392
2393 bool Magick::Image::compare(const Image &reference_)
2394 {
2395   bool
2396     status;
2397
2398   Image
2399     ref=reference_;
2400
2401   GetPPException;
2402   modifyImage();
2403   ref.modifyImage();
2404   status=static_cast<bool>(IsImagesEqual(image(),ref.image(),&exceptionInfo));
2405   ThrowPPException;
2406   return(status);
2407 }
2408
2409 double Magick::Image::compare(const Image &reference_,const MetricType metric_)
2410 {
2411   double
2412     distortion=0.0;
2413
2414   GetPPException;
2415   GetImageDistortion(image(),reference_.constImage(),metric_,&distortion,
2416     &exceptionInfo);
2417   ThrowPPException;
2418   return(distortion);
2419 }
2420
2421 double Magick::Image::compareChannel(const ChannelType channel_,
2422   const Image &reference_,const MetricType metric_)
2423 {
2424   double
2425     distortion=0.0;
2426
2427   GetPPException;
2428   SetPPChannelMask(channel_);
2429   GetImageDistortion(image(),reference_.constImage(),metric_,&distortion,
2430     &exceptionInfo);
2431   RestorePPChannelMask;
2432   ThrowPPException;
2433   return(distortion);
2434 }
2435
2436 Magick::Image Magick::Image::compare(const Image &reference_,
2437   const MetricType metric_,double *distortion)
2438 {
2439   MagickCore::Image
2440     *newImage;
2441
2442   GetPPException;
2443   newImage=CompareImages(image(),reference_.constImage(),metric_,distortion,
2444     &exceptionInfo);
2445   ThrowPPException;
2446   if (newImage == (MagickCore::Image *) NULL)
2447     return(Magick::Image());
2448   else
2449     return(Magick::Image(newImage));
2450 }
2451
2452 Magick::Image Magick::Image::compareChannel(const ChannelType channel_,
2453   const Image &reference_,const MetricType metric_,double *distortion)
2454 {
2455   MagickCore::Image
2456     *newImage;
2457
2458   GetPPException;
2459   SetPPChannelMask(channel_);
2460   newImage=CompareImages(image(),reference_.constImage(),metric_,distortion,
2461     &exceptionInfo);
2462   RestorePPChannelMask;
2463   ThrowPPException;
2464   if (newImage == (MagickCore::Image *) NULL)
2465     return(Magick::Image());
2466   else
2467     return(Magick::Image(newImage));
2468 }
2469
2470 void Magick::Image::composite(const Image &compositeImage_,
2471   const Geometry &offset_,const CompositeOperator compose_)
2472 {
2473   size_t
2474     height=rows(),
2475     width=columns();
2476
2477   ssize_t
2478     x=offset_.xOff(),
2479     y=offset_.yOff();
2480
2481   ParseMetaGeometry(static_cast<std::string>(offset_).c_str(),&x,&y,&width,
2482     &height);
2483
2484   modifyImage();
2485   GetPPException;
2486   CompositeImage(image(),compositeImage_.constImage(),compose_,MagickFalse,
2487     x,y,&exceptionInfo);
2488   ThrowPPException;
2489 }
2490
2491 void Magick::Image::composite(const Image &compositeImage_,
2492   const GravityType gravity_,const CompositeOperator compose_)
2493 {
2494   RectangleInfo
2495     geometry;
2496
2497   modifyImage();
2498   SetGeometry(compositeImage_.constImage(),&geometry);
2499   GravityAdjustGeometry(columns(),rows(),gravity_,&geometry);
2500
2501   GetPPException;
2502   CompositeImage(image(),compositeImage_.constImage(),compose_,MagickFalse,
2503     geometry.x,geometry.y,&exceptionInfo);
2504   ThrowPPException;
2505 }
2506
2507 void Magick::Image::composite(const Image &compositeImage_,
2508   const ssize_t xOffset_,const ssize_t yOffset_,
2509   const CompositeOperator compose_)
2510 {
2511   // Image supplied as compositeImage is composited with current image and
2512   // results in updating current image.
2513   modifyImage();
2514   GetPPException;
2515   CompositeImage(image(),compositeImage_.constImage(),compose_,MagickFalse,
2516     xOffset_,yOffset_,&exceptionInfo);
2517   ThrowPPException;
2518 }
2519
2520 void Magick::Image::contrast(const size_t sharpen_)
2521 {
2522   modifyImage();
2523   GetPPException;
2524   ContrastImage(image(),(MagickBooleanType) sharpen_,&exceptionInfo);
2525   ThrowPPException;
2526 }
2527
2528 void Magick::Image::contrastStretch(const double blackPoint_,
2529   const double whitePoint_)
2530 {
2531   modifyImage();
2532   GetPPException;
2533   ContrastStretchImage(image(),blackPoint_,whitePoint_,&exceptionInfo);
2534   ThrowPPException;
2535 }
2536
2537 void Magick::Image::contrastStretchChannel(const ChannelType channel_,
2538   const double blackPoint_,const double whitePoint_)
2539 {
2540   modifyImage();
2541   GetPPException;
2542   SetPPChannelMask(channel_);
2543   ContrastStretchImage(image(),blackPoint_,whitePoint_,&exceptionInfo);
2544   RestorePPChannelMask;
2545   ThrowPPException;
2546 }
2547
2548 void Magick::Image::convolve(const size_t order_,const double *kernel_)
2549 {
2550   KernelInfo
2551     *kernel_info;
2552
2553   GetPPException;
2554   kernel_info=AcquireKernelInfo((const char *) NULL);
2555   kernel_info->width=order_;
2556   kernel_info->height=order_;
2557   kernel_info->values=(MagickRealType *) AcquireAlignedMemory(order_,
2558     order_*sizeof(*kernel_info->values));
2559   if (kernel_info->values != (MagickRealType *) NULL)
2560     {
2561       MagickCore::Image
2562         *newImage;
2563
2564       for (ssize_t i=0; i < (ssize_t) (order_*order_); i++)
2565         kernel_info->values[i]=kernel_[i];
2566       newImage=ConvolveImage(image(),kernel_info,&exceptionInfo);
2567       replaceImage(newImage);
2568     }
2569   kernel_info=DestroyKernelInfo(kernel_info);
2570   ThrowPPException;
2571 }
2572
2573 void Magick::Image::crop(const Geometry &geometry_)
2574 {
2575   MagickCore::Image
2576     *newImage;
2577
2578   RectangleInfo
2579     cropInfo=geometry_;
2580
2581   GetPPException;
2582   newImage=CropImage(constImage(),&cropInfo,&exceptionInfo);
2583   replaceImage(newImage);
2584   ThrowPPException;
2585 }
2586
2587 void Magick::Image::cycleColormap(const ssize_t amount_)
2588 {
2589   modifyImage();
2590   GetPPException;
2591   CycleColormapImage(image(),amount_,&exceptionInfo);
2592   ThrowPPException;
2593 }
2594
2595 void Magick::Image::decipher(const std::string &passphrase_)
2596 {
2597   modifyImage();
2598   GetPPException;
2599   DecipherImage(image(),passphrase_.c_str(),&exceptionInfo);
2600   ThrowPPException;
2601 }
2602
2603 void Magick::Image::defineSet(const std::string &magick_,
2604   const std::string &key_,bool flag_)
2605 {
2606   std::string
2607     definition;
2608
2609   modifyImage();
2610   definition=magick_ + ":" + key_;
2611   if (flag_)
2612     (void) SetImageOption(imageInfo(),definition.c_str(),"");
2613   else
2614     DeleteImageOption(imageInfo(),definition.c_str());
2615 }
2616
2617 bool Magick::Image::defineSet(const std::string &magick_,
2618   const std::string &key_ ) const
2619 {
2620   const char
2621     *option;
2622
2623   std::string
2624     key;
2625
2626   key=magick_ + ":" + key_;
2627   option=GetImageOption(constImageInfo(),key.c_str());
2628   if (option)
2629     return(true);
2630   return(false);
2631 }
2632
2633 void Magick::Image::defineValue(const std::string &magick_,
2634   const std::string &key_,const std::string &value_)
2635 {
2636   std::string
2637     format,
2638     option;
2639
2640   modifyImage();
2641   format=magick_ + ":" + key_;
2642   option=value_;
2643   (void) SetImageOption(imageInfo(),format.c_str(),option.c_str());
2644 }
2645
2646 std::string Magick::Image::defineValue(const std::string &magick_,
2647   const std::string &key_) const
2648 {
2649   const char
2650     *option;
2651
2652   std::string
2653     definition;
2654
2655   definition=magick_ + ":" + key_;
2656   option=GetImageOption(constImageInfo(),definition.c_str());
2657   if (option)
2658     return(std::string(option));
2659   return(std::string());
2660 }
2661
2662 void Magick::Image::deskew(const double threshold_)
2663 {
2664   MagickCore::Image
2665     *newImage;
2666
2667   GetPPException;
2668   newImage=DeskewImage(constImage(),threshold_,&exceptionInfo);
2669   replaceImage(newImage);
2670   ThrowPPException;
2671 }
2672
2673 void Magick::Image::despeckle(void)
2674 {
2675   MagickCore::Image
2676     *newImage;
2677
2678   GetPPException;
2679   newImage=DespeckleImage(constImage(),&exceptionInfo);
2680   replaceImage(newImage);
2681   ThrowPPException;
2682 }
2683
2684 Magick::ImageType Magick::Image::determineType(void) const
2685 {
2686   ImageType
2687     image_type;
2688
2689   GetPPException;
2690   image_type=GetImageType(constImage(),&exceptionInfo);
2691   ThrowPPException;
2692   return(image_type);
2693 }
2694
2695 void Magick::Image::display(void)
2696 {
2697   GetPPException;
2698   DisplayImages(imageInfo(),image(),&exceptionInfo);
2699   ThrowPPException;
2700 }
2701
2702 void Magick::Image::distort(const DistortImageMethod method_,
2703   const size_t numberArguments_,const double *arguments_,const bool bestfit_)
2704 {
2705   MagickCore::Image
2706     *newImage;
2707
2708   GetPPException;
2709   newImage=DistortImage(constImage(), method_,numberArguments_,arguments_,
2710     bestfit_ == true ? MagickTrue : MagickFalse,&exceptionInfo);
2711   replaceImage(newImage);
2712   ThrowPPException;
2713 }
2714
2715 void Magick::Image::draw(const Magick::Drawable &drawable_)
2716 {
2717   DrawingWand
2718     *wand;
2719
2720   modifyImage();
2721
2722   wand=DrawAllocateWand(options()->drawInfo(),image());
2723
2724   if(wand)
2725     {
2726       drawable_.operator()(wand);
2727
2728       DrawRender(wand);
2729
2730       ClonePPDrawException(wand);
2731       wand=DestroyDrawingWand(wand);
2732       ThrowPPDrawException;
2733     }
2734 }
2735
2736 void Magick::Image::draw(const std::list<Magick::Drawable> &drawable_)
2737 {
2738   DrawingWand
2739     *wand;
2740
2741   modifyImage();
2742
2743   wand=DrawAllocateWand(options()->drawInfo(),image());
2744
2745   if(wand)
2746     {
2747       for (std::list<Magick::Drawable>::const_iterator p = drawable_.begin();
2748            p != drawable_.end(); p++ )
2749         {
2750           p->operator()(wand);
2751           if (DrawGetExceptionType(wand) != UndefinedException)
2752             break;
2753         }
2754
2755       if (DrawGetExceptionType(wand) == UndefinedException)
2756         DrawRender(wand);
2757
2758       ClonePPDrawException(wand);
2759       wand=DestroyDrawingWand(wand);
2760       ThrowPPDrawException;
2761     }
2762 }
2763
2764 void Magick::Image::edge(const double radius_)
2765 {
2766   MagickCore::Image
2767     *newImage;
2768
2769   GetPPException;
2770   newImage=EdgeImage(constImage(),radius_,&exceptionInfo);
2771   replaceImage(newImage);
2772   ThrowPPException;
2773 }
2774
2775 void Magick::Image::emboss(const double radius_,const double sigma_)
2776 {
2777   MagickCore::Image
2778     *newImage;
2779
2780   GetPPException;
2781   newImage=EmbossImage(constImage(),radius_,sigma_,&exceptionInfo);
2782   replaceImage(newImage);
2783   ThrowPPException;
2784 }
2785
2786 void Magick::Image::encipher(const std::string &passphrase_)
2787 {
2788   modifyImage();
2789   GetPPException;
2790   EncipherImage(image(),passphrase_.c_str(),&exceptionInfo);
2791   ThrowPPException;
2792 }
2793
2794 void Magick::Image::enhance(void)
2795 {
2796   MagickCore::Image
2797     *newImage;
2798
2799   GetPPException;
2800   newImage=EnhanceImage(constImage(),&exceptionInfo);
2801   replaceImage(newImage);
2802   ThrowPPException;
2803 }
2804
2805 void Magick::Image::equalize(void)
2806 {
2807   modifyImage();
2808   GetPPException;
2809   EqualizeImage(image(),&exceptionInfo);
2810   ThrowPPException;
2811 }
2812
2813 void Magick::Image::erase(void)
2814 {
2815   modifyImage();
2816   GetPPException;
2817   (void) SetImageBackgroundColor(image(),&exceptionInfo);
2818   ThrowPPException;
2819 }
2820
2821 void Magick::Image::extent(const Geometry &geometry_ )
2822 {
2823   MagickCore::Image
2824     *newImage;
2825
2826   RectangleInfo
2827     extentInfo=geometry_;
2828
2829   modifyImage();
2830   extentInfo.x=geometry_.xOff();
2831   extentInfo.y=geometry_.yOff();
2832   GetPPException;
2833   newImage=ExtentImage(image(),&extentInfo,&exceptionInfo);
2834   replaceImage(newImage);
2835   ThrowPPException;
2836 }
2837
2838 void Magick::Image::extent(const Geometry &geometry_,
2839   const Color &backgroundColor_)
2840 {
2841   backgroundColor(backgroundColor_);
2842   extent(geometry_);
2843 }
2844
2845 void Magick::Image::extent(const Geometry &geometry_,
2846   const Color &backgroundColor_,const GravityType gravity_)
2847 {
2848   backgroundColor(backgroundColor_);
2849   extent(geometry_,gravity_);
2850 }
2851
2852 void Magick::Image::extent(const Geometry &geometry_,
2853   const GravityType gravity_)
2854 {
2855   RectangleInfo
2856     geometry;
2857
2858   SetGeometry(image(),&geometry);
2859   geometry.width=geometry_.width();
2860   geometry.height=geometry_.height();
2861   GravityAdjustGeometry(image()->columns,image()->rows,gravity_,&geometry);
2862   extent(geometry);
2863 }
2864
2865 void Magick::Image::flip(void)
2866 {
2867   MagickCore::Image
2868     *newImage;
2869
2870   GetPPException;
2871   newImage=FlipImage(constImage(),&exceptionInfo);
2872   replaceImage(newImage);
2873   ThrowPPException;
2874 }
2875
2876 void Magick::Image::floodFillAlpha(const ssize_t x_,const ssize_t y_,
2877   const unsigned int alpha_,const PaintMethod method_)
2878 {
2879   PixelInfo
2880     pixel,
2881     target;
2882
2883   modifyImage();
2884   GetPixelInfo(image(),&target);
2885   pixel=static_cast<PixelInfo>(pixelColor(x_,y_));
2886   target.red=pixel.red;
2887   target.green=pixel.green;
2888   target.blue=pixel.blue;
2889   target.alpha=alpha_;
2890
2891   GetPPException;
2892   FloodfillPaintImage(image(),options()->drawInfo(),&target,
2893     static_cast<ssize_t>(x_), static_cast<ssize_t>(y_),
2894     method_  == FloodfillMethod ? MagickFalse : MagickTrue,&exceptionInfo);
2895   ThrowPPException;
2896 }
2897
2898 void Magick::Image::floodFillColor(const Geometry &point_,
2899   const Magick::Color &fillColor_)
2900 {
2901   floodFillTexture(point_,Image(Geometry(1,1),fillColor_));
2902 }
2903
2904 void Magick::Image::floodFillColor(const ssize_t x_,const ssize_t y_,
2905   const Magick::Color &fillColor_)
2906 {
2907   floodFillTexture(x_,y_,Image(Geometry(1,1),fillColor_));
2908 }
2909
2910 void Magick::Image::floodFillColor(const Geometry &point_,
2911   const Magick::Color &fillColor_,const Magick::Color &borderColor_)
2912 {
2913   floodFillTexture(point_,Image(Geometry(1,1),fillColor_),borderColor_);
2914 }
2915
2916 void Magick::Image::floodFillColor(const ssize_t x_,const ssize_t y_,
2917   const Magick::Color &fillColor_,const Magick::Color &borderColor_)
2918 {
2919   floodFillTexture(x_,y_,Image(Geometry(1,1),fillColor_),borderColor_);
2920 }
2921
2922 void Magick::Image::floodFillTexture(const Magick::Geometry &point_,
2923   const Magick::Image &texture_)
2924 {
2925   floodFillTexture(point_.xOff(),point_.yOff(),texture_);
2926 }
2927
2928 void Magick::Image::floodFillTexture(const ssize_t x_,const ssize_t y_,
2929   const Magick::Image &texture_)
2930 {
2931   MagickCore::Image
2932     *fillPattern;
2933
2934   Quantum
2935     *p;
2936
2937   modifyImage();
2938
2939   // Set drawing fill pattern
2940   fillPattern=(MagickCore::Image *)NULL;
2941   if (options()->fillPattern() != (MagickCore::Image *)NULL)
2942     {
2943       GetPPException;
2944       fillPattern=CloneImage(options()->fillPattern(),0,0,MagickTrue,
2945         &exceptionInfo);
2946       ThrowPPException;
2947     }
2948   options()->fillPattern(texture_.constImage());
2949
2950   // Get pixel view
2951   Pixels pixels(*this);
2952   // Fill image
2953   p=pixels.get(x_,y_,1,1);
2954
2955   if (p)
2956     {
2957       PixelInfo
2958         target;
2959
2960       GetPixelInfo(constImage(),&target);
2961       target.red=GetPixelRed(constImage(),p);
2962       target.green=GetPixelGreen(constImage(),p);
2963       target.blue=GetPixelBlue(constImage(),p);
2964       GetPPException;
2965       FloodfillPaintImage(image(),options()->drawInfo(),&target,
2966         static_cast<ssize_t>(x_),static_cast<ssize_t>(y_),MagickFalse,
2967         &exceptionInfo);
2968       options()->fillPattern(fillPattern);
2969       ThrowPPException;
2970     }
2971   else
2972     options()->fillPattern(fillPattern);
2973 }
2974
2975 void Magick::Image::floodFillTexture(const Magick::Geometry &point_,
2976   const Magick::Image &texture_,const Magick::Color &borderColor_)
2977 {
2978   floodFillTexture(point_.xOff(),point_.yOff(),texture_,borderColor_);
2979 }
2980
2981 void Magick::Image::floodFillTexture(const ssize_t x_,const ssize_t y_,
2982   const Magick::Image &texture_,const Magick::Color &borderColor_)
2983 {
2984   MagickCore::Image
2985     *fillPattern;
2986
2987   PixelInfo
2988     target;
2989
2990   modifyImage();
2991
2992   // Set drawing fill pattern
2993   fillPattern=(MagickCore::Image *)NULL;
2994   if (options()->fillPattern() != (MagickCore::Image *)NULL)
2995     {
2996       GetPPException;
2997       fillPattern=CloneImage(options()->fillPattern(),0,0,MagickTrue,
2998         &exceptionInfo);
2999       ThrowPPException;
3000     }
3001   options()->fillPattern(texture_.constImage());
3002
3003   GetPixelInfo(constImage(),&target);
3004   target.red=static_cast<PixelInfo>(borderColor_).red;
3005   target.green=static_cast<PixelInfo>(borderColor_).green;
3006   target.blue=static_cast<PixelInfo>(borderColor_).blue;
3007   GetPPException;
3008   FloodfillPaintImage(image(),options()->drawInfo(),&target,
3009     static_cast<ssize_t>(x_),static_cast<ssize_t>(y_),MagickTrue,
3010     &exceptionInfo);
3011   options()->fillPattern(fillPattern);
3012   ThrowPPException;
3013 }
3014
3015 void Magick::Image::flop(void)
3016 {
3017   MagickCore::Image
3018     *newImage;
3019
3020   GetPPException;
3021   newImage=FlopImage(constImage(),&exceptionInfo);
3022   replaceImage(newImage);
3023   ThrowPPException;
3024 }
3025
3026 void Magick::Image::fontTypeMetrics(const std::string &text_,
3027   TypeMetric *metrics)
3028 {
3029   DrawInfo
3030     *drawInfo;
3031
3032   drawInfo=options()->drawInfo();
3033   drawInfo->text=const_cast<char *>(text_.c_str());
3034   GetPPException;
3035   GetTypeMetrics(image(),drawInfo,&(metrics->_typeMetric),&exceptionInfo);
3036   drawInfo->text=0;
3037   ThrowPPException;
3038 }
3039
3040 void Magick::Image::fontTypeMetricsMultiline(const std::string &text_,
3041   TypeMetric *metrics)
3042 {
3043   DrawInfo
3044     *drawInfo;
3045
3046   drawInfo=options()->drawInfo();
3047   drawInfo->text=const_cast<char *>(text_.c_str());
3048   GetPPException;
3049   GetMultilineTypeMetrics(image(),drawInfo,&(metrics->_typeMetric),&exceptionInfo);
3050   drawInfo->text=0;
3051   ThrowPPException;
3052 }
3053
3054 void Magick::Image::frame(const Geometry &geometry_)
3055 {
3056   FrameInfo
3057     info;
3058
3059   MagickCore::Image
3060     *newImage;
3061
3062   info.x=static_cast<ssize_t>(geometry_.width());
3063   info.y=static_cast<ssize_t>(geometry_.height());
3064   info.width=columns() + (static_cast<size_t>(info.x) << 1);
3065   info.height=rows() + (static_cast<size_t>(info.y) << 1);
3066   info.outer_bevel=geometry_.xOff();
3067   info.inner_bevel=geometry_.yOff();
3068
3069   GetPPException;
3070   newImage=FrameImage(constImage(),&info,image()->compose,&exceptionInfo);
3071   replaceImage(newImage);
3072   ThrowPPException;
3073 }
3074
3075 void Magick::Image::frame(const size_t width_,const size_t height_,
3076   const ssize_t outerBevel_,const ssize_t innerBevel_)
3077 {
3078   FrameInfo
3079     info;
3080
3081   MagickCore::Image
3082     *newImage;
3083
3084   info.x=static_cast<ssize_t>(width_);
3085   info.y=static_cast<ssize_t>(height_);
3086   info.width=columns() + (static_cast<size_t>(info.x) << 1);
3087   info.height=rows() + (static_cast<size_t>(info.y) << 1);
3088   info.outer_bevel=static_cast<ssize_t>(outerBevel_);
3089   info.inner_bevel=static_cast<ssize_t>(innerBevel_);
3090
3091   GetPPException;
3092   newImage=FrameImage(constImage(),&info,image()->compose,&exceptionInfo);
3093   replaceImage(newImage);
3094   ThrowPPException;
3095 }
3096
3097 void Magick::Image::fx(const std::string expression_)
3098 {
3099   MagickCore::Image
3100     *newImage;
3101
3102   GetPPException;
3103   newImage=FxImage(constImage(),expression_.c_str(),&exceptionInfo);
3104   replaceImage(newImage);
3105   ThrowPPException;
3106 }
3107
3108 void Magick::Image::fx(const std::string expression_,
3109   const Magick::ChannelType channel_)
3110 {
3111   MagickCore::Image
3112     *newImage;
3113
3114   GetPPException;
3115   SetPPChannelMask(channel_);
3116   newImage=FxImage(constImage(),expression_.c_str(),&exceptionInfo);
3117   RestorePPChannelMask;
3118   replaceImage(newImage);
3119   ThrowPPException;
3120 }
3121
3122 void Magick::Image::gamma(const double gamma_)
3123 {
3124   modifyImage();
3125   GetPPException;
3126   GammaImage(image(),gamma_,&exceptionInfo);
3127   ThrowPPException;
3128 }
3129
3130 void Magick::Image::gamma(const double gammaRed_,const double gammaGreen_,
3131   const double gammaBlue_)
3132 {
3133   char
3134     gamma[MaxTextExtent + 1];
3135
3136   FormatLocaleString(gamma,MaxTextExtent,"%3.6f/%3.6f/%3.6f/",gammaRed_,
3137     gammaGreen_,gammaBlue_);
3138
3139   modifyImage();
3140   GetPPException;
3141   GammaImage(image(),atof(gamma),&exceptionInfo);
3142   ThrowPPException;
3143 }
3144
3145 void Magick::Image::gaussianBlur(const double width_,const double sigma_)
3146 {
3147   MagickCore::Image
3148     *newImage;
3149
3150   GetPPException;
3151   newImage=GaussianBlurImage(constImage(),width_,sigma_,&exceptionInfo);
3152   replaceImage(newImage);
3153   ThrowPPException;
3154 }
3155
3156 void Magick::Image::gaussianBlurChannel(const ChannelType channel_,
3157   const double width_,const double sigma_)
3158 {
3159   MagickCore::Image
3160     *newImage;
3161
3162   GetPPException;
3163   SetPPChannelMask(channel_);
3164   newImage=GaussianBlurImage(constImage(),width_,sigma_,&exceptionInfo);
3165   RestorePPChannelMask;
3166   replaceImage(newImage);
3167   ThrowPPException;
3168 }
3169
3170 const Magick::Quantum *Magick::Image::getConstPixels(const ssize_t x_,
3171   const ssize_t y_,const size_t columns_,const size_t rows_) const
3172 {
3173   const Quantum
3174     *p;
3175
3176   GetPPException;
3177   p=(*GetVirtualPixels)(constImage(),x_, y_,columns_, rows_,&exceptionInfo);
3178   ThrowPPException;
3179   return(p);
3180 }
3181
3182 const void *Magick::Image::getConstMetacontent(void) const
3183 {
3184   const void
3185     *result;
3186
3187   result=GetVirtualMetacontent(constImage());
3188
3189   if(!result)
3190     throwExceptionExplicit(OptionError,"Unable to retrieve meta content.");
3191
3192   return(result);
3193 }
3194
3195 void *Magick::Image::getMetacontent(void )
3196 {
3197   void
3198     *result;
3199
3200   result=GetAuthenticMetacontent(image());
3201
3202   if(!result)
3203     throwExceptionExplicit(OptionError,"Unable to retrieve meta content.");
3204
3205   return(result);
3206 }
3207
3208 Magick::Quantum *Magick::Image::getPixels(const ssize_t x_,const ssize_t y_,
3209   const size_t columns_,const size_t rows_)
3210 {
3211   Quantum
3212     *result;
3213
3214   modifyImage();
3215   GetPPException;
3216   result=(*GetAuthenticPixels)(image(),x_, y_,columns_,rows_,&exceptionInfo);
3217   ThrowPPException;
3218
3219   return(result);
3220 }
3221
3222 void  Magick::Image::haldClut(const Image &clutImage_)
3223 {
3224   modifyImage();
3225   GetPPException;
3226   (void) HaldClutImage(image(),clutImage_.constImage(),&exceptionInfo);
3227   ThrowPPException;
3228 }
3229
3230 void Magick::Image::houghLine(const size_t width_,const size_t height_,
3231   const size_t threshold_)
3232 {
3233   MagickCore::Image
3234     *newImage;
3235
3236   GetPPException;
3237   newImage=HoughLineImage(constImage(),width_,height_,threshold_,
3238     &exceptionInfo);
3239   replaceImage(newImage);
3240   ThrowPPException;
3241 }
3242
3243 void Magick::Image::implode(const double factor_)
3244 {
3245   MagickCore::Image
3246     *newImage;
3247
3248   GetPPException;
3249   newImage=ImplodeImage(constImage(),factor_,image()->interpolate,
3250     &exceptionInfo);
3251   replaceImage(newImage);
3252   ThrowPPException;
3253 }
3254
3255 void Magick::Image::inverseFourierTransform(const Image &phase_)
3256 {
3257   inverseFourierTransform(phase_,true);
3258 }
3259
3260 void Magick::Image::inverseFourierTransform(const Image &phase_,
3261   const bool magnitude_)
3262 {
3263   MagickCore::Image
3264     *newImage;
3265
3266   GetPPException;
3267   newImage=InverseFourierTransformImage(constImage(),phase_.constImage(),
3268     magnitude_ == true ? MagickTrue : MagickFalse,&exceptionInfo);
3269   replaceImage(newImage);
3270   ThrowPPException;
3271 }
3272
3273 void Magick::Image::level(const double blackPoint_,const double whitePoint_,
3274   const double gamma_)
3275 {
3276   modifyImage();
3277   GetPPException;
3278   (void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,&exceptionInfo);
3279   ThrowPPException;
3280 }
3281
3282 void Magick::Image::levelChannel(const ChannelType channel_,
3283   const double blackPoint_,const double whitePoint_,const double gamma_)
3284 {
3285   modifyImage();
3286   GetPPException;
3287   SetPPChannelMask(channel_);
3288   (void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,&exceptionInfo);
3289   RestorePPChannelMask;
3290   ThrowPPException;
3291 }
3292
3293 void Magick::Image::levelColors(const Color &blackColor_,
3294   const Color &whiteColor_,const bool invert_)
3295 {
3296   PixelInfo
3297     black,
3298     pixel,
3299     white;
3300
3301   modifyImage();
3302
3303   GetPixelInfo(image(),&black);
3304   pixel=static_cast<PixelInfo>(blackColor_);
3305   black.red=pixel.red;
3306   black.green=pixel.green;
3307   black.blue=pixel.blue;
3308   black.alpha=pixel.alpha;
3309
3310   GetPixelInfo(image(),&white);
3311   pixel=static_cast<PixelInfo>(whiteColor_);
3312   white.red=pixel.red;
3313   white.green=pixel.green;
3314   white.blue=pixel.blue;
3315   white.alpha=pixel.alpha;
3316
3317   GetPPException;
3318   (void) LevelImageColors(image(),&black,&white,invert_ == true ?
3319     MagickTrue : MagickFalse,&exceptionInfo);
3320   ThrowPPException;
3321 }
3322
3323 void Magick::Image::levelColorsChannel(const ChannelType channel_,
3324   const Color &blackColor_,const Color &whiteColor_,const bool invert_)
3325 {
3326   PixelInfo
3327     black,
3328     pixel,
3329     white;
3330
3331   modifyImage();
3332
3333   GetPixelInfo(image(),&black);
3334   pixel=static_cast<PixelInfo>(blackColor_);
3335   black.red=pixel.red;
3336   black.green=pixel.green;
3337   black.blue=pixel.blue;
3338   black.alpha=pixel.alpha;
3339
3340   GetPixelInfo(image(),&white);
3341   pixel=static_cast<PixelInfo>(whiteColor_);
3342   white.red=pixel.red;
3343   white.green=pixel.green;
3344   white.blue=pixel.blue;
3345   white.alpha=pixel.alpha;
3346
3347   GetPPException;
3348   SetPPChannelMask(channel_);
3349   (void) LevelImageColors(image(),&black,&white,invert_ == true ?
3350     MagickTrue : MagickFalse,&exceptionInfo);
3351   RestorePPChannelMask;
3352   ThrowPPException;
3353 }
3354
3355 void Magick::Image::linearStretch(const double blackPoint_,
3356   const double whitePoint_)
3357 {
3358   modifyImage();
3359   GetPPException;
3360   LinearStretchImage(image(),blackPoint_,whitePoint_,&exceptionInfo);
3361   ThrowPPException;
3362 }
3363
3364 void Magick::Image::liquidRescale(const Geometry &geometry_)
3365 {
3366   MagickCore::Image
3367     *newImage;
3368
3369   size_t
3370     height=rows(),
3371     width=columns();
3372
3373   ssize_t
3374     x=0,
3375     y=0;
3376
3377   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
3378     &height);
3379
3380   GetPPException;
3381   newImage=LiquidRescaleImage(image(),width,height,x,y,&exceptionInfo);
3382   replaceImage(newImage);
3383   ThrowPPException;
3384 }
3385
3386 void Magick::Image::magnify(void)
3387 {
3388   MagickCore::Image
3389     *newImage;
3390
3391   GetPPException;
3392   newImage=MagnifyImage(constImage(),&exceptionInfo);
3393   replaceImage(newImage);
3394   ThrowPPException;
3395 }
3396
3397 void Magick::Image::map(const Image &mapImage_,const bool dither_)
3398 {
3399   modifyImage();
3400   GetPPException;
3401   options()->quantizeDither(dither_);
3402   RemapImage(options()->quantizeInfo(),image(),mapImage_.constImage(),
3403     &exceptionInfo);
3404   ThrowPPException;
3405 }
3406
3407 void Magick::Image::medianFilter(const double radius_)
3408 {
3409   MagickCore::Image
3410     *newImage;
3411
3412   GetPPException;
3413   newImage=StatisticImage(image(),MedianStatistic,(size_t) radius_,
3414     (size_t) radius_,&exceptionInfo);
3415   replaceImage(newImage);
3416   ThrowPPException;
3417 }
3418
3419 void Magick::Image::minify(void)
3420 {
3421   MagickCore::Image
3422     *newImage;
3423
3424   GetPPException;
3425   newImage=MinifyImage(constImage(),&exceptionInfo);
3426   replaceImage(newImage);
3427   ThrowPPException;
3428 }
3429
3430 void Magick::Image::modulate(const double brightness_,const double saturation_,
3431   const double hue_)
3432 {
3433   char
3434     modulate[MaxTextExtent + 1];
3435
3436   FormatLocaleString(modulate,MaxTextExtent,"%3.6f,%3.6f,%3.6f",brightness_,
3437     saturation_,hue_);
3438
3439   modifyImage();
3440   GetPPException;
3441   ModulateImage(image(),modulate,&exceptionInfo);
3442   ThrowPPException;
3443 }
3444
3445 Magick::ImageMoments Magick::Image::moments(void)
3446 {
3447   return(ImageMoments(constImage()));
3448 }
3449
3450 void Magick::Image::morphology(const MorphologyMethod method_,
3451   const std::string kernel_,const ssize_t iterations_)
3452 {
3453   KernelInfo
3454     *kernel;
3455
3456   MagickCore::Image
3457     *newImage;
3458
3459   kernel=AcquireKernelInfo(kernel_.c_str());
3460   if (kernel == (KernelInfo *)NULL)
3461     throwExceptionExplicit(OptionError,"Unable to parse kernel.");
3462
3463   GetPPException;
3464   newImage=MorphologyImage(constImage(),method_,iterations_,kernel,
3465     &exceptionInfo);
3466   replaceImage(newImage);
3467   kernel=DestroyKernelInfo(kernel);
3468   ThrowPPException;
3469 }
3470
3471 void Magick::Image::morphology(const MorphologyMethod method_,
3472   const KernelInfoType kernel_,const std::string arguments_,
3473   const ssize_t iterations_)
3474 {
3475   const char
3476     *option;
3477
3478   std::string
3479     kernel;
3480
3481   option=CommandOptionToMnemonic(MagickKernelOptions,kernel_);
3482   if (option == (const char *)NULL)
3483     throwExceptionExplicit(OptionError,"Unable to determine kernel type.");
3484
3485   kernel=std::string(option);
3486   if (!arguments_.empty())
3487     kernel+=":"+arguments_;
3488
3489   morphology(method_,kernel,iterations_);
3490 }
3491
3492 void Magick::Image::morphologyChannel(const ChannelType channel_,
3493   const MorphologyMethod method_,const std::string kernel_,
3494   const ssize_t iterations_)
3495 {
3496   KernelInfo
3497     *kernel;
3498
3499   MagickCore::Image
3500     *newImage;
3501
3502   kernel=AcquireKernelInfo(kernel_.c_str());
3503   if (kernel == (KernelInfo *)NULL)
3504     throwExceptionExplicit(OptionError,"Unable to parse kernel.");
3505
3506   GetPPException;
3507   SetPPChannelMask(channel_);
3508   newImage=MorphologyImage(constImage(),method_,iterations_,kernel,
3509     &exceptionInfo);
3510   RestorePPChannelMask;
3511   replaceImage(newImage);
3512   kernel=DestroyKernelInfo(kernel);
3513   ThrowPPException;
3514 }
3515
3516 void Magick::Image::morphologyChannel(const ChannelType channel_,
3517   const MorphologyMethod method_,const KernelInfoType kernel_,
3518   const std::string arguments_,const ssize_t iterations_)
3519 {
3520   const char
3521     *option;
3522
3523   std::string
3524     kernel;
3525
3526   option=CommandOptionToMnemonic(MagickKernelOptions,kernel_);
3527   if (option == (const char *)NULL)
3528     throwExceptionExplicit(OptionError,"Unable to determine kernel type.");
3529
3530   kernel=std::string(option);
3531   if (!arguments_.empty())
3532     kernel+=":"+arguments_;
3533
3534   morphologyChannel(channel_,method_,kernel,iterations_);
3535 }
3536
3537 void Magick::Image::motionBlur(const double radius_,const double sigma_,
3538   const double angle_)
3539 {
3540   MagickCore::Image
3541     *newImage;
3542
3543   GetPPException;
3544   newImage=MotionBlurImage(constImage(),radius_,sigma_,angle_,&exceptionInfo);
3545   replaceImage(newImage);
3546   ThrowPPException;
3547 }
3548
3549 void Magick::Image::negate(const bool grayscale_)
3550 {
3551   modifyImage();
3552   GetPPException;
3553   NegateImage(image(),(MagickBooleanType) grayscale_,&exceptionInfo);
3554   ThrowPPException;
3555 }
3556
3557 void Magick::Image::negateChannel(const ChannelType channel_,
3558   const bool grayscale_)
3559 {
3560   modifyImage();
3561   GetPPException;
3562   SetPPChannelMask(channel_);
3563   NegateImage(image(),(MagickBooleanType) grayscale_,&exceptionInfo);
3564   RestorePPChannelMask;
3565   ThrowPPException;
3566 }
3567
3568 void Magick::Image::normalize(void)
3569 {
3570   modifyImage();
3571   GetPPException;
3572   NormalizeImage(image(),&exceptionInfo);
3573   ThrowPPException;
3574 }
3575
3576 void Magick::Image::oilPaint(const double radius_,const double sigma_)
3577 {
3578   MagickCore::Image
3579     *newImage;
3580
3581   GetPPException;
3582   newImage=OilPaintImage(constImage(),radius_,sigma_,&exceptionInfo);
3583   replaceImage(newImage);
3584   ThrowPPException;
3585 }
3586
3587 void Magick::Image::opaque(const Color &opaqueColor_,const Color &penColor_)
3588 {
3589   std::string
3590     opaqueColor,
3591     penColor;
3592
3593   PixelInfo
3594     opaque,
3595     pen;
3596
3597   if (!opaqueColor_.isValid())
3598     throwExceptionExplicit(OptionError,"Opaque color argument is invalid");
3599
3600   if (!penColor_.isValid())
3601     throwExceptionExplicit(OptionError,"Pen color argument is invalid");
3602
3603   modifyImage();
3604   opaqueColor=opaqueColor_;
3605   penColor=penColor_;
3606
3607   GetPPException;
3608   (void) QueryColorCompliance(opaqueColor.c_str(),AllCompliance,&opaque,
3609     &exceptionInfo);
3610   (void) QueryColorCompliance(penColor.c_str(),AllCompliance,&pen,
3611     &exceptionInfo);
3612   OpaquePaintImage(image(),&opaque,&pen,MagickFalse,&exceptionInfo);
3613   ThrowPPException;
3614 }
3615
3616 void Magick::Image::orderedDither(std::string thresholdMap_)
3617 {
3618   modifyImage();
3619   GetPPException;
3620   (void) OrderedPosterizeImage(image(),thresholdMap_.c_str(),&exceptionInfo);
3621   ThrowPPException;
3622 }
3623
3624 void Magick::Image::orderedDitherChannel(const ChannelType channel_,
3625   std::string thresholdMap_)
3626 {
3627   modifyImage();
3628   GetPPException;
3629   SetPPChannelMask(channel_);
3630   (void) OrderedPosterizeImage(image(),thresholdMap_.c_str(),&exceptionInfo);
3631   RestorePPChannelMask;
3632   ThrowPPException;
3633 }
3634
3635 void Magick::Image::perceptible(const double epsilon_)
3636 {
3637   modifyImage();
3638   GetPPException;
3639   PerceptibleImage(image(),epsilon_,&exceptionInfo);
3640   ThrowPPException;
3641 }
3642
3643 void Magick::Image::perceptibleChannel(const ChannelType channel_,
3644   const double epsilon_)
3645 {
3646   modifyImage();
3647   GetPPException;
3648   SetPPChannelMask(channel_);
3649   PerceptibleImage(image(),epsilon_,&exceptionInfo);
3650   RestorePPChannelMask;
3651   ThrowPPException;
3652 }
3653
3654 void Magick::Image::ping(const std::string &imageSpec_)
3655 {
3656   MagickCore::Image
3657     *newImage;
3658
3659   GetPPException;
3660   options()->fileName(imageSpec_);
3661   newImage=PingImage(imageInfo(),&exceptionInfo);
3662   replaceImage(newImage);
3663   ThrowPPException;
3664 }
3665
3666 void Magick::Image::ping(const Blob& blob_)
3667 {
3668   MagickCore::Image
3669     *newImage;
3670
3671   GetPPException;
3672   newImage=PingBlob(imageInfo(),blob_.data(),blob_.length(),&exceptionInfo);
3673   replaceImage(newImage);
3674   ThrowPPException;
3675 }
3676
3677 void Magick::Image::pixelColor(const ssize_t x_,const ssize_t y_,
3678   const Color &color_)
3679 {
3680   PixelInfo
3681     packet;
3682
3683   Quantum
3684     *pixel;
3685
3686   // Test arguments to ensure they are within the image.
3687   if (y_ > (ssize_t) rows() || x_ > (ssize_t) columns())
3688     throwExceptionExplicit(OptionError,"Access outside of image boundary");
3689
3690   modifyImage();
3691
3692   // Set image to DirectClass
3693   classType(DirectClass );
3694
3695   // Get pixel view
3696   Pixels pixels(*this);
3697     // Set pixel value
3698   pixel=pixels.get(x_, y_, 1, 1 );
3699   packet=color_;
3700   MagickCore::SetPixelInfoPixel(constImage(),&packet,pixel);
3701   // Tell ImageMagick that pixels have been updated
3702   pixels.sync();
3703 }
3704
3705 Magick::Color Magick::Image::pixelColor(const ssize_t x_,
3706   const ssize_t y_) const
3707 {
3708   const Quantum
3709     *pixel;
3710
3711   pixel=getConstPixels(x_,y_,1,1);
3712   if (pixel)
3713     {
3714       PixelInfo
3715         packet;
3716
3717       MagickCore::GetPixelInfoPixel(constImage(),pixel,&packet);
3718       return(Color(packet));
3719     }
3720
3721   return(Color()); // invalid
3722 }
3723
3724 void Magick::Image::polaroid(const std::string &caption_,const double angle_,
3725   const PixelInterpolateMethod method_)
3726 {
3727   MagickCore::Image
3728     *newImage;
3729
3730   GetPPException;
3731   newImage=PolaroidImage(constImage(),options()->drawInfo(),caption_.c_str(),
3732     angle_,method_,&exceptionInfo);
3733   replaceImage(newImage);
3734   ThrowPPException;
3735 }
3736
3737 void Magick::Image::posterize(const size_t levels_,const DitherMethod method_)
3738 {
3739   modifyImage();
3740   GetPPException;
3741   PosterizeImage(image(),levels_,method_,&exceptionInfo);
3742   ThrowPPException;
3743 }
3744
3745 void Magick::Image::posterizeChannel(const ChannelType channel_,
3746   const size_t levels_,const DitherMethod method_)
3747 {
3748   modifyImage();
3749   GetPPException;
3750   SetPPChannelMask(channel_);
3751   PosterizeImage(image(),levels_,method_,&exceptionInfo);
3752   RestorePPChannelMask;
3753   ThrowPPException;
3754 }
3755
3756 void Magick::Image::process(std::string name_,const ssize_t argc,
3757   const char **argv)
3758 {
3759   modifyImage();
3760
3761   GetPPException;
3762   (void) InvokeDynamicImageFilter(name_.c_str(),&image(),argc,argv,
3763       &exceptionInfo);
3764   ThrowPPException;
3765 }
3766
3767 void Magick::Image::profile(const std::string name_,
3768   const Magick::Blob &profile_)
3769 {
3770   modifyImage();
3771   GetPPException;
3772   (void) ProfileImage(image(),name_.c_str(),(unsigned char *)profile_.data(),
3773     profile_.length(),&exceptionInfo);
3774   ThrowPPException;
3775 }
3776
3777 Magick::Blob Magick::Image::profile(const std::string name_) const
3778 {
3779   const StringInfo
3780     *profile;
3781
3782   profile=GetImageProfile(constImage(),name_.c_str());
3783
3784   if (profile == (StringInfo *) NULL)
3785     return(Blob());
3786   return(Blob((void*) GetStringInfoDatum(profile),GetStringInfoLength(
3787     profile)));
3788 }
3789
3790 void Magick::Image::quantize(const bool measureError_)
3791 {
3792   modifyImage();
3793
3794   if (measureError_)
3795     options()->quantizeInfo()->measure_error=MagickTrue;
3796   else
3797     options()->quantizeInfo()->measure_error=MagickFalse;
3798
3799   GetPPException;
3800   QuantizeImage(options()->quantizeInfo(),image(),&exceptionInfo);
3801   ThrowPPException;
3802 }
3803
3804 void Magick::Image::quantumOperator(const ChannelType channel_,
3805   const MagickEvaluateOperator operator_,double rvalue_)
3806 {
3807   GetPPException;
3808   SetPPChannelMask(channel_);
3809   EvaluateImage(image(),operator_,rvalue_,&exceptionInfo);
3810   RestorePPChannelMask;
3811   ThrowPPException;
3812 }
3813
3814 void Magick::Image::quantumOperator(const ssize_t x_,const ssize_t y_,
3815   const size_t columns_,const size_t rows_,const ChannelType channel_,
3816   const MagickEvaluateOperator operator_,const double rvalue_)
3817 {
3818   RectangleInfo
3819     geometry;
3820
3821   MagickCore::Image
3822     *cropImage;
3823
3824   geometry.width = columns_;
3825   geometry.height = rows_;
3826   geometry.x = x_;
3827   geometry.y = y_;
3828
3829   GetPPException;
3830   cropImage=CropImage(image(),&geometry,&exceptionInfo);
3831   SetPPChannelMask(channel_);
3832   EvaluateImage(cropImage,operator_,rvalue_,&exceptionInfo);
3833   RestorePPChannelMask;
3834   (void) CompositeImage(image(),cropImage,image()->alpha_trait ==
3835     BlendPixelTrait ? OverCompositeOp : CopyCompositeOp,MagickFalse,
3836     geometry.x,geometry.y,&exceptionInfo );
3837   cropImage=DestroyImageList(cropImage);
3838   ThrowPPException;
3839 }
3840
3841 void Magick::Image::raise(const Geometry &geometry_,const bool raisedFlag_)
3842 {
3843   RectangleInfo
3844     raiseInfo=geometry_;
3845
3846   GetPPException;
3847   modifyImage();
3848   RaiseImage(image(),&raiseInfo,raisedFlag_ == true ? MagickTrue : MagickFalse,
3849     &exceptionInfo);
3850   ThrowPPException;
3851 }
3852
3853 void Magick::Image::randomThreshold(const Geometry &thresholds_)
3854 {
3855   GetPPException;
3856   (void) RandomThresholdImage(image(),static_cast<std::string>(
3857     thresholds_).c_str(),&exceptionInfo);
3858   ThrowPPException;
3859 }
3860
3861 void Magick::Image::randomThresholdChannel(const ChannelType channel_,
3862   const Geometry &thresholds_)
3863 {
3864   modifyImage();
3865   GetPPException;
3866   SetPPChannelMask(channel_);
3867   (void) RandomThresholdImage(image(),static_cast<std::string>(
3868     thresholds_).c_str(),&exceptionInfo);
3869   RestorePPChannelMask;
3870   ThrowPPException;
3871 }
3872
3873 void Magick::Image::read(const Blob &blob_)
3874 {
3875   MagickCore::Image
3876     *newImage;
3877
3878   GetPPException;
3879   newImage=BlobToImage(imageInfo(),static_cast<const void *>(blob_.data()),
3880     blob_.length(),&exceptionInfo);
3881   replaceImage(newImage);
3882   ThrowPPException;
3883 }
3884
3885 void Magick::Image::read(const Blob &blob_,const Geometry &size_)
3886 {
3887   size(size_);
3888   read(blob_);
3889 }
3890
3891 void Magick::Image::read(const Blob &blob_,const Geometry &size_,
3892   const size_t depth_)
3893 {
3894   size(size_);
3895   depth(depth_);
3896   read(blob_);
3897 }
3898
3899 void Magick::Image::read(const Blob &blob_,const Geometry &size_,
3900   const size_t depth_,const std::string &magick_)
3901 {
3902   size(size_);
3903   depth(depth_);
3904   magick(magick_);
3905   // Set explicit image format
3906   fileName(magick_ + ':');
3907   read(blob_);
3908 }
3909
3910 void Magick::Image::read(const Blob &blob_,const Geometry &size_,
3911   const std::string &magick_)
3912 {
3913   size(size_);
3914   magick(magick_);
3915   // Set explicit image format
3916   fileName(magick_ + ':');
3917   read(blob_);
3918 }
3919
3920 void Magick::Image::read(const Geometry &size_,const std::string &imageSpec_)
3921 {
3922   size(size_);
3923   read(imageSpec_);
3924 }
3925
3926 void Magick::Image::read(const size_t width_,const size_t height_,
3927   const std::string &map_,const StorageType type_,const void *pixels_)
3928 {
3929   MagickCore::Image
3930     *newImage;
3931
3932   GetPPException;
3933   newImage=ConstituteImage(width_,height_,map_.c_str(),type_, pixels_,
3934     &exceptionInfo);
3935   replaceImage(newImage);
3936   ThrowPPException;
3937 }
3938
3939 void Magick::Image::read(const std::string &imageSpec_)
3940 {
3941   MagickCore::Image
3942     *newImage;
3943
3944   GetPPException;
3945   options()->fileName(imageSpec_);
3946   newImage=ReadImage(imageInfo(),&exceptionInfo);
3947
3948   // Ensure that multiple image frames were not read.
3949   if (newImage && newImage->next)
3950     {
3951       MagickCore::Image
3952          *next;
3953
3954       // Destroy any extra image frames
3955       next=newImage->next;
3956       newImage->next=0;
3957       next->previous=0;
3958       DestroyImageList(next);
3959     }
3960   replaceImage(newImage);
3961   ThrowPPException;
3962 }
3963
3964 void Magick::Image::readPixels(const Magick::QuantumType quantum_,
3965   const unsigned char *source_)
3966 {
3967   QuantumInfo
3968     *quantum_info;
3969
3970   quantum_info=AcquireQuantumInfo(imageInfo(),image());
3971   GetPPException;
3972   ImportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
3973     quantum_,source_,&exceptionInfo);
3974   quantum_info=DestroyQuantumInfo(quantum_info);
3975   ThrowPPException;
3976 }
3977
3978 void Magick::Image::reduceNoise(void)
3979 {
3980   reduceNoise(3.0);
3981 }
3982
3983 void Magick::Image::reduceNoise(const double order_)
3984 {
3985   MagickCore::Image
3986     *newImage;
3987
3988   GetPPException;
3989   newImage=StatisticImage(constImage(),NonpeakStatistic,(size_t) order_,
3990     (size_t) order_,&exceptionInfo);
3991   replaceImage(newImage);
3992   ThrowPPException;
3993 }
3994
3995 void Magick::Image::resample(const Geometry &geometry_)
3996 {
3997   MagickCore::Image
3998     *newImage;
3999
4000   size_t
4001     height=rows(),
4002     width=columns();
4003
4004   ssize_t
4005     x=0,
4006     y=0;
4007
4008   // Calculate new size.  This code should be supported using binary arguments
4009   // in the ImageMagick library.
4010   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
4011     &height);
4012
4013   GetPPException;
4014   newImage=ResampleImage(constImage(),width,height,image()->filter,
4015     &exceptionInfo);
4016   replaceImage(newImage);
4017   ThrowPPException;
4018 }
4019
4020 void Magick::Image::resize(const Geometry &geometry_)
4021 {
4022   MagickCore::Image
4023     *newImage;
4024
4025   size_t
4026     height=rows(),
4027     width=columns();
4028
4029   ssize_t
4030     x=0,
4031     y=0;
4032
4033   // Calculate new size.  This code should be supported using binary arguments
4034   // in the ImageMagick library.
4035   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
4036     &height);
4037
4038   GetPPException;
4039   newImage=ResizeImage(constImage(),width,height,image()->filter,
4040     &exceptionInfo);
4041   replaceImage(newImage);
4042   ThrowPPException;
4043 }
4044
4045 void Magick::Image::roll(const Geometry &roll_)
4046 {
4047   MagickCore::Image
4048     *newImage;
4049
4050   ssize_t
4051     xOff=roll_.xOff(),
4052     yOff=roll_.yOff();
4053
4054   if (roll_.xNegative())
4055     xOff = 0 - xOff;
4056   if (roll_.yNegative())
4057     yOff = 0 - yOff;
4058
4059   GetPPException;
4060   newImage=RollImage(constImage(),xOff,yOff,&exceptionInfo);
4061   replaceImage(newImage);
4062   ThrowPPException;
4063 }
4064
4065 void Magick::Image::roll(const size_t columns_,const size_t rows_)
4066 {
4067   MagickCore::Image
4068     *newImage;
4069
4070   GetPPException;
4071   newImage=RollImage(constImage(),static_cast<ssize_t>(columns_),
4072     static_cast<ssize_t>(rows_),&exceptionInfo);
4073   replaceImage(newImage);
4074   ThrowPPException;
4075 }
4076
4077 void Magick::Image::rotate(const double degrees_)
4078 {
4079   MagickCore::Image
4080     *newImage;
4081
4082   GetPPException;
4083   newImage=RotateImage(constImage(),degrees_,&exceptionInfo);
4084   replaceImage(newImage);
4085   ThrowPPException;
4086 }
4087
4088 void Magick::Image::rotationalBlur(const double angle_)
4089 {
4090   MagickCore::Image
4091     *newImage;
4092
4093   GetPPException;
4094   newImage=RotationalBlurImage(constImage(),angle_,&exceptionInfo);
4095   replaceImage(newImage);
4096   ThrowPPException;
4097 }
4098
4099 void Magick::Image::rotationalBlurChannel(const ChannelType channel_,
4100   const double angle_)
4101 {
4102   MagickCore::Image
4103     *newImage;
4104
4105   GetPPException;
4106   SetPPChannelMask(channel_);
4107   newImage=RotationalBlurImage(constImage(),angle_,&exceptionInfo);
4108   RestorePPChannelMask;
4109   replaceImage(newImage);
4110   ThrowPPException;
4111 }
4112
4113 void Magick::Image::sample(const Geometry &geometry_)
4114 {
4115   MagickCore::Image
4116     *newImage;
4117
4118   size_t
4119     height=rows(),
4120     width=columns();
4121
4122   ssize_t
4123     x=0,
4124     y=0;
4125
4126   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
4127     &height);
4128
4129   GetPPException;
4130   newImage=SampleImage(constImage(),width,height,&exceptionInfo);
4131   replaceImage(newImage);
4132   ThrowPPException;
4133 }
4134
4135 void Magick::Image::scale(const Geometry &geometry_)
4136 {
4137   MagickCore::Image
4138     *newImage;
4139
4140   size_t
4141     height=rows(),
4142     width=columns();
4143
4144   ssize_t
4145     x=0,
4146     y=0;
4147
4148   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
4149     &height);
4150
4151   GetPPException;
4152   newImage=ScaleImage(constImage(),width,height,&exceptionInfo);
4153   replaceImage(newImage);
4154   ThrowPPException;
4155 }
4156
4157 void Magick::Image::segment(const double clusterThreshold_,
4158   const double smoothingThreshold_)
4159 {
4160   modifyImage();
4161   GetPPException;
4162   SegmentImage(image(),options()->quantizeColorSpace(),
4163     (MagickBooleanType) options()->verbose(),clusterThreshold_,
4164     smoothingThreshold_,&exceptionInfo);
4165   SyncImage(image(),&exceptionInfo);
4166   ThrowPPException;
4167 }
4168
4169 void Magick::Image::selectiveBlur(const double radius_,const double sigma_,
4170   const double threshold_)
4171 {
4172   MagickCore::Image
4173     *newImage;
4174
4175   GetPPException;
4176   newImage=SelectiveBlurImage(constImage(),radius_,sigma_,threshold_,
4177     &exceptionInfo);
4178   replaceImage(newImage);
4179   ThrowPPException;
4180 }
4181
4182 void Magick::Image::selectiveBlurChannel(const ChannelType channel_,
4183   const double radius_,const double sigma_,const double threshold_)
4184 {
4185   MagickCore::Image
4186     *newImage;
4187
4188   GetPPException;
4189   SetPPChannelMask(channel_);
4190   newImage=SelectiveBlurImage(constImage(),radius_,sigma_,threshold_,
4191     &exceptionInfo);
4192   RestorePPChannelMask;
4193   replaceImage(newImage);
4194   ThrowPPException;
4195 }
4196
4197 Magick::Image Magick::Image::separate(const ChannelType channel_)
4198 {
4199   MagickCore::Image
4200     *image;
4201
4202   GetPPException;
4203   image=SeparateImage(constImage(),channel_,&exceptionInfo);
4204   ThrowPPException;
4205   if (image == (MagickCore::Image *) NULL)
4206     return(Magick::Image());
4207   else
4208     return(Magick::Image(image));
4209 }
4210
4211 void Magick::Image::sepiaTone(const double threshold_)
4212 {
4213   MagickCore::Image
4214     *newImage;
4215
4216   GetPPException;
4217   newImage=SepiaToneImage(constImage(),threshold_,&exceptionInfo);
4218   replaceImage(newImage);
4219   ThrowPPException;
4220 }
4221
4222 Magick::Quantum *Magick::Image::setPixels(const ssize_t x_,const ssize_t y_,
4223   const size_t columns_,const size_t rows_)
4224 {
4225   Quantum
4226     *result;
4227
4228   modifyImage();
4229   GetPPException;
4230   result=(*QueueAuthenticPixels)(image(),x_,y_,columns_,rows_,&exceptionInfo);
4231   ThrowPPException;
4232   return(result);
4233 }
4234
4235 void Magick::Image::shade(const double azimuth_,const double elevation_,
4236   const bool colorShading_)
4237 {
4238   MagickCore::Image
4239     *newImage;
4240
4241   GetPPException;
4242   newImage=ShadeImage(constImage(),colorShading_ == true ?
4243     MagickTrue : MagickFalse,azimuth_,elevation_,&exceptionInfo);
4244   replaceImage(newImage);
4245   ThrowPPException;
4246 }
4247
4248 void Magick::Image::shadow(const double percent_opacity_,const double sigma_,
4249   const ssize_t x_,const ssize_t y_)
4250 {
4251   MagickCore::Image
4252     *newImage;
4253
4254   GetPPException;
4255   newImage=ShadowImage(constImage(),percent_opacity_, sigma_,x_, y_,
4256     &exceptionInfo);
4257   replaceImage(newImage);
4258   ThrowPPException;
4259 }
4260
4261 void Magick::Image::sharpen(const double radius_,const double sigma_)
4262 {
4263   MagickCore::Image
4264     *newImage;
4265
4266   GetPPException;
4267   newImage=SharpenImage(constImage(),radius_,sigma_,&exceptionInfo);
4268   replaceImage(newImage);
4269   ThrowPPException;
4270 }
4271
4272 void Magick::Image::sharpenChannel(const ChannelType channel_,
4273   const double radius_,const double sigma_)
4274 {
4275   MagickCore::Image
4276     *newImage;
4277
4278   GetPPException;
4279   SetPPChannelMask(channel_);
4280   newImage=SharpenImage(constImage(),radius_,sigma_,&exceptionInfo);
4281   RestorePPChannelMask;
4282   replaceImage(newImage);
4283   ThrowPPException;
4284 }
4285
4286 void Magick::Image::shave(const Geometry &geometry_)
4287 {
4288   MagickCore::Image
4289     *newImage;
4290
4291   RectangleInfo
4292     shaveInfo=geometry_;
4293
4294   GetPPException;
4295   newImage=ShaveImage(constImage(),&shaveInfo,&exceptionInfo);
4296   replaceImage(newImage);
4297   ThrowPPException;
4298 }
4299
4300 void Magick::Image::shear(const double xShearAngle_,const double yShearAngle_)
4301 {
4302   MagickCore::Image
4303     *newImage;
4304
4305   GetPPException;
4306   newImage=ShearImage(constImage(),xShearAngle_,yShearAngle_,&exceptionInfo);
4307   replaceImage(newImage);
4308   ThrowPPException;
4309 }
4310
4311 void Magick::Image::sigmoidalContrast(const size_t sharpen_,
4312   const double contrast,const double midpoint)
4313 {
4314   modifyImage();
4315   GetPPException;
4316   (void) SigmoidalContrastImage(image(),(MagickBooleanType) sharpen_,contrast,
4317     midpoint,&exceptionInfo);
4318   ThrowPPException;
4319 }
4320
4321 std::string Magick::Image::signature(const bool force_) const
4322 {
4323   const char
4324     *property;
4325
4326   Lock(&_imgRef->_mutexLock);
4327
4328   // Re-calculate image signature if necessary
4329   GetPPException;
4330   if (force_ || !GetImageProperty(constImage(),"Signature",&exceptionInfo) ||
4331     constImage()->taint)
4332     SignatureImage(const_cast<MagickCore::Image *>(constImage()),
4333       &exceptionInfo);
4334
4335   property=GetImageProperty(constImage(),"Signature",&exceptionInfo);
4336   ThrowPPException;
4337
4338   return(std::string(property));
4339 }
4340
4341 void Magick::Image::sketch(const double radius_,const double sigma_,
4342   const double angle_)
4343 {
4344   MagickCore::Image
4345     *newImage;
4346
4347   GetPPException;
4348   newImage=SketchImage(constImage(),radius_,sigma_,angle_,&exceptionInfo);
4349   replaceImage(newImage);
4350   ThrowPPException;
4351 }
4352
4353 void Magick::Image::solarize(const double factor_)
4354 {
4355   modifyImage();
4356   GetPPException;
4357   SolarizeImage(image(),factor_,&exceptionInfo);
4358   ThrowPPException;
4359 }
4360
4361 void Magick::Image::sparseColor(const ChannelType channel_,
4362   const SparseColorMethod method_,const size_t numberArguments_,
4363   const double *arguments_)
4364 {
4365   MagickCore::Image
4366     *newImage;
4367
4368   GetPPException;
4369   SetPPChannelMask(channel_);
4370   newImage=SparseColorImage(constImage(),method_,numberArguments_,arguments_,
4371     &exceptionInfo);
4372   RestorePPChannelMask;
4373   replaceImage(newImage);
4374   ThrowPPException;
4375 }
4376
4377 void Magick::Image::splice(const Geometry &geometry_)
4378 {
4379   MagickCore::Image
4380     *newImage;
4381
4382   RectangleInfo
4383     spliceInfo=geometry_;
4384
4385   GetPPException;
4386   newImage=SpliceImage(constImage(),&spliceInfo,&exceptionInfo);
4387   replaceImage(newImage);
4388   ThrowPPException;
4389 }
4390
4391 void Magick::Image::spread(const size_t amount_)
4392 {
4393   MagickCore::Image
4394     *newImage;
4395
4396   GetPPException;
4397   newImage=SpreadImage(constImage(),amount_,image()->interpolate,
4398     &exceptionInfo);
4399   replaceImage(newImage);
4400   ThrowPPException;
4401 }
4402
4403 void Magick::Image::statistics(ImageStatistics *statistics)
4404 {
4405   double
4406     maximum,
4407     minimum;
4408
4409   GetPPException;
4410
4411   SetPPChannelMask(RedChannel);
4412   (void) GetImageRange(constImage(),&minimum,&maximum,&exceptionInfo);
4413   statistics->red.minimum=minimum;
4414   statistics->red.maximum=maximum;
4415   (void) GetImageMean(constImage(),&statistics->red.mean,
4416     &statistics->red.standard_deviation,&exceptionInfo);
4417   (void) GetImageKurtosis(constImage(),&statistics->red.kurtosis,
4418     &statistics->red.skewness,&exceptionInfo);
4419
4420   (void) SetImageChannelMask(image(),GreenChannel);
4421   (void) GetImageRange(constImage(),&minimum,&maximum,&exceptionInfo);
4422   statistics->green.minimum=minimum;
4423   statistics->green.maximum=maximum;
4424   (void) GetImageMean(constImage(),&statistics->green.mean,
4425     &statistics->green.standard_deviation,&exceptionInfo);
4426   (void) GetImageKurtosis(constImage(),&statistics->green.kurtosis,
4427     &statistics->green.skewness,&exceptionInfo);
4428
4429   (void) SetImageChannelMask(image(),GreenChannel);
4430   (void) GetImageRange(constImage(),&minimum,&maximum,&exceptionInfo);
4431   statistics->blue.minimum=minimum;
4432   statistics->blue.maximum=maximum;
4433   (void) GetImageMean(constImage(),&statistics->blue.mean,
4434     &statistics->blue.standard_deviation,&exceptionInfo);
4435   (void) GetImageKurtosis(constImage(),&statistics->blue.kurtosis,
4436     &statistics->blue.skewness,&exceptionInfo);
4437
4438   (void) SetImageChannelMask(image(),AlphaChannel);
4439   (void) GetImageRange(constImage(),&minimum,&maximum,&exceptionInfo);
4440   statistics->alpha.minimum=minimum;
4441   statistics->alpha.maximum=maximum;
4442   (void) GetImageMean(constImage(),&statistics->alpha.mean,
4443     &statistics->alpha.standard_deviation,&exceptionInfo);
4444   (void) GetImageKurtosis(constImage(),&statistics->alpha.kurtosis,
4445     &statistics->alpha.skewness,&exceptionInfo);
4446   RestorePPChannelMask;
4447   ThrowPPException;
4448 }
4449
4450 void Magick::Image::stegano(const Image &watermark_)
4451 {
4452   MagickCore::Image
4453     *newImage;
4454
4455   GetPPException;
4456   newImage=SteganoImage(constImage(),watermark_.constImage(),&exceptionInfo);
4457   replaceImage(newImage);
4458   ThrowPPException;
4459 }
4460
4461 void Magick::Image::stereo(const Image &rightImage_)
4462 {
4463   MagickCore::Image
4464     *newImage;
4465
4466   GetPPException;
4467   newImage=StereoImage(constImage(),rightImage_.constImage(),&exceptionInfo);
4468   replaceImage(newImage);
4469   ThrowPPException;
4470 }
4471
4472 void Magick::Image::strip(void)
4473 {
4474   modifyImage();
4475   GetPPException;
4476   StripImage(image(),&exceptionInfo);
4477   ThrowPPException;
4478 }
4479
4480 Magick::Image Magick::Image::subImageSearch(const Image &reference_,
4481   const MetricType metric_,Geometry *offset_,double *similarityMetric_,
4482   const double similarityThreshold)
4483 {
4484   MagickCore::Image
4485     *newImage;
4486
4487   RectangleInfo
4488     offset;
4489
4490   GetPPException;
4491   newImage=SimilarityImage(image(),reference_.constImage(),metric_,
4492     similarityThreshold,&offset,similarityMetric_,&exceptionInfo);
4493   ThrowPPException;
4494   if (offset_ != (Geometry *) NULL)
4495     *offset_=offset;
4496   if (newImage == (MagickCore::Image *) NULL)
4497     return(Magick::Image());
4498   else
4499     return(Magick::Image(newImage));
4500 }
4501
4502 void Magick::Image::swirl(const double degrees_)
4503 {
4504   MagickCore::Image
4505     *newImage;
4506
4507   GetPPException;
4508   newImage=SwirlImage(constImage(),degrees_,image()->interpolate,
4509     &exceptionInfo);
4510   replaceImage(newImage);
4511   ThrowPPException;
4512 }
4513
4514 void Magick::Image::syncPixels(void)
4515 {
4516   GetPPException;
4517   (void) (*SyncAuthenticPixels)(image(),&exceptionInfo);
4518   ThrowPPException;
4519 }
4520
4521 void Magick::Image::texture(const Image &texture_)
4522 {
4523   modifyImage();
4524   GetPPException;
4525   TextureImage(image(),texture_.constImage(),&exceptionInfo);
4526   ThrowPPException;
4527 }
4528
4529 void Magick::Image::threshold(const double threshold_)
4530 {
4531   modifyImage();
4532   GetPPException;
4533   BilevelImage(image(),threshold_,&exceptionInfo);
4534   ThrowPPException;
4535 }
4536
4537 void Magick::Image::thumbnail(const Geometry &geometry_)
4538 {
4539   MagickCore::Image
4540     *newImage;
4541
4542   size_t
4543     height=rows(),
4544     width=columns();
4545
4546   ssize_t
4547     x=0,
4548     y=0;
4549
4550   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
4551     &height);
4552
4553   GetPPException;
4554   newImage=ThumbnailImage(constImage(),width,height,&exceptionInfo);
4555   replaceImage(newImage);
4556   ThrowPPException;
4557 }
4558
4559 void Magick::Image::tint(const std::string opacity_)
4560 {
4561   MagickCore::Image
4562     *newImage;
4563
4564   PixelInfo
4565     color;
4566
4567   GetPPException;
4568   color=static_cast<PixelInfo>(constOptions()->fillColor());
4569   newImage=TintImage(constImage(),opacity_.c_str(),&color,&exceptionInfo);
4570   replaceImage(newImage);
4571   ThrowPPException;
4572 }
4573
4574 void Magick::Image::transform(const Geometry &imageGeometry_)
4575 {
4576   modifyImage();
4577   GetPPException;
4578   TransformImage(&(image()),0,std::string(imageGeometry_).c_str(),
4579     &exceptionInfo);
4580   ThrowPPException;
4581 }
4582
4583 void Magick::Image::transform(const Geometry &imageGeometry_,
4584   const Geometry &cropGeometry_)
4585 {
4586   modifyImage();
4587   GetPPException;
4588   TransformImage(&(image()),std::string(cropGeometry_).c_str(),std::string(
4589     imageGeometry_).c_str(), &exceptionInfo);
4590   ThrowPPException;
4591 }
4592
4593 void Magick::Image::transformOrigin(const double x_,const double y_)
4594 {
4595   modifyImage();
4596   options()->transformOrigin(x_,y_);
4597 }
4598
4599 void Magick::Image::transformReset(void)
4600 {
4601   modifyImage();
4602   options()->transformReset();
4603 }
4604
4605 void Magick::Image::transformScale(const double sx_,const double sy_)
4606 {
4607   modifyImage();
4608   options()->transformScale(sx_,sy_);
4609 }
4610
4611 void Magick::Image::transparent(const Color &color_)
4612 {
4613   PixelInfo
4614     target;
4615
4616   std::string
4617     color;
4618
4619   if (!color_.isValid())
4620     throwExceptionExplicit(OptionError,"Color argument is invalid");
4621
4622   color=color_;
4623   GetPPException;
4624   (void) QueryColorCompliance(color.c_str(),AllCompliance,&target,
4625     &exceptionInfo);
4626   modifyImage();
4627   TransparentPaintImage(image(),&target,TransparentAlpha,MagickFalse,
4628     &exceptionInfo);
4629   ThrowPPException;
4630 }
4631
4632 void Magick::Image::transparentChroma(const Color &colorLow_,
4633   const Color &colorHigh_)
4634 {
4635   std::string
4636     colorHigh,
4637     colorLow;
4638
4639   PixelInfo
4640     targetHigh,
4641     targetLow;
4642
4643   if (!colorLow_.isValid() || !colorHigh_.isValid())
4644     throwExceptionExplicit(OptionError,"Color argument is invalid");
4645
4646   colorLow=colorLow_;
4647   colorHigh=colorHigh_;
4648
4649   GetPPException;
4650   (void) QueryColorCompliance(colorLow.c_str(),AllCompliance,&targetLow,
4651     &exceptionInfo);
4652   (void) QueryColorCompliance(colorHigh.c_str(),AllCompliance,&targetHigh,
4653     &exceptionInfo);
4654   modifyImage();
4655   TransparentPaintImageChroma(image(),&targetLow,&targetHigh,TransparentAlpha,
4656     MagickFalse,&exceptionInfo);
4657   ThrowPPException;
4658 }
4659
4660 void Magick::Image::transpose(void)
4661 {
4662   MagickCore::Image
4663     *newImage;
4664
4665   GetPPException;
4666   newImage=TransposeImage(constImage(),&exceptionInfo);
4667   replaceImage(newImage);
4668   ThrowPPException;
4669 }
4670
4671 void Magick::Image::transverse(void)
4672 {
4673   MagickCore::Image
4674     *newImage;
4675
4676   GetPPException;
4677   newImage=TransverseImage(constImage(),&exceptionInfo);
4678   replaceImage(newImage);
4679   ThrowPPException;
4680 }
4681
4682 void Magick::Image::trim(void)
4683 {
4684   MagickCore::Image
4685     *newImage;
4686
4687   GetPPException;
4688   newImage=TrimImage(constImage(),&exceptionInfo);
4689   replaceImage(newImage);
4690   ThrowPPException;
4691 }
4692
4693 Magick::Image Magick::Image::uniqueColors(void)
4694 {
4695   MagickCore::Image
4696     *image;
4697
4698   GetPPException;
4699   image=UniqueImageColors(constImage(),&exceptionInfo);
4700   ThrowPPException;
4701   if (image == (MagickCore::Image *) NULL)
4702     return(Magick::Image());
4703   else
4704     return(Magick::Image(image));
4705 }
4706
4707 void Magick::Image::unsharpmask(const double radius_,const double sigma_,
4708   const double amount_,const double threshold_)
4709 {
4710   MagickCore::Image
4711     *newImage;
4712
4713   GetPPException;
4714   newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
4715     &exceptionInfo);
4716   replaceImage(newImage);
4717   ThrowPPException;
4718 }
4719
4720 void Magick::Image::unsharpmaskChannel(const ChannelType channel_,
4721   const double radius_,const double sigma_,const double amount_,
4722   const double threshold_)
4723 {
4724   MagickCore::Image
4725     *newImage;
4726
4727   GetPPException;
4728   SetPPChannelMask(channel_);
4729   newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
4730     &exceptionInfo);
4731   RestorePPChannelMask;
4732   replaceImage(newImage);
4733   ThrowPPException;
4734 }
4735
4736 void Magick::Image::vignette(const double radius_,const double sigma_,
4737   const ssize_t x_,const ssize_t y_)
4738 {
4739   MagickCore::Image
4740     *newImage;
4741
4742   GetPPException;
4743   newImage=VignetteImage(constImage(),radius_,sigma_,x_,y_,&exceptionInfo);
4744   replaceImage(newImage);
4745   ThrowPPException;
4746 }
4747
4748 void Magick::Image::wave(const double amplitude_,const double wavelength_)
4749 {
4750   MagickCore::Image
4751     *newImage;
4752
4753   GetPPException;
4754   newImage=WaveImage(constImage(),amplitude_,wavelength_,image()->interpolate,
4755     &exceptionInfo);
4756   replaceImage(newImage);
4757   ThrowPPException;
4758 }
4759
4760 void Magick::Image::whiteThreshold(const std::string &threshold_)
4761 {
4762   modifyImage();
4763   GetPPException;
4764   WhiteThresholdImage(image(),threshold_.c_str(),&exceptionInfo);
4765   ThrowPPException;
4766 }
4767
4768 void Magick::Image::whiteThresholdChannel(const ChannelType channel_,
4769   const std::string &threshold_)
4770 {
4771   modifyImage();
4772   GetPPException;
4773   SetPPChannelMask(channel_);
4774   WhiteThresholdImage(image(),threshold_.c_str(),&exceptionInfo);
4775   RestorePPChannelMask;
4776   ThrowPPException;
4777 }
4778
4779 void Magick::Image::write(Blob *blob_)
4780 {
4781   size_t
4782     length=0;
4783
4784   void
4785     *data;
4786
4787   modifyImage();
4788   GetPPException;
4789   data=ImagesToBlob(constImageInfo(),image(),&length,&exceptionInfo);
4790   if (length > 0)
4791     blob_->updateNoCopy(data,length,Blob::MallocAllocator);
4792   ThrowPPException;
4793 }
4794
4795 void Magick::Image::write(Blob *blob_,const std::string &magick_)
4796 {
4797   size_t
4798     length=0;
4799
4800   void
4801     *data;
4802
4803   modifyImage();
4804   magick(magick_);
4805   GetPPException;
4806   data=ImagesToBlob(constImageInfo(),image(),&length,&exceptionInfo);
4807   if (length > 0)
4808     blob_->updateNoCopy(data,length,Blob::MallocAllocator);
4809   ThrowPPException;
4810 }
4811
4812 void Magick::Image::write(Blob *blob_,const std::string &magick_,
4813   const size_t depth_)
4814 {
4815   size_t
4816     length=0;
4817
4818   void
4819     *data;
4820
4821   modifyImage();
4822   magick(magick_);
4823   depth(depth_);
4824   GetPPException;
4825   data=ImagesToBlob(constImageInfo(),image(),&length,&exceptionInfo);
4826   if (length > 0)
4827     blob_->updateNoCopy(data,length,Blob::MallocAllocator);
4828   ThrowPPException;
4829 }
4830
4831 void Magick::Image::write(const ssize_t x_,const ssize_t y_,
4832   const size_t columns_,const size_t rows_,const std::string &map_,
4833   const StorageType type_,void *pixels_)
4834 {
4835   GetPPException;
4836   ExportImagePixels(image(),x_,y_,columns_,rows_,map_.c_str(),type_,pixels_,
4837     &exceptionInfo);
4838   ThrowPPException;
4839 }
4840
4841 void Magick::Image::write(const std::string &imageSpec_)
4842 {
4843   modifyImage();
4844   fileName(imageSpec_);
4845   GetPPException;
4846   WriteImage(constImageInfo(),image(),&exceptionInfo);
4847   ThrowPPException;
4848 }
4849
4850 void Magick::Image::writePixels(const Magick::QuantumType quantum_,
4851   unsigned char *destination_)
4852 {
4853   QuantumInfo
4854     *quantum_info;
4855
4856   quantum_info=AcquireQuantumInfo(imageInfo(),image());
4857   GetPPException;
4858   ExportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
4859     quantum_,destination_, &exceptionInfo);
4860   quantum_info=DestroyQuantumInfo(quantum_info);
4861   ThrowPPException;
4862 }
4863
4864 void Magick::Image::zoom(const Geometry &geometry_)
4865 {
4866   MagickCore::Image
4867     *newImage;
4868
4869   size_t
4870     height=rows(),
4871     width=columns();
4872
4873   ssize_t
4874     x=0,
4875     y=0;
4876
4877   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
4878     &height);
4879
4880   GetPPException;
4881   newImage=ResizeImage(constImage(),width,height,image()->filter,&exceptionInfo);
4882   replaceImage(newImage);
4883   ThrowPPException;
4884 }
4885
4886 Magick::Image::Image(MagickCore::Image *image_)
4887   : _imgRef(new ImageRef(image_))
4888 {
4889 }
4890
4891 MagickCore::Image *&Magick::Image::image(void)
4892 {
4893   return(_imgRef->image());
4894 }
4895
4896 const MagickCore::Image *Magick::Image::constImage(void) const
4897 {
4898   return(_imgRef->image());
4899 }
4900
4901 MagickCore::ImageInfo *Magick::Image::imageInfo(void)
4902 {
4903   return(_imgRef->options()->imageInfo());
4904 }
4905
4906 const MagickCore::ImageInfo *Magick::Image::constImageInfo(void) const
4907 {
4908   return(_imgRef->options()->imageInfo());
4909 }
4910
4911 Magick::Options *Magick::Image::options(void)
4912 {
4913   return(_imgRef->options());
4914 }
4915
4916 const Magick::Options *Magick::Image::constOptions(void) const
4917 {
4918   return(_imgRef->options());
4919 }
4920
4921 MagickCore::QuantizeInfo *Magick::Image::quantizeInfo(void)
4922 {
4923   return(_imgRef->options()->quantizeInfo());
4924 }
4925
4926 const MagickCore::QuantizeInfo *Magick::Image::constQuantizeInfo(void) const
4927 {
4928   return(_imgRef->options()->quantizeInfo());
4929 }
4930
4931 void Magick::Image::modifyImage(void)
4932 {
4933   {
4934     Lock(&_imgRef->_mutexLock);
4935     if (_imgRef->_refCount == 1)
4936       {
4937         // De-register image and return
4938         _imgRef->id(-1);
4939         return;
4940       }
4941   }
4942
4943   GetPPException;
4944   replaceImage(CloneImage(image(),0,0,MagickTrue,&exceptionInfo));
4945   ThrowPPException;
4946 }
4947
4948 ssize_t Magick::Image::registerId(void)
4949 {
4950   Lock(&_imgRef->_mutexLock);
4951   if ( _imgRef->id() < 0)
4952     {
4953       char
4954         id[MaxTextExtent];
4955
4956       GetPPException;
4957       _imgRef->id(_imgRef->id()+1);
4958       sprintf(id,"%.20g\n",(double) _imgRef->id());
4959       SetImageRegistry(ImageRegistryType,id,image(),&exceptionInfo);
4960       ThrowPPException;
4961     }
4962   return(_imgRef->id());
4963 }
4964
4965 MagickCore::Image *Magick::Image::replaceImage(MagickCore::Image *replacement_)
4966 {
4967   MagickCore::Image
4968     *image;
4969
4970   if (replacement_)
4971     image = replacement_;
4972   else
4973     {
4974       GetPPException;
4975       image=AcquireImage(constImageInfo(),&exceptionInfo);
4976       ThrowPPException;
4977     }
4978
4979   {
4980     Lock(&_imgRef->_mutexLock);
4981
4982     if (_imgRef->_refCount == 1)
4983       {
4984         // We own the image, just replace it, and de-register
4985         _imgRef->id(-1);
4986         _imgRef->image(image);
4987       }
4988     else
4989       {
4990         // We don't own the image, dereference and replace with copy
4991         --_imgRef->_refCount;
4992         _imgRef=new ImageRef(image,constOptions());
4993       }
4994   }
4995
4996   return(_imgRef->_image);
4997 }
4998
4999 void Magick::Image::unregisterId(void)
5000 {
5001   modifyImage();
5002   _imgRef->id(-1);
5003 }