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 #if !defined(MAGICKCORE_WINDOWS_SUPPORT)
  18 #include <strings.h>
  19 #endif
  20
  21 using namespace std;
  22
  23 #include "Magick++/Image.h"
  24 #include "Magick++/Functions.h"
  25 #include "Magick++/Pixels.h"
  26 #include "Magick++/Options.h"
  27 #include "Magick++/ImageRef.h"
  28
  29 #define AbsoluteValue(x)  ((x) < 0 ? -(x) : (x))
  30 #define MagickPI  3.14159265358979323846264338327950288419716939937510
  31 #define DegreesToRadians(x)  (MagickPI*(x)/180.0)
  32
  33 MagickDLLDeclExtern const char *Magick::borderGeometryDefault = "6x6+0+0";
  34 MagickDLLDeclExtern const char *Magick::frameGeometryDefault  = "25x25+6+6";
  35 MagickDLLDeclExtern const char *Magick::raiseGeometryDefault  = "6x6+0+0";
  36
  37 static bool magick_initialized=false;
  38
  39 //
  40 // Explicit template instantiations
  41 //
  42
  43 //
  44 // Friend functions to compare Image objects
  45 //
  46
  47 MagickDLLDecl int Magick::operator == ( const Magick::Image& left_,
  48                                         const Magick::Image& right_ )
  49 {
  50   // If image pixels and signature are the same, then the image is identical
  51   return ( ( left_.rows() == right_.rows() ) &&
  52            ( left_.columns() == right_.columns() ) &&
  53            ( left_.signature() == right_.signature() )
  54            );
  55 }
  56 MagickDLLDecl int Magick::operator != ( const Magick::Image& left_,
  57                                         const Magick::Image& right_ )
  58 {
  59   return ( ! (left_ == right_) );
  60 }
  61 MagickDLLDecl int Magick::operator >  ( const Magick::Image& left_,
  62                                         const Magick::Image& right_ )
  63 {
  64   return ( !( left_ < right_ ) && ( left_ != right_ ) );
  65 }
  66 MagickDLLDecl int Magick::operator <  ( const Magick::Image& left_,
  67                                         const Magick::Image& right_ )
  68 {
  69   // If image pixels are less, then image is smaller
  70   return ( ( left_.rows() * left_.columns() ) <
  71            ( right_.rows() * right_.columns() )
  72            );
  73 }
  74 MagickDLLDecl int Magick::operator >= ( const Magick::Image& left_,
  75                                         const Magick::Image& right_ )
  76 {
  77   return ( ( left_ > right_ ) || ( left_ == right_ ) );
  78 }
  79 MagickDLLDecl int Magick::operator <= ( const Magick::Image& left_,
  80                                         const Magick::Image& right_ )
  81 {
  82   return ( ( left_ < right_ ) || ( left_ == right_ ) );
  83 }
  84
  85 //
  86 // Image object implementation
  87 //
  88
  89 // Construct from image file or image specification
  90 Magick::Image::Image( const std::string &imageSpec_ )
  91   : _imgRef(new ImageRef)
  92 {
  93   try
  94     {
  95       // Initialize, Allocate and Read images
  96       read( imageSpec_ );
  97     }
  98   catch ( const Warning & /*warning_*/ )
  99     {
 100       // FIXME: need a way to report warnings in constructor
 101     }
 102   catch ( const Error & /*error_*/ )
 103     {
 104       // Release resources
 105       delete _imgRef;
 106       throw;
 107     }
 108 }
 109
 110 // Construct a blank image canvas of specified size and color
 111 Magick::Image::Image( const Geometry &size_,
 112                       const Color &color_ )
 113   : _imgRef(new ImageRef)
 114 {
 115   // xc: prefix specifies an X11 color string
 116   std::string imageSpec("xc:");
 117   imageSpec += color_;
 118
 119   try
 120     {
 121       // Set image size
 122       size( size_ );
 123
 124       // Initialize, Allocate and Read images
 125       read( imageSpec );
 126     }
 127   catch ( const Warning & /*warning_*/ )
 128     {
 129       // FIXME: need a way to report warnings in constructor
 130     }
 131   catch ( const Error & /*error_*/ )
 132     {
 133       // Release resources
 134       delete _imgRef;
 135       throw;
 136     }
 137 }
 138
 139 // Construct Image from in-memory BLOB
 140 Magick::Image::Image ( const Blob &blob_ )
 141   : _imgRef(new ImageRef)
 142 {
 143   try
 144     {
 145       // Initialize, Allocate and Read images
 146       read( blob_ );
 147     }
 148   catch ( const Warning & /*warning_*/ )
 149     {
 150       // FIXME: need a way to report warnings in constructor
 151     }
 152   catch ( const Error & /*error_*/ )
 153     {
 154       // Release resources
 155       delete _imgRef;
 156       throw;
 157     }
 158 }
 159
 160 // Construct Image of specified size from in-memory BLOB
 161 Magick::Image::Image ( const Blob &blob_,
 162                        const Geometry &size_ )
 163   : _imgRef(new ImageRef)
 164 {
 165   try
 166     {
 167       // Read from Blob
 168       read( blob_, size_ );
 169     }
 170   catch ( const Warning & /*warning_*/ )
 171     {
 172       // FIXME: need a way to report warnings in constructor
 173     }
 174   catch ( const Error & /*error_*/ )
 175     {
 176       // Release resources
 177       delete _imgRef;
 178       throw;
 179     }
 180 }
 181
 182 // Construct Image of specified size and depth from in-memory BLOB
 183 Magick::Image::Image ( const Blob &blob_,
 184                        const Geometry &size_,
 185                        const size_t depth_ )
 186   : _imgRef(new ImageRef)
 187 {
 188   try
 189     {
 190       // Read from Blob
 191       read( blob_, size_, depth_ );
 192     }
 193   catch ( const Warning & /*warning_*/ )
 194     {
 195       // FIXME: need a way to report warnings in constructor
 196     }
 197   catch ( const Error & /*error_*/ )
 198     {
 199       // Release resources
 200       delete _imgRef;
 201       throw;
 202     }
 203 }
 204
 205 // Construct Image of specified size, depth, and format from in-memory BLOB
 206 Magick::Image::Image ( const Blob &blob_,
 207                        const Geometry &size_,
 208                        const size_t depth_,
 209                        const std::string &magick_ )
 210   : _imgRef(new ImageRef)
 211 {
 212   try
 213     {
 214       // Read from Blob
 215       read( blob_, size_, depth_, magick_ );
 216     }
 217   catch ( const Warning & /*warning_*/ )
 218     {
 219       // FIXME: need a way to report warnings in constructor
 220     }
 221   catch ( const Error & /*error_*/ )
 222     {
 223       // Release resources
 224       delete _imgRef;
 225       throw;
 226     }
 227 }
 228
 229 // Construct Image of specified size, and format from in-memory BLOB
 230 Magick::Image::Image ( const Blob &blob_,
 231                        const Geometry &size_,
 232                        const std::string &magick_ )
 233   : _imgRef(new ImageRef)
 234 {
 235   try
 236     {
 237       // Read from Blob
 238       read( blob_, size_, magick_ );
 239     }
 240   catch ( const Warning & /*warning_*/ )
 241     {
 242       // FIXME: need a way to report warnings in constructor
 243     }
 244   catch ( const Error & /*error_*/ )
 245     {
 246       // Release resources
 247       delete _imgRef;
 248       throw;
 249     }
 250 }
 251
 252 // Construct an image based on an array of raw pixels, of specified
 253 // type and mapping, in memory
 254 Magick::Image::Image ( const size_t width_,
 255                        const size_t height_,
 256                        const std::string &map_,
 257                        const StorageType type_,
 258                        const void *pixels_ )
 259   : _imgRef(new ImageRef)
 260 {
 261   try
 262     {
 263       read( width_, height_, map_.c_str(), type_, pixels_ );
 264     }
 265   catch ( const Warning & /*warning_*/ )
 266     {
 267       // FIXME: need a way to report warnings in constructor
 268     }
 269   catch ( const Error & /*error_*/ )
 270     {
 271       // Release resources
 272       delete _imgRef;
 273       throw;
 274     }
 275 }
 276
 277 // Default constructor
 278 Magick::Image::Image( void )
 279   : _imgRef(new ImageRef)
 280 {
 281 }
 282
 283 // Destructor
 284 /* virtual */
 285 Magick::Image::~Image()
 286 {
 287   bool doDelete = false;
 288   {
 289     Lock( &_imgRef->_mutexLock );
 290     if ( --_imgRef->_refCount == 0 )
 291       doDelete = true;
 292   }
 293
 294   if ( doDelete )
 295     {
 296       delete _imgRef;
 297     }
 298   _imgRef = 0;
 299 }
 300
 301 // Adaptive-blur image
 302 void Magick::Image::adaptiveBlur( const double radius_, const double sigma_ )
 303 {
 304   ExceptionInfo exceptionInfo;
 305   GetExceptionInfo( &exceptionInfo );
 306   MagickCore::Image* newImage =
 307     AdaptiveBlurImage( image(), radius_, sigma_, &exceptionInfo);
 308   replaceImage( newImage );
 309   throwException( exceptionInfo );
 310   (void) DestroyExceptionInfo( &exceptionInfo );
 311 }
 312
 313 // Local adaptive threshold image
 314 // http://www.dai.ed.ac.uk/HIPR2/adpthrsh.htm
 315 // Width x height define the size of the pixel neighborhood
 316 // offset = constant to subtract from pixel neighborhood mean
 317 void Magick::Image::adaptiveThreshold ( const size_t width_,
 318                                         const size_t height_,
 319                                         const ssize_t offset_ )
 320 {
 321   ExceptionInfo exceptionInfo;
 322   GetExceptionInfo( &exceptionInfo );
 323   MagickCore::Image* newImage =
 324     AdaptiveThresholdImage( constImage(), width_, height_, offset_, &exceptionInfo );
 325   replaceImage( newImage );
 326   throwException( exceptionInfo );
 327   (void) DestroyExceptionInfo( &exceptionInfo );
 328 }
 329
 330 // Add noise to image
 331 void Magick::Image::addNoise( const NoiseType noiseType_ )
 332 {
 333   ExceptionInfo exceptionInfo;
 334   GetExceptionInfo( &exceptionInfo );
 335   MagickCore::Image* newImage =
 336     AddNoiseImage ( image(),
 337                     noiseType_,
 338                     &exceptionInfo );
 339   replaceImage( newImage );
 340   throwException( exceptionInfo );
 341   (void) DestroyExceptionInfo( &exceptionInfo );
 342 }
 343
 344 void Magick::Image::addNoiseChannel( const ChannelType channel_,
 345                                      const NoiseType noiseType_ )
 346 {
 347   ExceptionInfo exceptionInfo;
 348   GetExceptionInfo( &exceptionInfo );
 349   MagickCore::Image* newImage =
 350     AddNoiseImageChannel ( image(),
 351                            channel_,
 352                            noiseType_,
 353                            &exceptionInfo );
 354   replaceImage( newImage );
 355   throwException( exceptionInfo );
 356   (void) DestroyExceptionInfo( &exceptionInfo );
 357 }
 358
 359 // Affine Transform image
 360 void Magick::Image::affineTransform ( const DrawableAffine &affine_ )
 361 {
 362   ExceptionInfo exceptionInfo;
 363   GetExceptionInfo( &exceptionInfo );
 364
 365   AffineMatrix _affine;
 366   _affine.sx = affine_.sx();
 367   _affine.sy = affine_.sy();
 368   _affine.rx = affine_.rx();
 369   _affine.ry = affine_.ry();
 370   _affine.tx = affine_.tx();
 371   _affine.ty = affine_.ty();
 372
 373   MagickCore::Image* newImage =
 374     AffineTransformImage( image(), &_affine, &exceptionInfo);
 375   replaceImage( newImage );
 376   throwException( exceptionInfo );
 377   (void) DestroyExceptionInfo( &exceptionInfo );
 378 }
 379
 380 // Annotate using specified text, and placement location
 381 void Magick::Image::annotate ( const std::string &text_,
 382                                const Geometry &location_ )
 383 {
 384   annotate ( text_, location_,  NorthWestGravity, 0.0 );
 385 }
 386 // Annotate using specified text, bounding area, and placement gravity
 387 void Magick::Image::annotate ( const std::string &text_,
 388                                const Geometry &boundingArea_,
 389                                const GravityType gravity_ )
 390 {
 391   annotate ( text_, boundingArea_, gravity_, 0.0 );
 392 }
 393 // Annotate with text using specified text, bounding area, placement
 394 // gravity, and rotation.
 395 void Magick::Image::annotate ( const std::string &text_,
 396                                const Geometry &boundingArea_,
 397                                const GravityType gravity_,
 398                                const double degrees_ )
 399 {
 400   modifyImage();
 401
 402   DrawInfo *drawInfo
 403     = options()->drawInfo();
 404
 405   drawInfo->text = const_cast<char *>(text_.c_str());
 406
 407   char boundingArea[MaxTextExtent];
 408
 409   drawInfo->geometry = 0;
 410   if ( boundingArea_.isValid() ){
 411     if ( boundingArea_.width() == 0 || boundingArea_.height() == 0 )
 412       {
 413         FormatMagickString( boundingArea, MaxTextExtent, "%+.20g%+.20g",
 414           (double) boundingArea_.xOff(), (double) boundingArea_.yOff() );
 415       }
 416     else
 417       {
 418         (void) CopyMagickString( boundingArea, string(boundingArea_).c_str(),
 419           MaxTextExtent);
 420       }
 421     drawInfo->geometry = boundingArea;
 422   }
 423
 424   drawInfo->gravity = gravity_;
 425
 426   AffineMatrix oaffine = drawInfo->affine;
 427   if ( degrees_ != 0.0)
 428     {
 429         AffineMatrix affine;
 430         affine.sx=1.0;
 431         affine.rx=0.0;
 432         affine.ry=0.0;
 433         affine.sy=1.0;
 434         affine.tx=0.0;
 435         affine.ty=0.0;
 436
 437         AffineMatrix current = drawInfo->affine;
 438         affine.sx=cos(DegreesToRadians(fmod(degrees_,360.0)));
 439         affine.rx=sin(DegreesToRadians(fmod(degrees_,360.0)));
 440         affine.ry=(-sin(DegreesToRadians(fmod(degrees_,360.0))));
 441         affine.sy=cos(DegreesToRadians(fmod(degrees_,360.0)));
 442
 443         drawInfo->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
 444         drawInfo->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
 445         drawInfo->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
 446         drawInfo->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
 447         drawInfo->affine.tx=current.sx*affine.tx+current.ry*affine.ty
 448           +current.tx;
 449     }
 450
 451   AnnotateImage( image(), drawInfo );
 452
 453   // Restore original values
 454   drawInfo->affine = oaffine;
 455   drawInfo->text = 0;
 456   drawInfo->geometry = 0;
 457
 458   throwImageException();
 459 }
 460 // Annotate with text (bounding area is entire image) and placement gravity.
 461 void Magick::Image::annotate ( const std::string &text_,
 462                                const GravityType gravity_ )
 463 {
 464   modifyImage();
 465
 466   DrawInfo *drawInfo
 467     = options()->drawInfo();
 468
 469   drawInfo->text = const_cast<char *>(text_.c_str());
 470
 471   drawInfo->gravity = gravity_;
 472
 473   AnnotateImage( image(), drawInfo );
 474
 475   drawInfo->gravity = NorthWestGravity;
 476   drawInfo->text = 0;
 477
 478   throwImageException();
 479 }
 480
 481 // Blur image
 482 void Magick::Image::blur( const double radius_, const double sigma_ )
 483 {
 484   ExceptionInfo exceptionInfo;
 485   GetExceptionInfo( &exceptionInfo );
 486   MagickCore::Image* newImage =
 487     BlurImage( image(), radius_, sigma_, &exceptionInfo);
 488   replaceImage( newImage );
 489   throwException( exceptionInfo );
 490   (void) DestroyExceptionInfo( &exceptionInfo );
 491 }
 492
 493 void Magick::Image::blurChannel( const ChannelType channel_,
 494                                  const double radius_, const double sigma_ )
 495 {
 496   ExceptionInfo exceptionInfo;
 497   GetExceptionInfo( &exceptionInfo );
 498   MagickCore::Image* newImage =
 499     BlurImageChannel( image(), channel_,radius_, sigma_, &exceptionInfo);
 500   replaceImage( newImage );
 501   throwException( exceptionInfo );
 502   (void) DestroyExceptionInfo( &exceptionInfo );
 503 }
 504
 505 // Add border to image
 506 // Only uses width & height
 507 void Magick::Image::border( const Geometry &geometry_ )
 508 {
 509   RectangleInfo borderInfo = geometry_;
 510   ExceptionInfo exceptionInfo;
 511   GetExceptionInfo( &exceptionInfo );
 512   MagickCore::Image* newImage =
 513     BorderImage( image(), &borderInfo, &exceptionInfo);
 514   replaceImage( newImage );
 515   throwException( exceptionInfo );
 516   (void) DestroyExceptionInfo( &exceptionInfo );
 517 }
 518
 519 // Extract channel from image
 520 void Magick::Image::channel ( const ChannelType channel_ )
 521 {
 522   modifyImage();
 523   SeparateImageChannel ( image(), channel_ );
 524   throwImageException();
 525 }
 526
 527 // Set or obtain modulus channel depth
 528 void Magick::Image::channelDepth ( const ChannelType channel_,
 529                                    const size_t depth_)
 530 {
 531   modifyImage();
 532   SetImageChannelDepth( image(), channel_, depth_);
 533   throwImageException();
 534 }
 535 size_t Magick::Image::channelDepth ( const ChannelType channel_ )
 536 {
 537   size_t channel_depth;
 538
 539   ExceptionInfo exceptionInfo;
 540   GetExceptionInfo( &exceptionInfo );
 541   channel_depth=GetImageChannelDepth( constImage(), channel_,
 542                                       &exceptionInfo );
 543   throwException( exceptionInfo );
 544   (void) DestroyExceptionInfo( &exceptionInfo );
 545   return channel_depth;
 546 }
 547
 548
 549 // Charcoal-effect image
 550 void Magick::Image::charcoal( const double radius_, const double sigma_ )
 551 {
 552   ExceptionInfo exceptionInfo;
 553   GetExceptionInfo( &exceptionInfo );
 554   MagickCore::Image* newImage =
 555     CharcoalImage( image(), radius_, sigma_, &exceptionInfo );
 556   replaceImage( newImage );
 557   throwException( exceptionInfo );
 558   (void) DestroyExceptionInfo( &exceptionInfo );
 559 }
 560
 561 // Chop image
 562 void Magick::Image::chop( const Geometry &geometry_ )
 563 {
 564   RectangleInfo chopInfo = geometry_;
 565   ExceptionInfo exceptionInfo;
 566   GetExceptionInfo( &exceptionInfo );
 567   MagickCore::Image* newImage =
 568     ChopImage( image(), &chopInfo, &exceptionInfo);
 569   replaceImage( newImage );
 570   throwException( exceptionInfo );
 571   (void) DestroyExceptionInfo( &exceptionInfo );
 572 }
 573
 574 // contains one or more color corrections and applies the correction to the
 575 // image.
 576 void Magick::Image::cdl ( const std::string &cdl_ )
 577 {
 578   modifyImage();
 579   (void) ColorDecisionListImage( image(), cdl_.c_str() );
 580   throwImageException();
 581 }
 582
 583 // Colorize
 584 void Magick::Image::colorize ( const unsigned int opacityRed_,
 585                                const unsigned int opacityGreen_,
 586                                const unsigned int opacityBlue_,
 587                                const Color &penColor_ )
 588 {
 589   if ( !penColor_.isValid() )
 590   {
 591     throwExceptionExplicit( OptionError,
 592                             "Pen color argument is invalid");
 593   }
 594
 595   char opacity[MaxTextExtent];
 596   FormatMagickString(opacity,MaxTextExtent,"%u/%u/%u",opacityRed_,opacityGreen_,opacityBlue_);
 597
 598   ExceptionInfo exceptionInfo;
 599   GetExceptionInfo( &exceptionInfo );
 600   MagickCore::Image* newImage =
 601   ColorizeImage ( image(), opacity,
 602                   penColor_, &exceptionInfo );
 603   replaceImage( newImage );
 604   throwException( exceptionInfo );
 605   (void) DestroyExceptionInfo( &exceptionInfo );
 606 }
 607 void Magick::Image::colorize ( const unsigned int opacity_,
 608                                const Color &penColor_ )
 609 {
 610   colorize( opacity_, opacity_, opacity_, penColor_ );
 611 }
 612
 613 // Apply a color matrix to the image channels.  The user supplied
 614 // matrix may be of order 1 to 6 (1x1 through 6x6).
 615 void Magick::Image::colorMatrix (const size_t order_,
 616          const double *color_matrix_)
 617 {
 618   KernelInfo
 619     *kernel_info;
 620
 621   ExceptionInfo exceptionInfo;
 622   GetExceptionInfo( &exceptionInfo );
 623     kernel_info=AcquireKernelInfo("1");
 624   kernel_info->width=order_;
 625   kernel_info->height=order_;
 626   kernel_info->values=(double *) color_matrix_;
 627   MagickCore::Image* newImage =
 628     ColorMatrixImage( image(), kernel_info, &exceptionInfo );
 629   kernel_info->values=(double *) NULL;
 630   kernel_info=DestroyKernelInfo(kernel_info);
 631   replaceImage( newImage );
 632   throwException( exceptionInfo );
 633   (void) DestroyExceptionInfo( &exceptionInfo );
 634 }
 635
 636 // Compare current image with another image
 637 // Sets meanErrorPerPixel, normalizedMaxError, and normalizedMeanError
 638 // in the current image. False is returned if the images are identical.
 639 bool Magick::Image::compare ( const Image &reference_ )
 640 {
 641   modifyImage();
 642   Image ref = reference_;
 643   ref.modifyImage();
 644   return static_cast<bool>(IsImagesEqual(image(), ref.image()));
 645 }
 646
 647 // Composite two images
 648 void Magick::Image::composite ( const Image &compositeImage_,
 649                                 const ssize_t xOffset_,
 650                                 const ssize_t yOffset_,
 651                                 const CompositeOperator compose_ )
 652 {
 653   // Image supplied as compositeImage is composited with current image and
 654   // results in updating current image.
 655   modifyImage();
 656
 657   CompositeImage( image(),
 658                   compose_,
 659                   compositeImage_.constImage(),
 660                   xOffset_,
 661                   yOffset_ );
 662   throwImageException();
 663 }
 664 void Magick::Image::composite ( const Image &compositeImage_,
 665                                 const Geometry &offset_,
 666                                 const CompositeOperator compose_ )
 667 {
 668   modifyImage();
 669
 670   ssize_t x = offset_.xOff();
 671   ssize_t y = offset_.yOff();
 672   size_t width = columns();
 673   size_t height = rows();
 674
 675   ParseMetaGeometry (static_cast<std::string>(offset_).c_str(),
 676                       &x, &y,
 677                       &width, &height );
 678
 679   CompositeImage( image(),
 680                   compose_,
 681                   compositeImage_.constImage(),
 682                   x, y );
 683   throwImageException();
 684 }
 685 void Magick::Image::composite ( const Image &compositeImage_,
 686                                 const GravityType gravity_,
 687                                 const CompositeOperator compose_ )
 688 {
 689   modifyImage();
 690
 691   RectangleInfo geometry;
 692
 693   SetGeometry(compositeImage_.constImage(), &geometry);
 694   GravityAdjustGeometry(columns(), rows(), gravity_, &geometry);
 695
 696   CompositeImage( image(),
 697                   compose_,
 698                   compositeImage_.constImage(),
 699                   geometry.x, geometry.y );
 700   throwImageException();
 701 }
 702
 703 // Contrast image
 704 void Magick::Image::contrast ( const size_t sharpen_ )
 705 {
 706   modifyImage();
 707   ContrastImage ( image(), (MagickBooleanType) sharpen_ );
 708   throwImageException();
 709 }
 710
 711 // Convolve image.  Applies a general image convolution kernel to the image.
 712 //  order_ represents the number of columns and rows in the filter kernel.
 713 //  kernel_ is an array of doubles representing the convolution kernel.
 714 void Magick::Image::convolve ( const size_t order_,
 715                                const double *kernel_ )
 716 {
 717   ExceptionInfo exceptionInfo;
 718   GetExceptionInfo( &exceptionInfo );
 719   MagickCore::Image* newImage =
 720   ConvolveImage ( image(), order_,
 721                   kernel_, &exceptionInfo );
 722   replaceImage( newImage );
 723   throwException( exceptionInfo );
 724   (void) DestroyExceptionInfo( &exceptionInfo );
 725 }
 726
 727 // Crop image
 728 void Magick::Image::crop ( const Geometry &geometry_ )
 729 {
 730   RectangleInfo cropInfo = geometry_;
 731   ExceptionInfo exceptionInfo;
 732   GetExceptionInfo( &exceptionInfo );
 733   MagickCore::Image* newImage =
 734     CropImage( image(),
 735                &cropInfo,
 736                &exceptionInfo);
 737   replaceImage( newImage );
 738   throwException( exceptionInfo );
 739   (void) DestroyExceptionInfo( &exceptionInfo );
 740 }
 741
 742 // Cycle Color Map
 743 void Magick::Image::cycleColormap ( const ssize_t amount_ )
 744 {
 745   modifyImage();
 746   CycleColormapImage( image(), amount_ );
 747   throwImageException();
 748 }
 749
 750 // Despeckle
 751 void Magick::Image::despeckle ( void )
 752 {
 753   ExceptionInfo exceptionInfo;
 754   GetExceptionInfo( &exceptionInfo );
 755   MagickCore::Image* newImage =
 756     DespeckleImage( image(), &exceptionInfo );
 757   replaceImage( newImage );
 758   throwException( exceptionInfo );
 759   (void) DestroyExceptionInfo( &exceptionInfo );
 760 }
 761
 762 // Display image
 763 void Magick::Image::display( void )
 764 {
 765   DisplayImages( imageInfo(), image() );
 766 }
 767
 768 // Distort image.  distorts an image using various distortion methods, by
 769 // mapping color lookups of the source image to a new destination image
 770 // usally of the same size as the source image, unless 'bestfit' is set to
 771 // true.
 772 void Magick::Image::distort ( const DistortImageMethod method_,
 773                               const size_t number_arguments_,
 774                               const double *arguments_,
 775                               const bool bestfit_ )
 776 {
 777   ExceptionInfo exceptionInfo;
 778   GetExceptionInfo( &exceptionInfo );
 779   MagickCore::Image* newImage = DistortImage ( image(), method_,
 780     number_arguments_, arguments_, bestfit_ == true ? MagickTrue : MagickFalse,
 781     &exceptionInfo );
 782   replaceImage( newImage );
 783   throwException( exceptionInfo );
 784   (void) DestroyExceptionInfo( &exceptionInfo );
 785 }
 786
 787 // Draw on image using single drawable
 788 void Magick::Image::draw ( const Magick::Drawable &drawable_ )
 789 {
 790   modifyImage();
 791
 792   DrawingWand *wand = DrawAllocateWand( options()->drawInfo(), image());
 793
 794   if(wand)
 795     {
 796       drawable_.operator()(wand);
 797
 798       if( constImage()->exception.severity == UndefinedException)
 799         DrawRender(wand);
 800
 801       wand=DestroyDrawingWand(wand);
 802     }
 803
 804   throwImageException();
 805 }
 806
 807 // Draw on image using a drawable list
 808 void Magick::Image::draw ( const std::list<Magick::Drawable> &drawable_ )
 809 {
 810   modifyImage();
 811
 812   DrawingWand *wand = DrawAllocateWand( options()->drawInfo(), image());
 813
 814   if(wand)
 815     {
 816       for( std::list<Magick::Drawable>::const_iterator p = drawable_.begin();
 817            p != drawable_.end(); p++ )
 818         {
 819           p->operator()(wand);
 820           if( constImage()->exception.severity != UndefinedException)
 821             break;
 822         }
 823
 824       if( constImage()->exception.severity == UndefinedException)
 825         DrawRender(wand);
 826
 827       wand=DestroyDrawingWand(wand);
 828     }
 829
 830   throwImageException();
 831 }
 832
 833 // Hilight edges in image
 834 void Magick::Image::edge ( const double radius_ )
 835 {
 836   ExceptionInfo exceptionInfo;
 837   GetExceptionInfo( &exceptionInfo );
 838   MagickCore::Image* newImage =
 839     EdgeImage( image(), radius_, &exceptionInfo );
 840   replaceImage( newImage );
 841   throwException( exceptionInfo );
 842   (void) DestroyExceptionInfo( &exceptionInfo );
 843 }
 844
 845 // Emboss image (hilight edges)
 846 void Magick::Image::emboss ( const double radius_, const double sigma_ )
 847 {
 848   ExceptionInfo exceptionInfo;
 849   GetExceptionInfo( &exceptionInfo );
 850   MagickCore::Image* newImage =
 851     EmbossImage( image(), radius_, sigma_, &exceptionInfo );
 852   replaceImage( newImage );
 853   throwException( exceptionInfo );
 854   (void) DestroyExceptionInfo( &exceptionInfo );
 855 }
 856
 857 // Enhance image (minimize noise)
 858 void Magick::Image::enhance ( void )
 859 {
 860   ExceptionInfo exceptionInfo;
 861   GetExceptionInfo( &exceptionInfo );
 862   MagickCore::Image* newImage =
 863     EnhanceImage( image(), &exceptionInfo );
 864   replaceImage( newImage );
 865   throwException( exceptionInfo );
 866   (void) DestroyExceptionInfo( &exceptionInfo );
 867 }
 868
 869 // Equalize image (histogram equalization)
 870 void Magick::Image::equalize ( void )
 871 {
 872   modifyImage();
 873   EqualizeImage( image() );
 874   throwImageException();
 875 }
 876
 877 // Erase image to current "background color"
 878 void Magick::Image::erase ( void )
 879 {
 880   modifyImage();
 881   SetImageBackgroundColor( image() );
 882   throwImageException();
 883 }
 884
 885 // Extends image as defined by the geometry.
 886 //
 887 void Magick::Image::extent ( const Geometry &geometry_ )
 888 {
 889   RectangleInfo extentInfo = geometry_;
 890   modifyImage();
 891   ExceptionInfo exceptionInfo;
 892   GetExceptionInfo( &exceptionInfo );
 893   MagickCore::Image* newImage =
 894     ExtentImage ( image(), &extentInfo, &exceptionInfo );
 895   replaceImage( newImage );
 896   throwException( exceptionInfo );
 897   (void) DestroyExceptionInfo( &exceptionInfo );
 898 }
 899 void Magick::Image::extent ( const Geometry &geometry_, const Color &backgroundColor_ )
 900 {
 901   backgroundColor ( backgroundColor_ );
 902   extent ( geometry_ );
 903 }
 904 void Magick::Image::extent ( const Geometry &geometry_, const GravityType gravity_ )
 905 {
 906   image()->gravity  = gravity_;
 907   extent ( geometry_ );
 908 }
 909 void Magick::Image::extent ( const Geometry &geometry_, const Color &backgroundColor_, const GravityType gravity_ )
 910 {
 911   image()->gravity  = gravity_;
 912   backgroundColor ( backgroundColor_ );
 913   extent ( geometry_ );
 914 }
 915
 916 // Flip image (reflect each scanline in the vertical direction)
 917 void Magick::Image::flip ( void )
 918 {
 919   ExceptionInfo exceptionInfo;
 920   GetExceptionInfo( &exceptionInfo );
 921   MagickCore::Image* newImage =
 922     FlipImage( image(), &exceptionInfo );
 923   replaceImage( newImage );
 924   throwException( exceptionInfo );
 925   (void) DestroyExceptionInfo( &exceptionInfo );
 926 }
 927
 928 // Flood-fill color across pixels that match the color of the
 929 // target pixel and are neighbors of the target pixel.
 930 // Uses current fuzz setting when determining color match.
 931 void Magick::Image::floodFillColor( const ssize_t x_,
 932                                     const ssize_t y_,
 933                                     const Magick::Color &fillColor_ )
 934 {
 935   floodFillTexture( x_, y_, Image( Geometry( 1, 1), fillColor_ ) );
 936 }
 937 void Magick::Image::floodFillColor( const Geometry &point_,
 938                                     const Magick::Color &fillColor_ )
 939 {
 940   floodFillTexture( point_, Image( Geometry( 1, 1), fillColor_) );
 941 }
 942
 943 // Flood-fill color across pixels starting at target-pixel and
 944 // stopping at pixels matching specified border color.
 945 // Uses current fuzz setting when determining color match.
 946 void Magick::Image::floodFillColor( const ssize_t x_,
 947                                     const ssize_t y_,
 948                                     const Magick::Color &fillColor_,
 949                                     const Magick::Color &borderColor_ )
 950 {
 951   floodFillTexture( x_, y_, Image( Geometry( 1, 1), fillColor_),
 952                     borderColor_ );
 953 }
 954 void Magick::Image::floodFillColor( const Geometry &point_,
 955                                     const Magick::Color &fillColor_,
 956                                     const Magick::Color &borderColor_ )
 957 {
 958   floodFillTexture( point_, Image( Geometry( 1, 1), fillColor_),
 959                     borderColor_ );
 960 }
 961
 962 // Floodfill pixels matching color (within fuzz factor) of target
 963 // pixel(x,y) with replacement opacity value using method.
 964 void Magick::Image::floodFillOpacity( const ssize_t x_,
 965                                       const ssize_t y_,
 966                                       const unsigned int opacity_,
 967                                       const PaintMethod method_ )
 968 {
 969   modifyImage();
 970   MagickPixelPacket target;
 971   GetMagickPixelPacket(image(),&target);
 972   PixelPacket pixel=static_cast<PixelPacket>(pixelColor(x_,y_));
 973   target.red=pixel.red;
 974   target.green=pixel.green;
 975   target.blue=pixel.blue;
 976   target.opacity=opacity_;
 977   FloodfillPaintImage ( image(),
 978                         DefaultChannels,
 979                         options()->drawInfo(), // const DrawInfo *draw_info
 980                         &target,
 981                                         static_cast<ssize_t>(x_), static_cast<ssize_t>(y_),
 982                         method_  == FloodfillMethod ? MagickFalse : MagickTrue);
 983   throwImageException();
 984 }
 985
 986 // Flood-fill texture across pixels that match the color of the
 987 // target pixel and are neighbors of the target pixel.
 988 // Uses current fuzz setting when determining color match.
 989 void Magick::Image::floodFillTexture( const ssize_t x_,
 990                                       const ssize_t y_,
 991                                       const Magick::Image &texture_ )
 992 {
 993   modifyImage();
 994
 995   // Set drawing pattern
 996   options()->fillPattern(texture_.constImage());
 997
 998   // Get pixel view
 999   Pixels pixels(*this);
1000   // Fill image
1001   PixelPacket *p = pixels.get(x_, y_, 1, 1 );
1002   MagickPixelPacket target;
1003   GetMagickPixelPacket(constImage(),&target);
1004   target.red=p->red;
1005   target.green=p->green;
1006   target.blue=p->blue;
1007   if (p)
1008     FloodfillPaintImage ( image(), // Image *image
1009                           DefaultChannels,
1010                           options()->drawInfo(), // const DrawInfo *draw_info
1011                           &target, // const MagickPacket target
1012                           static_cast<ssize_t>(x_), // const ssize_t x_offset
1013                           static_cast<ssize_t>(y_), // const ssize_t y_offset
1014                           MagickFalse // const PaintMethod method
1015       );
1016
1017   throwImageException();
1018 }
1019 void Magick::Image::floodFillTexture( const Magick::Geometry &point_,
1020                                       const Magick::Image &texture_ )
1021 {
1022   floodFillTexture( point_.xOff(), point_.yOff(), texture_ );
1023 }
1024
1025 // Flood-fill texture across pixels starting at target-pixel and
1026 // stopping at pixels matching specified border color.
1027 // Uses current fuzz setting when determining color match.
1028 void Magick::Image::floodFillTexture( const ssize_t x_,
1029                                       const ssize_t y_,
1030                                       const Magick::Image &texture_,
1031                                       const Magick::Color &borderColor_ )
1032 {
1033   modifyImage();
1034
1035   // Set drawing fill pattern
1036   options()->fillPattern(texture_.constImage());
1037
1038   MagickPixelPacket target;
1039   GetMagickPixelPacket(constImage(),&target);
1040   target.red=static_cast<PixelPacket>(borderColor_).red;
1041   target.green=static_cast<PixelPacket>(borderColor_).green;
1042   target.blue=static_cast<PixelPacket>(borderColor_).blue;
1043   FloodfillPaintImage ( image(),
1044                         DefaultChannels,
1045                         options()->drawInfo(),
1046                         &target,
1047                         static_cast<ssize_t>(x_),
1048                         static_cast<ssize_t>(y_),
1049                         MagickTrue);
1050
1051   throwImageException();
1052 }
1053 void  Magick::Image::floodFillTexture( const Magick::Geometry &point_,
1054                                        const Magick::Image &texture_,
1055                                        const Magick::Color &borderColor_ )
1056 {
1057   floodFillTexture( point_.xOff(), point_.yOff(), texture_, borderColor_ );
1058 }
1059
1060 // Flop image (reflect each scanline in the horizontal direction)
1061 void Magick::Image::flop ( void )
1062 {
1063   ExceptionInfo exceptionInfo;
1064   GetExceptionInfo( &exceptionInfo );
1065   MagickCore::Image* newImage =
1066     FlopImage( image(), &exceptionInfo );
1067   replaceImage( newImage );
1068   throwException( exceptionInfo );
1069   (void) DestroyExceptionInfo( &exceptionInfo );
1070 }
1071
1072 // Frame image
1073 void Magick::Image::frame ( const Geometry &geometry_ )
1074 {
1075   FrameInfo info;
1076
1077   info.x           = static_cast<ssize_t>(geometry_.width());
1078   info.y           = static_cast<ssize_t>(geometry_.height());
1079   info.width       = columns() + ( static_cast<size_t>(info.x) << 1 );
1080   info.height      = rows() + ( static_cast<size_t>(info.y) << 1 );
1081   info.outer_bevel = geometry_.xOff();
1082   info.inner_bevel = geometry_.yOff();
1083
1084   ExceptionInfo exceptionInfo;
1085   GetExceptionInfo( &exceptionInfo );
1086   MagickCore::Image* newImage =
1087     FrameImage( image(), &info, &exceptionInfo );
1088   replaceImage( newImage );
1089   throwException( exceptionInfo );
1090   (void) DestroyExceptionInfo( &exceptionInfo );
1091 }
1092 void Magick::Image::frame ( const size_t width_,
1093                             const size_t height_,
1094                             const ssize_t outerBevel_, const ssize_t innerBevel_ )
1095 {
1096   FrameInfo info;
1097   info.x           = static_cast<ssize_t>(width_);
1098   info.y           = static_cast<ssize_t>(height_);
1099   info.width       = columns() + ( static_cast<size_t>(info.x) << 1 );
1100   info.height      = rows() + ( static_cast<size_t>(info.y) << 1 );
1101   info.outer_bevel = static_cast<ssize_t>(outerBevel_);
1102   info.inner_bevel = static_cast<ssize_t>(innerBevel_);
1103
1104   ExceptionInfo exceptionInfo;
1105   GetExceptionInfo( &exceptionInfo );
1106   MagickCore::Image* newImage =
1107     FrameImage( image(), &info, &exceptionInfo );
1108   replaceImage( newImage );
1109   throwException( exceptionInfo );
1110   (void) DestroyExceptionInfo( &exceptionInfo );
1111 }
1112
1113 // Fx image.  Applies a mathematical expression to the image.
1114 void Magick::Image::fx ( const std::string expression )
1115 {
1116   ExceptionInfo exceptionInfo;
1117   GetExceptionInfo( &exceptionInfo );
1118   MagickCore::Image* newImage =
1119     FxImageChannel ( image(), DefaultChannels, expression.c_str(), &exceptionInfo );
1120   replaceImage( newImage );
1121   throwException( exceptionInfo );
1122   (void) DestroyExceptionInfo( &exceptionInfo );
1123 }
1124 void Magick::Image::fx ( const std::string expression,
1125                          const Magick::ChannelType channel )
1126 {
1127   ExceptionInfo exceptionInfo;
1128   GetExceptionInfo( &exceptionInfo );
1129   MagickCore::Image* newImage =
1130     FxImageChannel ( image(), channel, expression.c_str(), &exceptionInfo );
1131   replaceImage( newImage );
1132   throwException( exceptionInfo );
1133   (void) DestroyExceptionInfo( &exceptionInfo );
1134 }
1135
1136 // Gamma correct image
1137 void Magick::Image::gamma ( const double gamma_ )
1138 {
1139   char gamma[MaxTextExtent + 1];
1140   FormatMagickString( gamma, MaxTextExtent, "%3.6f", gamma_);
1141
1142   modifyImage();
1143   GammaImage ( image(), gamma );
1144 }
1145
1146 void Magick::Image::gamma ( const double gammaRed_,
1147                             const double gammaGreen_,
1148                             const double gammaBlue_ )
1149 {
1150   char gamma[MaxTextExtent + 1];
1151   FormatMagickString( gamma, MaxTextExtent, "%3.6f/%3.6f/%3.6f/",
1152                 gammaRed_, gammaGreen_, gammaBlue_);
1153
1154   modifyImage();
1155   GammaImage ( image(), gamma );
1156   throwImageException();
1157 }
1158
1159 // Gaussian blur image
1160 // The number of neighbor pixels to be included in the convolution
1161 // mask is specified by 'width_'. The standard deviation of the
1162 // gaussian bell curve is specified by 'sigma_'.
1163 void Magick::Image::gaussianBlur ( const double width_, const double sigma_ )
1164 {
1165   ExceptionInfo exceptionInfo;
1166   GetExceptionInfo( &exceptionInfo );
1167   MagickCore::Image* newImage =
1168     GaussianBlurImage( image(), width_, sigma_, &exceptionInfo );
1169   replaceImage( newImage );
1170   throwException( exceptionInfo );
1171   (void) DestroyExceptionInfo( &exceptionInfo );
1172 }
1173
1174 void Magick::Image::gaussianBlurChannel ( const ChannelType channel_,
1175                                           const double width_,
1176                                           const double sigma_ )
1177 {
1178   ExceptionInfo exceptionInfo;
1179   GetExceptionInfo( &exceptionInfo );
1180   MagickCore::Image* newImage =
1181     GaussianBlurImageChannel( image(), channel_, width_, sigma_, &exceptionInfo );
1182   replaceImage( newImage );
1183   throwException( exceptionInfo );
1184   (void) DestroyExceptionInfo( &exceptionInfo );
1185 }
1186
1187 // Apply a color lookup table (Hald CLUT) to the image.
1188 void  Magick::Image::haldClut ( const Image &clutImage_ )
1189 {
1190   modifyImage();
1191   (void) HaldClutImage( image(), clutImage_.constImage() );
1192   throwImageException();
1193 }
1194
1195 // Implode image
1196 void Magick::Image::implode ( const double factor_ )
1197 {
1198   ExceptionInfo exceptionInfo;
1199   GetExceptionInfo( &exceptionInfo );
1200   MagickCore::Image* newImage =
1201     ImplodeImage( image(), factor_, &exceptionInfo );
1202   replaceImage( newImage );
1203   throwException( exceptionInfo );
1204   (void) DestroyExceptionInfo( &exceptionInfo );
1205 }
1206
1207 // implements the inverse discrete Fourier transform (IFT) of the image either
1208 // as a magnitude / phase or real / imaginary image pair.
1209 void Magick::Image::inverseFourierTransform ( const Image &phase_ )
1210 {
1211   ExceptionInfo exceptionInfo;
1212   GetExceptionInfo( &exceptionInfo );
1213   MagickCore::Image* newImage = InverseFourierTransformImage( image(),
1214                  phase_.constImage(), MagickTrue, &exceptionInfo);
1215   replaceImage( newImage );
1216   throwException( exceptionInfo );
1217   (void) DestroyExceptionInfo( &exceptionInfo );
1218 }
1219 void Magick::Image::inverseFourierTransform ( const Image &phase_,
1220    const bool magnitude_ )
1221 {
1222   ExceptionInfo exceptionInfo;
1223   GetExceptionInfo( &exceptionInfo );
1224   MagickCore::Image* newImage = InverseFourierTransformImage( image(),
1225                  phase_.constImage(), magnitude_ == true ? MagickTrue : MagickFalse,
1226      &exceptionInfo);
1227   replaceImage( newImage );
1228   throwException( exceptionInfo );
1229   (void) DestroyExceptionInfo( &exceptionInfo );
1230 }
1231
1232 // Level image. Adjust the levels of the image by scaling the colors
1233 // falling between specified white and black points to the full
1234 // available quantum range. The parameters provided represent the
1235 // black, mid (gamma), and white points.  The black point specifies
1236 // the darkest color in the image. Colors darker than the black point
1237 // are set to zero. Mid point (gamma) specifies a gamma correction to
1238 // apply to the image. White point specifies the lightest color in the
1239 // image.  Colors brighter than the white point are set to the maximum
1240 // quantum value. The black and white point have the valid range 0 to
1241 // QuantumRange while gamma has a useful range of 0 to ten.
1242 void Magick::Image::level ( const double black_point,
1243                             const double white_point,
1244                             const double gamma )
1245 {
1246   modifyImage();
1247   char levels[MaxTextExtent];
1248   FormatMagickString( levels, MaxTextExtent, "%g,%g,%g",black_point,white_point,gamma);
1249   (void) LevelImage( image(), levels );
1250   throwImageException();
1251 }
1252
1253 // Level image channel. Adjust the levels of the image channel by
1254 // scaling the values falling between specified white and black points
1255 // to the full available quantum range. The parameters provided
1256 // represent the black, mid (gamma), and white points.  The black
1257 // point specifies the darkest color in the image. Colors darker than
1258 // the black point are set to zero. Mid point (gamma) specifies a
1259 // gamma correction to apply to the image. White point specifies the
1260 // lightest color in the image.  Colors brighter than the white point
1261 // are set to the maximum quantum value. The black and white point
1262 // have the valid range 0 to QuantumRange while gamma has a useful range of
1263 // 0 to ten.
1264 void  Magick::Image::levelChannel ( const Magick::ChannelType channel,
1265                                     const double black_point,
1266                                     const double white_point,
1267                                     const double gamma )
1268 {
1269   modifyImage();
1270   (void) LevelImageChannel( image(), channel, black_point, white_point,
1271                             gamma );
1272   throwImageException();
1273 }
1274
1275 // Magnify image by integral size
1276 void Magick::Image::magnify ( void )
1277 {
1278   ExceptionInfo exceptionInfo;
1279   GetExceptionInfo( &exceptionInfo );
1280   MagickCore::Image* newImage =
1281     MagnifyImage( image(), &exceptionInfo );
1282   replaceImage( newImage );
1283   throwException( exceptionInfo );
1284   (void) DestroyExceptionInfo( &exceptionInfo );
1285 }
1286
1287 // Remap image colors with closest color from reference image
1288 void Magick::Image::map ( const Image &mapImage_ , const bool dither_ )
1289 {
1290   modifyImage();
1291   options()->quantizeDither( dither_ );
1292   RemapImage ( options()->quantizeInfo(), image(),
1293              mapImage_.constImage());
1294   throwImageException();
1295 }
1296 // Floodfill designated area with replacement opacity value
1297 void Magick::Image::matteFloodfill ( const Color &target_ ,
1298                                      const unsigned int opacity_,
1299                                      const ssize_t x_, const ssize_t y_,
1300                                      const Magick::PaintMethod method_ )
1301 {
1302   modifyImage();
1303   MagickPixelPacket target;
1304   GetMagickPixelPacket(constImage(),&target);
1305   target.red=static_cast<PixelPacket>(target_).red;
1306   target.green=static_cast<PixelPacket>(target_).green;
1307   target.blue=static_cast<PixelPacket>(target_).blue;
1308   target.opacity=opacity_;
1309   FloodfillPaintImage ( image(), OpacityChannel, options()->drawInfo(), &target,
1310     x_, y_, method_ == FloodfillMethod ? MagickFalse : MagickTrue);
1311   throwImageException();
1312 }
1313
1314 // Filter image by replacing each pixel component with the median
1315 // color in a circular neighborhood
1316 void Magick::Image::medianFilter ( const double radius_ )
1317 {
1318   ExceptionInfo exceptionInfo;
1319   GetExceptionInfo( &exceptionInfo );
1320   MagickCore::Image* newImage =
1321     StatisticImage ( image(), MedianStatistic, (size_t) radius_, (size_t)
1322     radius_,&exceptionInfo );
1323   replaceImage( newImage );
1324   throwException( exceptionInfo );
1325   (void) DestroyExceptionInfo( &exceptionInfo );
1326 }
1327
1328 // Reduce image by integral size
1329 void Magick::Image::minify ( void )
1330 {
1331   ExceptionInfo exceptionInfo;
1332   GetExceptionInfo( &exceptionInfo );
1333   MagickCore::Image* newImage =
1334     MinifyImage( image(), &exceptionInfo );
1335   replaceImage( newImage );
1336   throwException( exceptionInfo );
1337   (void) DestroyExceptionInfo( &exceptionInfo );
1338 }
1339
1340 // Modulate percent hue, saturation, and brightness of an image
1341 void Magick::Image::modulate ( const double brightness_,
1342                                const double saturation_,
1343                                const double hue_ )
1344 {
1345   char modulate[MaxTextExtent + 1];
1346   FormatMagickString( modulate, MaxTextExtent, "%3.6f,%3.6f,%3.6f",
1347                 brightness_, saturation_, hue_);
1348
1349   modifyImage();
1350   ModulateImage( image(), modulate );
1351   throwImageException();
1352 }
1353
1354 // Motion blur image with specified blur factor
1355 // The radius_ parameter specifies the radius of the Gaussian, in
1356 // pixels, not counting the center pixel.  The sigma_ parameter
1357 // specifies the standard deviation of the Laplacian, in pixels.
1358 // The angle_ parameter specifies the angle the object appears
1359 // to be comming from (zero degrees is from the right).
1360 void            Magick::Image::motionBlur ( const double radius_,
1361                                             const double sigma_,
1362                                             const double angle_ )
1363 {
1364   ExceptionInfo exceptionInfo;
1365   GetExceptionInfo( &exceptionInfo );
1366   MagickCore::Image* newImage =
1367     MotionBlurImage( image(), radius_, sigma_, angle_, &exceptionInfo);
1368   replaceImage( newImage );
1369   throwException( exceptionInfo );
1370   (void) DestroyExceptionInfo( &exceptionInfo );
1371 }
1372
1373 // Negate image.  Set grayscale_ to true to effect grayscale values
1374 // only
1375 void Magick::Image::negate ( const bool grayscale_ )
1376 {
1377   modifyImage();
1378   NegateImage ( image(), grayscale_ == true ? MagickTrue : MagickFalse );
1379   throwImageException();
1380 }
1381
1382 // Normalize image
1383 void Magick::Image::normalize ( void )
1384 {
1385   modifyImage();
1386   NormalizeImage ( image() );
1387   throwImageException();
1388 }
1389
1390 // Oilpaint image
1391 void Magick::Image::oilPaint ( const double radius_ )
1392 {
1393   ExceptionInfo exceptionInfo;
1394   GetExceptionInfo( &exceptionInfo );
1395   MagickCore::Image* newImage =
1396     OilPaintImage( image(), radius_, &exceptionInfo );
1397   replaceImage( newImage );
1398   throwException( exceptionInfo );
1399   (void) DestroyExceptionInfo( &exceptionInfo );
1400 }
1401
1402 // Set or attenuate the opacity channel. If the image pixels are
1403 // opaque then they are set to the specified opacity value, otherwise
1404 // they are blended with the supplied opacity value.  The value of
1405 // opacity_ ranges from 0 (completely opaque) to QuantumRange. The defines
1406 // OpaqueOpacity and TransparentOpacity are available to specify
1407 // completely opaque or completely transparent, respectively.
1408 void Magick::Image::opacity ( const unsigned int opacity_ )
1409 {
1410   modifyImage();
1411   SetImageOpacity( image(), opacity_ );
1412 }
1413
1414 // Change the color of an opaque pixel to the pen color.
1415 void Magick::Image::opaque ( const Color &opaqueColor_,
1416                              const Color &penColor_ )
1417 {
1418   if ( !opaqueColor_.isValid() )
1419   {
1420     throwExceptionExplicit( OptionError,
1421                             "Opaque color argument is invalid" );
1422   }
1423   if ( !penColor_.isValid() )
1424   {
1425     throwExceptionExplicit( OptionError,
1426                             "Pen color argument is invalid" );
1427   }
1428
1429   modifyImage();
1430   std::string opaqueColor = opaqueColor_;
1431   std::string penColor = penColor_;
1432
1433   MagickPixelPacket opaque;
1434   MagickPixelPacket pen;
1435   (void) QueryMagickColor(std::string(opaqueColor_).c_str(),&opaque,&image()->exception);
1436   (void) QueryMagickColor(std::string(penColor_).c_str(),&pen,&image()->exception);
1437   OpaquePaintImage ( image(), &opaque, &pen, MagickFalse );
1438   throwImageException();
1439 }
1440
1441 // Ping is similar to read except only enough of the image is read to
1442 // determine the image columns, rows, and filesize.  Access the
1443 // columns(), rows(), and fileSize() attributes after invoking ping.
1444 // The image data is not valid after calling ping.
1445 void Magick::Image::ping ( const std::string &imageSpec_ )
1446 {
1447   options()->fileName( imageSpec_ );
1448   ExceptionInfo exceptionInfo;
1449   GetExceptionInfo( &exceptionInfo );
1450   MagickCore::Image* image =
1451     PingImage( imageInfo(), &exceptionInfo );
1452   replaceImage( image );
1453   throwException( exceptionInfo );
1454   (void) DestroyExceptionInfo( &exceptionInfo );
1455 }
1456
1457 // Ping is similar to read except only enough of the image is read
1458 // to determine the image columns, rows, and filesize.  Access the
1459 // columns(), rows(), and fileSize() attributes after invoking
1460 // ping.  The image data is not valid after calling ping.
1461 void Magick::Image::ping ( const Blob& blob_ )
1462 {
1463   ExceptionInfo exceptionInfo;
1464   GetExceptionInfo( &exceptionInfo );
1465   MagickCore::Image* image =
1466     PingBlob( imageInfo(), blob_.data(), blob_.length(), &exceptionInfo );
1467   replaceImage( image );
1468   throwException( exceptionInfo );
1469   (void) DestroyExceptionInfo( &exceptionInfo );
1470 }
1471
1472 // Execute a named process module using an argc/argv syntax similar to
1473 // that accepted by a C 'main' routine. An exception is thrown if the
1474 // requested process module doesn't exist, fails to load, or fails during
1475 // execution.
1476 void Magick::Image::process( std::string name_, const ssize_t argc, const char **argv )
1477 {
1478   modifyImage();
1479
1480   size_t status =
1481     InvokeDynamicImageFilter( name_.c_str(), &image(), argc, argv,
1482       &image()->exception );
1483
1484   if (status == false)
1485     throwException( image()->exception );
1486 }
1487
1488 // Quantize colors in image using current quantization settings
1489 // Set measureError_ to true in order to measure quantization error
1490 void Magick::Image::quantize ( const bool measureError_  )
1491 {
1492   modifyImage();
1493
1494   if (measureError_)
1495     options()->quantizeInfo()->measure_error=MagickTrue;
1496   else
1497     options()->quantizeInfo()->measure_error=MagickFalse;
1498
1499   QuantizeImage( options()->quantizeInfo(), image() );
1500
1501   throwImageException();
1502 }
1503
1504 // Apply an arithmetic or bitwise operator to the image pixel quantums.
1505 void Magick::Image::quantumOperator ( const ChannelType channel_,
1506                                       const MagickEvaluateOperator operator_,
1507                                       double rvalue_)
1508 {
1509   ExceptionInfo exceptionInfo;
1510   GetExceptionInfo( &exceptionInfo );
1511   EvaluateImageChannel( image(), channel_, operator_, rvalue_, &exceptionInfo);
1512   throwException( exceptionInfo );
1513   (void) DestroyExceptionInfo( &exceptionInfo );
1514 }
1515
1516 void Magick::Image::quantumOperator ( const ssize_t x_,const ssize_t y_,
1517                                       const size_t columns_,
1518                                       const size_t rows_,
1519                                       const ChannelType channel_,
1520                                       const MagickEvaluateOperator operator_,
1521                                       const double rvalue_)
1522 {
1523   ExceptionInfo exceptionInfo;
1524   GetExceptionInfo( &exceptionInfo );
1525   RectangleInfo geometry;
1526   geometry.width = columns_;
1527   geometry.height = rows_;
1528   geometry.x = x_;
1529   geometry.y = y_;
1530   MagickCore::Image *crop_image = CropImage( image(), &geometry,
1531     &exceptionInfo );
1532   EvaluateImageChannel( crop_image, channel_, operator_, rvalue_,
1533     &exceptionInfo );
1534   (void) CompositeImage( image(), image()->matte != MagickFalse ?
1535     OverCompositeOp : CopyCompositeOp, crop_image, geometry.x, geometry.y );
1536   crop_image = DestroyImageList(crop_image);
1537   throwException( exceptionInfo );
1538   (void) DestroyExceptionInfo( &exceptionInfo );
1539 }
1540
1541 // Raise image (lighten or darken the edges of an image to give a 3-D
1542 // raised or lowered effect)
1543 void Magick::Image::raise ( const Geometry &geometry_ ,
1544                             const bool raisedFlag_ )
1545 {
1546   RectangleInfo raiseInfo = geometry_;
1547   modifyImage();
1548   RaiseImage ( image(), &raiseInfo, raisedFlag_ == true ? MagickTrue : MagickFalse );
1549   throwImageException();
1550 }
1551
1552
1553 // Random threshold image.
1554 //
1555 // Changes the value of individual pixels based on the intensity
1556 // of each pixel compared to a random threshold.  The result is a
1557 // low-contrast, two color image.  The thresholds_ argument is a
1558 // geometry containing LOWxHIGH thresholds.  If the string
1559 // contains 2x2, 3x3, or 4x4, then an ordered dither of order 2,
1560 // 3, or 4 will be performed instead.  If a channel_ argument is
1561 // specified then only the specified channel is altered.  This is
1562 // a very fast alternative to 'quantize' based dithering.
1563 void Magick::Image::randomThreshold( const Geometry &thresholds_ )
1564 {
1565   randomThresholdChannel(thresholds_,DefaultChannels);
1566 }
1567 void Magick::Image::randomThresholdChannel( const Geometry &thresholds_,
1568                                             const ChannelType channel_ )
1569 {
1570   ExceptionInfo exceptionInfo;
1571   GetExceptionInfo( &exceptionInfo );
1572   modifyImage();
1573   (void) RandomThresholdImageChannel( image(),
1574                                       channel_,
1575                                       static_cast<std::string>(thresholds_).c_str(),
1576                                       &exceptionInfo );
1577   throwImageException();
1578   (void) DestroyExceptionInfo( &exceptionInfo );
1579 }
1580
1581 // Read image into current object
1582 void Magick::Image::read ( const std::string &imageSpec_ )
1583 {
1584   options()->fileName( imageSpec_ );
1585
1586   ExceptionInfo exceptionInfo;
1587   GetExceptionInfo( &exceptionInfo );
1588   MagickCore::Image* image =
1589     ReadImage( imageInfo(), &exceptionInfo );
1590
1591   // Ensure that multiple image frames were not read.
1592   if ( image && image->next )
1593     {
1594       // Destroy any extra image frames
1595       MagickCore::Image* next = image->next;
1596       image->next = 0;
1597       next->previous = 0;
1598       DestroyImageList( next );
1599
1600     }
1601   replaceImage( image );
1602   throwException( exceptionInfo );
1603   if ( image )
1604     throwException( image->exception );
1605   (void) DestroyExceptionInfo( &exceptionInfo );
1606 }
1607
1608 // Read image of specified size into current object
1609 void Magick::Image::read ( const Geometry &size_,
1610                            const std::string &imageSpec_ )
1611 {
1612   size( size_ );
1613   read( imageSpec_ );
1614 }
1615
1616 // Read image from in-memory BLOB
1617 void Magick::Image::read ( const Blob &blob_ )
1618 {
1619   ExceptionInfo exceptionInfo;
1620   GetExceptionInfo( &exceptionInfo );
1621   MagickCore::Image* image =
1622     BlobToImage( imageInfo(),
1623                  static_cast<const void *>(blob_.data()),
1624                  blob_.length(), &exceptionInfo );
1625   replaceImage( image );
1626   throwException( exceptionInfo );
1627   if ( image )
1628     throwException( image->exception );
1629   (void) DestroyExceptionInfo( &exceptionInfo );
1630 }
1631
1632 // Read image of specified size from in-memory BLOB
1633 void  Magick::Image::read ( const Blob &blob_,
1634                             const Geometry &size_ )
1635 {
1636   // Set image size
1637   size( size_ );
1638   // Read from Blob
1639   read( blob_ );
1640 }
1641
1642 // Read image of specified size and depth from in-memory BLOB
1643 void Magick::Image::read ( const Blob &blob_,
1644                            const Geometry &size_,
1645                            const size_t depth_ )
1646 {
1647   // Set image size
1648   size( size_ );
1649   // Set image depth
1650   depth( depth_ );
1651   // Read from Blob
1652   read( blob_ );
1653 }
1654
1655 // Read image of specified size, depth, and format from in-memory BLOB
1656 void Magick::Image::read ( const Blob &blob_,
1657                            const Geometry &size_,
1658                            const size_t depth_,
1659                            const std::string &magick_ )
1660 {
1661   // Set image size
1662   size( size_ );
1663   // Set image depth
1664   depth( depth_ );
1665   // Set image magick
1666   magick( magick_ );
1667   // Set explicit image format
1668   fileName( magick_ + ':');
1669   // Read from Blob
1670   read( blob_ );
1671 }
1672
1673 // Read image of specified size, and format from in-memory BLOB
1674 void Magick::Image::read ( const Blob &blob_,
1675                            const Geometry &size_,
1676                            const std::string &magick_ )
1677 {
1678   // Set image size
1679   size( size_ );
1680   // Set image magick
1681   magick( magick_ );
1682   // Set explicit image format
1683   fileName( magick_ + ':');
1684   // Read from Blob
1685   read( blob_ );
1686 }
1687
1688 // Read image based on raw pixels in memory (ConstituteImage)
1689 void Magick::Image::read ( const size_t width_,
1690                            const size_t height_,
1691                            const std::string &map_,
1692                            const StorageType type_,
1693                            const void *pixels_ )
1694 {
1695   ExceptionInfo exceptionInfo;
1696   GetExceptionInfo( &exceptionInfo );
1697   MagickCore::Image* image =
1698     ConstituteImage( width_, height_, map_.c_str(), type_, pixels_,
1699                      &exceptionInfo );
1700   replaceImage( image );
1701   throwException( exceptionInfo );
1702   if ( image )
1703     throwException( image->exception );
1704   (void) DestroyExceptionInfo( &exceptionInfo );
1705 }
1706
1707 // Reduce noise in image
1708 void Magick::Image::reduceNoise ( const double order_ )
1709 {
1710   ExceptionInfo exceptionInfo;
1711   GetExceptionInfo( &exceptionInfo );
1712   MagickCore::Image* newImage =
1713     StatisticImage( image(), NonpeakStatistic, (size_t) order_, (size_t) order_,
1714     &exceptionInfo );
1715   replaceImage( newImage );
1716   throwException( exceptionInfo );
1717   (void) DestroyExceptionInfo( &exceptionInfo );
1718 }
1719
1720 // Resize image
1721 void Magick::Image::resize( const Geometry &geometry_ )
1722 {
1723   // Calculate new size.  This code should be supported using binary arguments
1724   // in the ImageMagick library.
1725   ssize_t x = 0;
1726   ssize_t y = 0;
1727   size_t width = columns();
1728   size_t height = rows();
1729
1730   ParseMetaGeometry (static_cast<std::string>(geometry_).c_str(),
1731                      &x, &y,
1732                      &width, &height );
1733
1734   ExceptionInfo exceptionInfo;
1735   GetExceptionInfo( &exceptionInfo );
1736   MagickCore::Image* newImage =
1737     ResizeImage( image(),
1738                width,
1739                height,
1740                image()->filter,
1741                1.0,
1742                &exceptionInfo);
1743   replaceImage( newImage );
1744   throwException( exceptionInfo );
1745   (void) DestroyExceptionInfo( &exceptionInfo );
1746 }
1747
1748 // Roll image
1749 void Magick::Image::roll ( const Geometry &roll_ )
1750 {
1751   ssize_t xOff = roll_.xOff();
1752   if ( roll_.xNegative() )
1753     xOff = 0 - xOff;
1754   ssize_t yOff = roll_.yOff();
1755   if ( roll_.yNegative() )
1756     yOff = 0 - yOff;
1757
1758   ExceptionInfo exceptionInfo;
1759   GetExceptionInfo( &exceptionInfo );
1760   MagickCore::Image* newImage =
1761     RollImage( image(), xOff, yOff, &exceptionInfo );
1762   replaceImage( newImage );
1763   throwException( exceptionInfo );
1764   (void) DestroyExceptionInfo( &exceptionInfo );
1765 }
1766 void Magick::Image::roll ( const size_t columns_,
1767                            const size_t rows_ )
1768 {
1769   ExceptionInfo exceptionInfo;
1770   GetExceptionInfo( &exceptionInfo );
1771   MagickCore::Image* newImage =
1772     RollImage( image(),
1773                static_cast<ssize_t>(columns_),
1774                static_cast<ssize_t>(rows_), &exceptionInfo );
1775   replaceImage( newImage );
1776   throwException( exceptionInfo );
1777   (void) DestroyExceptionInfo( &exceptionInfo );
1778 }
1779
1780 // Rotate image
1781 void Magick::Image::rotate ( const double degrees_ )
1782 {
1783   ExceptionInfo exceptionInfo;
1784   GetExceptionInfo( &exceptionInfo );
1785   MagickCore::Image* newImage =
1786     RotateImage( image(), degrees_, &exceptionInfo);
1787   replaceImage( newImage );
1788   throwException( exceptionInfo );
1789   (void) DestroyExceptionInfo( &exceptionInfo );
1790 }
1791
1792 // Sample image
1793 void Magick::Image::sample ( const Geometry &geometry_ )
1794 {
1795   ssize_t x = 0;
1796   ssize_t y = 0;
1797   size_t width = columns();
1798   size_t height = rows();
1799
1800   ParseMetaGeometry (static_cast<std::string>(geometry_).c_str(),
1801                       &x, &y,
1802                       &width, &height );
1803
1804   ExceptionInfo exceptionInfo;
1805   GetExceptionInfo( &exceptionInfo );
1806   MagickCore::Image* newImage =
1807     SampleImage( image(), width, height, &exceptionInfo );
1808   replaceImage( newImage );
1809   throwException( exceptionInfo );
1810   (void) DestroyExceptionInfo( &exceptionInfo );
1811 }
1812
1813 // Scale image
1814 void Magick::Image::scale ( const Geometry &geometry_ )
1815 {
1816   ssize_t x = 0;
1817   ssize_t y = 0;
1818   size_t width = columns();
1819   size_t height = rows();
1820
1821   ParseMetaGeometry (static_cast<std::string>(geometry_).c_str(),
1822                       &x, &y,
1823                       &width, &height );
1824
1825   ExceptionInfo exceptionInfo;
1826   GetExceptionInfo( &exceptionInfo );
1827   MagickCore::Image* newImage =
1828     ScaleImage( image(), width, height, &exceptionInfo );
1829   replaceImage( newImage );
1830   throwException( exceptionInfo );
1831   (void) DestroyExceptionInfo( &exceptionInfo );
1832 }
1833
1834 // Segment (coalesce similar image components) by analyzing the
1835 // histograms of the color components and identifying units that are
1836 // homogeneous with the fuzzy c-means technique.
1837 void Magick::Image::segment ( const double clusterThreshold_,
1838                               const double smoothingThreshold_ )
1839 {
1840   modifyImage();
1841   SegmentImage ( image(),
1842                  options()->quantizeColorSpace(),
1843                  (MagickBooleanType) options()->verbose(),
1844                  clusterThreshold_,
1845                  smoothingThreshold_ );
1846   throwImageException();
1847   SyncImage( image() );
1848   throwImageException();
1849 }
1850
1851 // Shade image using distant light source
1852 void Magick::Image::shade ( const double azimuth_,
1853                             const double elevation_,
1854                             const bool   colorShading_ )
1855 {
1856   ExceptionInfo exceptionInfo;
1857   GetExceptionInfo( &exceptionInfo );
1858   MagickCore::Image* newImage =
1859     ShadeImage( image(),
1860                 colorShading_ == true ? MagickTrue : MagickFalse,
1861                 azimuth_,
1862                 elevation_,
1863                 &exceptionInfo);
1864   replaceImage( newImage );
1865   throwException( exceptionInfo );
1866   (void) DestroyExceptionInfo( &exceptionInfo );
1867 }
1868
1869 // Sharpen pixels in image
1870 void Magick::Image::sharpen ( const double radius_, const double sigma_ )
1871 {
1872   ExceptionInfo exceptionInfo;
1873   GetExceptionInfo( &exceptionInfo );
1874   MagickCore::Image* newImage =
1875     SharpenImage( image(),
1876                   radius_,
1877                   sigma_,
1878                   &exceptionInfo );
1879   replaceImage( newImage );
1880   throwException( exceptionInfo );
1881   (void) DestroyExceptionInfo( &exceptionInfo );
1882 }
1883
1884 void Magick::Image::sharpenChannel ( const ChannelType channel_,
1885                                      const double radius_, const double sigma_ )
1886 {
1887   ExceptionInfo exceptionInfo;
1888   GetExceptionInfo( &exceptionInfo );
1889   MagickCore::Image* newImage =
1890     SharpenImageChannel( image(),
1891                          channel_,
1892                          radius_,
1893                          sigma_,
1894                          &exceptionInfo );
1895   replaceImage( newImage );
1896   throwException( exceptionInfo );
1897   (void) DestroyExceptionInfo( &exceptionInfo );
1898 }
1899
1900 // Shave pixels from image edges.
1901 void Magick::Image::shave ( const Geometry &geometry_ )
1902 {
1903   RectangleInfo shaveInfo = geometry_;
1904   ExceptionInfo exceptionInfo;
1905   GetExceptionInfo( &exceptionInfo );
1906   MagickCore::Image* newImage =
1907     ShaveImage( image(),
1908                &shaveInfo,
1909                &exceptionInfo);
1910   replaceImage( newImage );
1911   throwException( exceptionInfo );
1912   (void) DestroyExceptionInfo( &exceptionInfo );
1913 }
1914
1915 // Shear image
1916 void Magick::Image::shear ( const double xShearAngle_,
1917                             const double yShearAngle_ )
1918 {
1919   ExceptionInfo exceptionInfo;
1920   GetExceptionInfo( &exceptionInfo );
1921   MagickCore::Image* newImage =
1922     ShearImage( image(),
1923                 xShearAngle_,
1924                 yShearAngle_,
1925                 &exceptionInfo );
1926   replaceImage( newImage );
1927   throwException( exceptionInfo );
1928   (void) DestroyExceptionInfo( &exceptionInfo );
1929 }
1930
1931 // Contrast image
1932 void Magick::Image::sigmoidalContrast ( const size_t sharpen_, const double contrast, const double midpoint )
1933 {
1934   modifyImage();
1935   (void) SigmoidalContrastImageChannel( image(), DefaultChannels, (MagickBooleanType) sharpen_, contrast, midpoint );
1936   throwImageException();
1937 }
1938
1939 // Solarize image (similar to effect seen when exposing a photographic
1940 // film to light during the development process)
1941 void Magick::Image::solarize ( const double factor_ )
1942 {
1943   modifyImage();
1944   SolarizeImage ( image(), factor_ );
1945   throwImageException();
1946 }
1947
1948 // Sparse color image, given a set of coordinates, interpolates the colors
1949 // found at those coordinates, across the whole image, using various methods.
1950 //
1951 void Magick::Image::sparseColor ( const ChannelType channel,
1952                                   const SparseColorMethod method,
1953                                   const size_t number_arguments,
1954                                   const double *arguments )
1955 {
1956   ExceptionInfo exceptionInfo;
1957   GetExceptionInfo( &exceptionInfo );
1958   MagickCore::Image* newImage = SparseColorImage ( image(), channel, method,
1959     number_arguments, arguments, &exceptionInfo );
1960   replaceImage( newImage );
1961   throwException( exceptionInfo );
1962   (void) DestroyExceptionInfo( &exceptionInfo );
1963 }
1964
1965 // Spread pixels randomly within image by specified ammount
1966 void Magick::Image::spread ( const size_t amount_ )
1967 {
1968   ExceptionInfo exceptionInfo;
1969   GetExceptionInfo( &exceptionInfo );
1970   MagickCore::Image* newImage =
1971     SpreadImage( image(),
1972                  amount_,
1973                  &exceptionInfo );
1974   replaceImage( newImage );
1975   throwException( exceptionInfo );
1976   (void) DestroyExceptionInfo( &exceptionInfo );
1977 }
1978
1979 // Add a digital watermark to the image (based on second image)
1980 void Magick::Image::stegano ( const Image &watermark_ )
1981 {
1982   ExceptionInfo exceptionInfo;
1983   GetExceptionInfo( &exceptionInfo );
1984   MagickCore::Image* newImage =
1985     SteganoImage( image(),
1986                   watermark_.constImage(),
1987                   &exceptionInfo);
1988   replaceImage( newImage );
1989   throwException( exceptionInfo );
1990   (void) DestroyExceptionInfo( &exceptionInfo );
1991 }
1992
1993 // Stereo image (left image is current image)
1994 void Magick::Image::stereo ( const Image &rightImage_ )
1995 {
1996   ExceptionInfo exceptionInfo;
1997   GetExceptionInfo( &exceptionInfo );
1998   MagickCore::Image* newImage =
1999     StereoImage( image(),
2000                  rightImage_.constImage(),
2001                  &exceptionInfo);
2002   replaceImage( newImage );
2003   throwException( exceptionInfo );
2004   (void) DestroyExceptionInfo( &exceptionInfo );
2005 }
2006
2007 // Swirl image
2008 void Magick::Image::swirl ( const double degrees_ )
2009 {
2010   ExceptionInfo exceptionInfo;
2011   GetExceptionInfo( &exceptionInfo );
2012   MagickCore::Image* newImage =
2013     SwirlImage( image(), degrees_,
2014                 &exceptionInfo);
2015   replaceImage( newImage );
2016   throwException( exceptionInfo );
2017   (void) DestroyExceptionInfo( &exceptionInfo );
2018 }
2019
2020 // Texture image
2021 void Magick::Image::texture ( const Image &texture_ )
2022 {
2023   modifyImage();
2024   TextureImage( image(), texture_.constImage() );
2025   throwImageException();
2026 }
2027
2028 // Threshold image
2029 void Magick::Image::threshold ( const double threshold_ )
2030 {
2031   modifyImage();
2032   BilevelImage( image(), threshold_ );
2033   throwImageException();
2034 }
2035
2036 // Transform image based on image geometry only
2037 void Magick::Image::transform ( const Geometry &imageGeometry_ )
2038 {
2039   modifyImage();
2040   TransformImage ( &(image()), 0,
2041                    std::string(imageGeometry_).c_str() );
2042   throwImageException();
2043 }
2044 // Transform image based on image and crop geometries
2045 void Magick::Image::transform ( const Geometry &imageGeometry_,
2046                                 const Geometry &cropGeometry_ )
2047 {
2048   modifyImage();
2049   TransformImage ( &(image()), std::string(cropGeometry_).c_str(),
2050                    std::string(imageGeometry_).c_str() );
2051   throwImageException();
2052 }
2053
2054 // Add matte image to image, setting pixels matching color to transparent
2055 void Magick::Image::transparent ( const Color &color_ )
2056 {
2057   if ( !color_.isValid() )
2058   {
2059     throwExceptionExplicit( OptionError,
2060                             "Color argument is invalid" );
2061   }
2062
2063   std::string color = color_;
2064
2065   MagickPixelPacket target;
2066   (void) QueryMagickColor(std::string(color_).c_str(),&target,&image()->exception);
2067   modifyImage();
2068   TransparentPaintImage ( image(), &target, TransparentOpacity, MagickFalse );
2069   throwImageException();
2070 }
2071
2072 // Add matte image to image, setting pixels matching color to transparent
2073 void Magick::Image::transparentChroma(const Color &colorLow_,
2074   const Color &colorHigh_)
2075 {
2076   if ( !colorLow_.isValid() || !colorHigh_.isValid() )
2077   {
2078     throwExceptionExplicit( OptionError,
2079                             "Color argument is invalid" );
2080   }
2081
2082   std::string colorLow = colorLow_;
2083   std::string colorHigh = colorHigh_;
2084
2085   MagickPixelPacket targetLow;
2086   MagickPixelPacket targetHigh;
2087   (void) QueryMagickColor(std::string(colorLow_).c_str(),&targetLow,
2088     &image()->exception);
2089   (void) QueryMagickColor(std::string(colorHigh_).c_str(),&targetHigh,
2090     &image()->exception);
2091   modifyImage();
2092   TransparentPaintImageChroma ( image(), &targetLow, &targetHigh,
2093     TransparentOpacity, MagickFalse );
2094   throwImageException();
2095 }
2096
2097
2098 // Trim edges that are the background color from the image
2099 void Magick::Image::trim ( void )
2100 {
2101   ExceptionInfo exceptionInfo;
2102   GetExceptionInfo( &exceptionInfo );
2103   MagickCore::Image* newImage =
2104     TrimImage( image(), &exceptionInfo);
2105   replaceImage( newImage );
2106   throwException( exceptionInfo );
2107   (void) DestroyExceptionInfo( &exceptionInfo );
2108 }
2109
2110 // Replace image with a sharpened version of the original image
2111 // using the unsharp mask algorithm.
2112 //  radius_
2113 //    the radius of the Gaussian, in pixels, not counting the
2114 //    center pixel.
2115 //  sigma_
2116 //    the standard deviation of the Gaussian, in pixels.
2117 //  amount_
2118 //    the percentage of the difference between the original and
2119 //    the blur image that is added back into the original.
2120 // threshold_
2121 //   the threshold in pixels needed to apply the diffence amount.
2122 void Magick::Image::unsharpmask ( const double radius_,
2123                                   const double sigma_,
2124                                   const double amount_,
2125                                   const double threshold_ )
2126 {
2127   ExceptionInfo exceptionInfo;
2128   GetExceptionInfo( &exceptionInfo );
2129   MagickCore::Image* newImage =
2130     UnsharpMaskImage( image(),
2131                       radius_,
2132                       sigma_,
2133                       amount_,
2134                       threshold_,
2135                       &exceptionInfo );
2136   replaceImage( newImage );
2137   throwException( exceptionInfo );
2138   (void) DestroyExceptionInfo( &exceptionInfo );
2139 }
2140
2141 void Magick::Image::unsharpmaskChannel ( const ChannelType channel_,
2142                                          const double radius_,
2143                                          const double sigma_,
2144                                          const double amount_,
2145                                          const double threshold_ )
2146 {
2147   ExceptionInfo exceptionInfo;
2148   GetExceptionInfo( &exceptionInfo );
2149   MagickCore::Image* newImage =
2150     UnsharpMaskImageChannel( image(),
2151                              channel_,
2152                              radius_,
2153                              sigma_,
2154                              amount_,
2155                              threshold_,
2156                              &exceptionInfo );
2157   replaceImage( newImage );
2158   throwException( exceptionInfo );
2159   (void) DestroyExceptionInfo( &exceptionInfo );
2160 }
2161
2162 // Map image pixels to a sine wave
2163 void Magick::Image::wave ( const double amplitude_, const double wavelength_ )
2164 {
2165   ExceptionInfo exceptionInfo;
2166   GetExceptionInfo( &exceptionInfo );
2167   MagickCore::Image* newImage =
2168     WaveImage( image(),
2169                amplitude_,
2170                wavelength_,
2171                &exceptionInfo);
2172   replaceImage( newImage );
2173   throwException( exceptionInfo );
2174   (void) DestroyExceptionInfo( &exceptionInfo );
2175 }
2176
2177 // Write image to file
2178 void Magick::Image::write( const std::string &imageSpec_ )
2179 {
2180   modifyImage();
2181   fileName( imageSpec_ );
2182   WriteImage( imageInfo(), image() );
2183   throwImageException();
2184 }
2185
2186 // Write image to in-memory BLOB
2187 void Magick::Image::write ( Blob *blob_ )
2188 {
2189   modifyImage();
2190   size_t length = 2048; // Efficient size for small images
2191   ExceptionInfo exceptionInfo;
2192   GetExceptionInfo( &exceptionInfo );
2193   void* data = ImageToBlob( imageInfo(),
2194                             image(),
2195                             &length,
2196                             &exceptionInfo);
2197   throwException( exceptionInfo );
2198   blob_->updateNoCopy( data, length, Blob::MallocAllocator );
2199   throwImageException();
2200   (void) DestroyExceptionInfo( &exceptionInfo );
2201 }
2202 void Magick::Image::write ( Blob *blob_,
2203                             const std::string &magick_ )
2204 {
2205   modifyImage();
2206   magick(magick_);
2207   size_t length = 2048; // Efficient size for small images
2208   ExceptionInfo exceptionInfo;
2209   GetExceptionInfo( &exceptionInfo );
2210   void* data = ImageToBlob( imageInfo(),
2211                             image(),
2212                             &length,
2213                             &exceptionInfo);
2214   throwException( exceptionInfo );
2215   blob_->updateNoCopy( data, length, Blob::MallocAllocator );
2216   throwImageException();
2217   (void) DestroyExceptionInfo( &exceptionInfo );
2218 }
2219 void Magick::Image::write ( Blob *blob_,
2220                             const std::string &magick_,
2221                             const size_t depth_ )
2222 {
2223   modifyImage();
2224   magick(magick_);
2225   depth(depth_);
2226   size_t length = 2048; // Efficient size for small images
2227   ExceptionInfo exceptionInfo;
2228   GetExceptionInfo( &exceptionInfo );
2229   void* data = ImageToBlob( imageInfo(),
2230                             image(),
2231                             &length,
2232                             &exceptionInfo);
2233   throwException( exceptionInfo );
2234   blob_->updateNoCopy( data, length, Blob::MallocAllocator );
2235   throwImageException();
2236   (void) DestroyExceptionInfo( &exceptionInfo );
2237 }
2238
2239 // Write image to an array of pixels with storage type specified
2240 // by user (ExportImagePixels), e.g.
2241 // image.write( 0, 0, 640, 1, "RGB", 0, pixels );
2242 void Magick::Image::write ( const ssize_t x_,
2243                             const ssize_t y_,
2244                             const size_t columns_,
2245                             const size_t rows_,
2246                             const std::string &map_,
2247                             const StorageType type_,
2248                             void *pixels_ )
2249 {
2250   ExceptionInfo exceptionInfo;
2251   GetExceptionInfo( &exceptionInfo );
2252   ExportImagePixels( image(), x_, y_, columns_, rows_, map_.c_str(), type_,
2253                  pixels_,
2254     &exceptionInfo);
2255   throwException( exceptionInfo );
2256   (void) DestroyExceptionInfo( &exceptionInfo );
2257 }
2258
2259 // Zoom image
2260 void Magick::Image::zoom( const Geometry &geometry_ )
2261 {
2262   // Calculate new size.  This code should be supported using binary arguments
2263   // in the ImageMagick library.
2264   ssize_t x = 0;
2265   ssize_t y = 0;
2266   size_t width = columns();
2267   size_t height = rows();
2268
2269   ParseMetaGeometry (static_cast<std::string>(geometry_).c_str(),
2270                      &x, &y,
2271                      &width, &height );
2272
2273   ExceptionInfo exceptionInfo;
2274   GetExceptionInfo( &exceptionInfo );
2275   MagickCore::Image* newImage =
2276     ResizeImage( image(),
2277                width,
2278                height,
2279                image()->filter,
2280                image()->blur,
2281                &exceptionInfo);
2282   replaceImage( newImage );
2283   throwException( exceptionInfo );
2284   (void) DestroyExceptionInfo( &exceptionInfo );
2285 }
2286
2287 /*
2288  * Methods for setting image attributes
2289  *
2290  */
2291
2292 // Join images into a single multi-image file
2293 void Magick::Image::adjoin ( const bool flag_ )
2294 {
2295   modifyImage();
2296   options()->adjoin( flag_ );
2297 }
2298 bool Magick::Image::adjoin ( void ) const
2299 {
2300   return constOptions()->adjoin();
2301 }
2302
2303 // Remove pixel aliasing
2304 void Magick::Image::antiAlias( const bool flag_ )
2305 {
2306   modifyImage();
2307   options()->antiAlias( static_cast<size_t>(flag_) );
2308 }
2309 bool Magick::Image::antiAlias( void )
2310 {
2311   return static_cast<bool>( options()->antiAlias( ) );
2312 }
2313
2314 // Animation inter-frame delay
2315 void Magick::Image::animationDelay ( const size_t delay_ )
2316 {
2317   modifyImage();
2318   image()->delay = delay_;
2319 }
2320 size_t Magick::Image::animationDelay ( void ) const
2321 {
2322   return constImage()->delay;
2323 }
2324
2325 // Number of iterations to play animation
2326 void Magick::Image::animationIterations ( const size_t iterations_ )
2327 {
2328   modifyImage();
2329   image()->iterations = iterations_;
2330 }
2331 size_t Magick::Image::animationIterations ( void ) const
2332 {
2333   return constImage()->iterations;
2334 }
2335
2336 // Access/Update a named image attribute
2337 void Magick::Image::attribute ( const std::string name_,
2338                                 const std::string value_ )
2339 {
2340   modifyImage();
2341   SetImageProperty( image(), name_.c_str(), value_.c_str() );
2342 }
2343 std::string Magick::Image::attribute ( const std::string name_ )
2344 {
2345   const char *value = GetImageProperty( constImage(), name_.c_str() );
2346
2347   if ( value )
2348     return std::string( value );
2349
2350   return std::string(); // Intentionally no exception
2351 }
2352
2353 // Background color
2354 void Magick::Image::backgroundColor ( const Color &backgroundColor_ )
2355 {
2356   modifyImage();
2357
2358   if ( backgroundColor_.isValid() )
2359     {
2360       image()->background_color = backgroundColor_;
2361     }
2362   else
2363     {
2364       image()->background_color = Color();
2365     }
2366
2367   options()->backgroundColor( backgroundColor_ );
2368 }
2369 Magick::Color Magick::Image::backgroundColor ( void ) const
2370 {
2371   return constOptions()->backgroundColor( );
2372 }
2373
2374 // Background fill texture
2375 void Magick::Image::backgroundTexture ( const std::string &backgroundTexture_ )
2376 {
2377   modifyImage();
2378   options()->backgroundTexture( backgroundTexture_ );
2379 }
2380 std::string Magick::Image::backgroundTexture ( void ) const
2381 {
2382   return constOptions()->backgroundTexture( );
2383 }
2384
2385 // Original image columns
2386 size_t Magick::Image::baseColumns ( void ) const
2387 {
2388   return constImage()->magick_columns;
2389 }
2390
2391 // Original image name
2392 std::string Magick::Image::baseFilename ( void ) const
2393 {
2394   return std::string(constImage()->magick_filename);
2395 }
2396
2397 // Original image rows
2398 size_t Magick::Image::baseRows ( void ) const
2399 {
2400   return constImage()->magick_rows;
2401 }
2402
2403 // Border color
2404 void Magick::Image::borderColor ( const Color &borderColor_ )
2405 {
2406   modifyImage();
2407
2408   if ( borderColor_.isValid() )
2409     {
2410       image()->border_color = borderColor_;
2411     }
2412   else
2413     {
2414       image()->border_color = Color();
2415     }
2416
2417   options()->borderColor( borderColor_ );
2418 }
2419 Magick::Color Magick::Image::borderColor ( void ) const
2420 {
2421   return constOptions()->borderColor( );
2422 }
2423
2424 // Return smallest bounding box enclosing non-border pixels. The
2425 // current fuzz value is used when discriminating between pixels.
2426 // This is the crop bounding box used by crop(Geometry(0,0));
2427 Magick::Geometry Magick::Image::boundingBox ( void ) const
2428 {
2429   ExceptionInfo exceptionInfo;
2430   GetExceptionInfo( &exceptionInfo );
2431   RectangleInfo bbox = GetImageBoundingBox( constImage(), &exceptionInfo);
2432   throwException( exceptionInfo );
2433   (void) DestroyExceptionInfo( &exceptionInfo );
2434   return Geometry( bbox );
2435 }
2436
2437 // Text bounding-box base color
2438 void Magick::Image::boxColor ( const Color &boxColor_ )
2439 {
2440   modifyImage();
2441   options()->boxColor( boxColor_ );
2442 }
2443 Magick::Color Magick::Image::boxColor ( void ) const
2444 {
2445   return constOptions()->boxColor( );
2446 }
2447
2448 // Pixel cache threshold.  Once this threshold is exceeded, all
2449 // subsequent pixels cache operations are to/from disk.
2450 // This setting is shared by all Image objects.
2451 /* static */
2452 void Magick::Image::cacheThreshold ( const size_t threshold_ )
2453 {
2454   SetMagickResourceLimit( MemoryResource, threshold_ );
2455 }
2456
2457 void Magick::Image::chromaBluePrimary ( const double x_, const double y_ )
2458 {
2459   modifyImage();
2460   image()->chromaticity.blue_primary.x = x_;
2461   image()->chromaticity.blue_primary.y = y_;
2462 }
2463 void Magick::Image::chromaBluePrimary ( double *x_, double *y_ ) const
2464 {
2465   *x_ = constImage()->chromaticity.blue_primary.x;
2466   *y_ = constImage()->chromaticity.blue_primary.y;
2467 }
2468
2469 void Magick::Image::chromaGreenPrimary ( const double x_, const double y_ )
2470 {
2471   modifyImage();
2472   image()->chromaticity.green_primary.x = x_;
2473   image()->chromaticity.green_primary.y = y_;
2474 }
2475 void Magick::Image::chromaGreenPrimary ( double *x_, double *y_ ) const
2476 {
2477   *x_ = constImage()->chromaticity.green_primary.x;
2478   *y_ = constImage()->chromaticity.green_primary.y;
2479 }
2480
2481 void Magick::Image::chromaRedPrimary ( const double x_, const double y_ )
2482 {
2483   modifyImage();
2484   image()->chromaticity.red_primary.x = x_;
2485   image()->chromaticity.red_primary.y = y_;
2486 }
2487 void Magick::Image::chromaRedPrimary ( double *x_, double *y_ ) const
2488 {
2489   *x_ = constImage()->chromaticity.red_primary.x;
2490   *y_ = constImage()->chromaticity.red_primary.y;
2491 }
2492
2493 void Magick::Image::chromaWhitePoint ( const double x_, const double y_ )
2494 {
2495   modifyImage();
2496   image()->chromaticity.white_point.x = x_;
2497   image()->chromaticity.white_point.y = y_;
2498 }
2499 void Magick::Image::chromaWhitePoint ( double *x_, double *y_ ) const
2500 {
2501   *x_ = constImage()->chromaticity.white_point.x;
2502   *y_ = constImage()->chromaticity.white_point.y;
2503 }
2504
2505 // Set image storage class
2506 void Magick::Image::classType ( const ClassType class_ )
2507 {
2508   if ( classType() == PseudoClass && class_ == DirectClass )
2509     {
2510       // Use SyncImage to synchronize the DirectClass pixels with the
2511       // color map and then set to DirectClass type.
2512       modifyImage();
2513       SyncImage( image() );
2514       image()->colormap = (PixelPacket *)
2515         RelinquishMagickMemory( image()->colormap );
2516       image()->storage_class = static_cast<MagickCore::ClassType>(DirectClass);
2517       return;
2518     }
2519
2520   if ( classType() == DirectClass && class_ == PseudoClass )
2521     {
2522       // Quantize to create PseudoClass color map
2523       modifyImage();
2524       quantizeColors(MaxColormapSize);
2525       quantize();
2526       image()->storage_class = static_cast<MagickCore::ClassType>(PseudoClass);
2527     }
2528 }
2529
2530 // Associate a clip mask with the image. The clip mask must be the
2531 // same dimensions as the image. Pass an invalid image to unset an
2532 // existing clip mask.
2533 void Magick::Image::clipMask ( const Magick::Image & clipMask_ )
2534 {
2535   modifyImage();
2536
2537   if( clipMask_.isValid() )
2538     {
2539       // Set clip mask
2540       SetImageClipMask( image(), clipMask_.constImage() );
2541     }
2542   else
2543     {
2544       // Unset existing clip mask
2545       SetImageClipMask( image(), 0 );
2546     }
2547 }
2548 Magick::Image Magick::Image::clipMask ( void  ) const
2549 {
2550       ExceptionInfo exceptionInfo;
2551       GetExceptionInfo( &exceptionInfo );
2552       MagickCore::Image* image =
2553         GetImageClipMask( constImage(), &exceptionInfo );
2554       throwException( exceptionInfo );
2555   (void) DestroyExceptionInfo( &exceptionInfo );
2556       return Magick::Image( image );
2557 }
2558
2559 void Magick::Image::colorFuzz ( const double fuzz_ )
2560 {
2561   modifyImage();
2562   image()->fuzz = fuzz_;
2563   options()->colorFuzz( fuzz_ );
2564 }
2565 double Magick::Image::colorFuzz ( void ) const
2566 {
2567   return constOptions()->colorFuzz( );
2568 }
2569
2570 // Set color in colormap at index
2571 void Magick::Image::colorMap ( const size_t index_,
2572                                const Color &color_ )
2573 {
2574   MagickCore::Image* imageptr = image();
2575
2576   if (index_ > (MaxColormapSize-1) )
2577     throwExceptionExplicit( OptionError,
2578                             "Colormap index must be less than MaxColormapSize" );
2579
2580   if ( !color_.isValid() )
2581     throwExceptionExplicit( OptionError,
2582                             "Color argument is invalid");
2583   modifyImage();
2584
2585   // Ensure that colormap size is large enough
2586   if ( colorMapSize() < (index_+1) )
2587     colorMapSize( index_ + 1 );
2588
2589   // Set color at index in colormap
2590   (imageptr->colormap)[index_] = color_;
2591 }
2592 // Return color in colormap at index
2593 Magick::Color Magick::Image::colorMap ( const size_t index_ ) const
2594 {
2595   const MagickCore::Image* imageptr = constImage();
2596
2597   if ( !imageptr->colormap )
2598     throwExceptionExplicit( OptionError,
2599                             "Image does not contain a colormap");
2600
2601   if ( index_ > imageptr->colors-1 )
2602     throwExceptionExplicit( OptionError,
2603                             "Index out of range");
2604
2605   return Magick::Color( (imageptr->colormap)[index_] );
2606 }
2607
2608 // Colormap size (number of colormap entries)
2609 void Magick::Image::colorMapSize ( const size_t entries_ )
2610 {
2611   if (entries_ >MaxColormapSize )
2612     throwExceptionExplicit( OptionError,
2613                             "Colormap entries must not exceed MaxColormapSize" );
2614
2615   modifyImage();
2616
2617   MagickCore::Image* imageptr = image();
2618
2619   if( !imageptr->colormap )
2620     {
2621       // Allocate colormap
2622       imageptr->colormap =
2623         static_cast<PixelPacket*>(AcquireMagickMemory(entries_*sizeof(PixelPacket)));
2624       imageptr->colors = 0;
2625     }
2626   else if ( entries_ > imageptr->colors )
2627     {
2628       // Re-allocate colormap
2629       imageptr->colormap=(PixelPacket *)
2630         ResizeMagickMemory(imageptr->colormap,(entries_)*sizeof(PixelPacket));
2631     }
2632
2633   // Initialize any new colormap entries as all black
2634   Color black(0,0,0);
2635   for( size_t i=imageptr->colors; i<(entries_-1); i++ )
2636     (imageptr->colormap)[i] = black;
2637
2638   imageptr->colors = entries_;
2639 }
2640 size_t Magick::Image::colorMapSize ( void )
2641 {
2642   const MagickCore::Image* imageptr = constImage();
2643
2644   if ( !imageptr->colormap )
2645     throwExceptionExplicit( OptionError,
2646                             "Image does not contain a colormap");
2647
2648   return imageptr->colors;
2649 }
2650
2651 // Image colorspace
2652 void Magick::Image::colorSpace( const ColorspaceType colorSpace_ )
2653 {
2654   // Nothing to do?
2655   if ( image()->colorspace == colorSpace_ )
2656     return;
2657
2658   modifyImage();
2659
2660   if ( colorSpace_ != RGBColorspace &&
2661        colorSpace_ != TransparentColorspace &&
2662        colorSpace_ != GRAYColorspace )
2663     {
2664       if (image()->colorspace != RGBColorspace &&
2665           image()->colorspace != TransparentColorspace &&
2666           image()->colorspace != GRAYColorspace)
2667         {
2668           /* Transform to RGB colorspace as intermediate step */
2669           TransformRGBImage( image(), image()->colorspace );
2670           throwImageException();
2671         }
2672       /* Transform to final non-RGB colorspace */
2673       RGBTransformImage( image(), colorSpace_ );
2674       throwImageException();
2675       return;
2676     }
2677
2678   if ( colorSpace_ == RGBColorspace ||
2679        colorSpace_ == TransparentColorspace ||
2680        colorSpace_ == GRAYColorspace )
2681     {
2682       /* Transform to a RGB-type colorspace */
2683       TransformRGBImage( image(), image()->colorspace );
2684       throwImageException();
2685       return;
2686     }
2687 }
2688 Magick::ColorspaceType Magick::Image::colorSpace ( void ) const
2689 {
2690   return constImage()->colorspace;
2691 }
2692
2693 // Set image colorspace type.
2694 void Magick::Image::colorspaceType( const ColorspaceType colorSpace_ )
2695 {
2696   modifyImage();
2697   options()->colorspaceType( colorSpace_ );
2698 }
2699 Magick::ColorspaceType Magick::Image::colorspaceType ( void ) const
2700 {
2701   return constOptions()->colorspaceType();
2702 }
2703
2704
2705 // Comment string
2706 void Magick::Image::comment ( const std::string &comment_ )
2707 {
2708   modifyImage();
2709   SetImageProperty( image(), "Comment", NULL );
2710   if ( comment_.length() > 0 )
2711     SetImageProperty( image(), "Comment", comment_.c_str() );
2712   throwImageException();
2713 }
2714 std::string Magick::Image::comment ( void ) const
2715 {
2716   const char *value = GetImageProperty( constImage(), "Comment" );
2717
2718   if ( value )
2719     return std::string( value );
2720
2721   return std::string(); // Intentionally no exception
2722 }
2723
2724 // Composition operator to be used when composition is implicitly used
2725 // (such as for image flattening).
2726 void Magick::Image::compose (const CompositeOperator compose_)
2727 {
2728   image()->compose=compose_;
2729 }
2730
2731 Magick::CompositeOperator Magick::Image::compose ( void ) const
2732 {
2733   return constImage()->compose;
2734 }
2735
2736 // Compression algorithm
2737 void Magick::Image::compressType ( const CompressionType compressType_ )
2738 {
2739   modifyImage();
2740   image()->compression = compressType_;
2741   options()->compressType( compressType_ );
2742 }
2743 Magick::CompressionType Magick::Image::compressType ( void ) const
2744 {
2745   return constImage()->compression;
2746 }
2747
2748 // Enable printing of debug messages from ImageMagick
2749 void Magick::Image::debug ( const bool flag_ )
2750 {
2751   modifyImage();
2752   options()->debug( flag_ );
2753 }
2754 bool Magick::Image::debug ( void ) const
2755 {
2756   return constOptions()->debug();
2757 }
2758
2759 // Tagged image format define (set/access coder-specific option) The
2760 // magick_ option specifies the coder the define applies to.  The key_
2761 // option provides the key specific to that coder.  The value_ option
2762 // provides the value to set (if any). See the defineSet() method if the
2763 // key must be removed entirely.
2764 void Magick::Image::defineValue ( const std::string &magick_,
2765                                   const std::string &key_,
2766                                   const std::string &value_ )
2767 {
2768   modifyImage();
2769   std::string format = magick_ + ":" + key_;
2770   std::string option = value_;
2771   (void) SetImageOption ( imageInfo(), format.c_str(), option.c_str() );
2772 }
2773 std::string Magick::Image::defineValue ( const std::string &magick_,
2774                                          const std::string &key_ ) const
2775 {
2776   std::string definition = magick_ + ":" + key_;
2777   const char *option =
2778     GetImageOption ( constImageInfo(), definition.c_str() );
2779   if (option)
2780     return std::string( option );
2781   return std::string( );
2782 }
2783
2784 // Tagged image format define. Similar to the defineValue() method
2785 // except that passing the flag_ value 'true' creates a value-less
2786 // define with that format and key. Passing the flag_ value 'false'
2787 // removes any existing matching definition. The method returns 'true'
2788 // if a matching key exists, and 'false' if no matching key exists.
2789 void Magick::Image::defineSet ( const std::string &magick_,
2790                                 const std::string &key_,
2791                                 bool flag_ )
2792 {
2793   modifyImage();
2794   std::string definition = magick_ + ":" + key_;
2795   if (flag_)
2796     {
2797       (void) SetImageOption ( imageInfo(), definition.c_str(),  "" );
2798     }
2799   else
2800     {
2801       DeleteImageOption( imageInfo(), definition.c_str() );
2802     }
2803 }
2804 bool Magick::Image::defineSet ( const std::string &magick_,
2805                                 const std::string &key_ ) const
2806 {
2807   std::string key = magick_ + ":" + key_;
2808   const char *option =
2809     GetImageOption ( constImageInfo(), key.c_str() );
2810   if (option)
2811     return true;
2812   return false;
2813 }
2814
2815 // Pixel resolution
2816 void Magick::Image::density ( const Geometry &density_ )
2817 {
2818   modifyImage();
2819   options()->density( density_ );
2820   if ( density_.isValid() )
2821     {
2822       image()->x_resolution = density_.width();
2823       if ( density_.height() != 0 )
2824         {
2825           image()->y_resolution = density_.height();
2826         }
2827       else
2828         {
2829           image()->y_resolution = density_.width();
2830         }
2831     }
2832   else
2833     {
2834       // Reset to default
2835       image()->x_resolution = 0;
2836       image()->y_resolution = 0;
2837     }
2838 }
2839 Magick::Geometry Magick::Image::density ( void ) const
2840 {
2841   if (isValid())
2842     {
2843       ssize_t x_resolution=72;
2844       ssize_t y_resolution=72;
2845
2846       if (constImage()->x_resolution > 0.0)
2847         x_resolution=static_cast<ssize_t>(constImage()->x_resolution + 0.5);
2848
2849       if (constImage()->y_resolution > 0.0)
2850         y_resolution=static_cast<ssize_t>(constImage()->y_resolution + 0.5);
2851
2852       return Geometry(x_resolution,y_resolution);
2853     }
2854
2855   return constOptions()->density( );
2856 }
2857
2858 // Image depth (bits allocated to red/green/blue components)
2859 void Magick::Image::depth ( const size_t depth_ )
2860 {
2861   size_t depth = depth_;
2862
2863   if (depth > MAGICKCORE_QUANTUM_DEPTH)
2864     depth=MAGICKCORE_QUANTUM_DEPTH;
2865
2866   modifyImage();
2867   image()->depth=depth;
2868   options()->depth( depth );
2869 }
2870 size_t Magick::Image::depth ( void ) const
2871 {
2872   return constImage()->depth;
2873 }
2874
2875 std::string Magick::Image::directory ( void ) const
2876 {
2877   if ( constImage()->directory )
2878     return std::string( constImage()->directory );
2879
2880   throwExceptionExplicit( CorruptImageWarning,
2881                           "Image does not contain a directory");
2882
2883   return std::string();
2884 }
2885
2886 // Endianness (little like Intel or big like SPARC) for image
2887 // formats which support endian-specific options.
2888 void Magick::Image::endian ( const Magick::EndianType endian_ )
2889 {
2890   modifyImage();
2891   options()->endian( endian_ );
2892   image()->endian = endian_;
2893 }
2894 Magick::EndianType Magick::Image::endian ( void ) const
2895 {
2896   return constImage()->endian;
2897 }
2898
2899 // EXIF profile (BLOB)
2900 void Magick::Image::exifProfile( const Magick::Blob &exifProfile_ )
2901 {
2902   modifyImage();
2903   if ( exifProfile_.data() != 0 )
2904     {
2905       StringInfo * exif_profile = AcquireStringInfo( exifProfile_.length() );
2906       SetStringInfoDatum(exif_profile ,(unsigned char *) exifProfile_.data());
2907       (void) SetImageProfile( image(), "exif", exif_profile);
2908       exif_profile =DestroyStringInfo( exif_profile );
2909     }
2910 }
2911 Magick::Blob Magick::Image::exifProfile( void ) const
2912 {
2913   const StringInfo * exif_profile = GetImageProfile( constImage(), "exif" );
2914   if ( exif_profile == (StringInfo *) NULL)
2915     return Blob( 0, 0 );
2916   return Blob(GetStringInfoDatum(exif_profile),GetStringInfoLength(exif_profile));
2917 }
2918
2919 // Image file name
2920 void Magick::Image::fileName ( const std::string &fileName_ )
2921 {
2922   modifyImage();
2923
2924   fileName_.copy( image()->filename,
2925                   sizeof(image()->filename) - 1 );
2926   image()->filename[ fileName_.length() ] = 0; // Null terminate
2927
2928   options()->fileName( fileName_ );
2929
2930 }
2931 std::string Magick::Image::fileName ( void ) const
2932 {
2933   return constOptions()->fileName( );
2934 }
2935
2936 // Image file size
2937 off_t Magick::Image::fileSize ( void ) const
2938 {
2939   return (off_t) GetBlobSize( constImage() );
2940 }
2941
2942 // Color to use when drawing inside an object
2943 void Magick::Image::fillColor ( const Magick::Color &fillColor_ )
2944 {
2945   modifyImage();
2946   options()->fillColor(fillColor_);
2947 }
2948 Magick::Color Magick::Image::fillColor ( void ) const
2949 {
2950   return constOptions()->fillColor();
2951 }
2952
2953 // Rule to use when filling drawn objects
2954 void Magick::Image::fillRule ( const Magick::FillRule &fillRule_ )
2955 {
2956   modifyImage();
2957   options()->fillRule(fillRule_);
2958 }
2959 Magick::FillRule Magick::Image::fillRule ( void ) const
2960 {
2961   return constOptions()->fillRule();
2962 }
2963
2964 // Pattern to use while filling drawn objects.
2965 void Magick::Image::fillPattern ( const Image &fillPattern_ )
2966 {
2967   modifyImage();
2968   if(fillPattern_.isValid())
2969     options()->fillPattern( fillPattern_.constImage() );
2970   else
2971     options()->fillPattern( static_cast<MagickCore::Image*>(NULL) );
2972 }
2973 Magick::Image  Magick::Image::fillPattern ( void  ) const
2974 {
2975   // FIXME: This is inordinately innefficient
2976   Image texture;
2977
2978   const MagickCore::Image* tmpTexture = constOptions()->fillPattern( );
2979
2980   if ( tmpTexture )
2981     {
2982       ExceptionInfo exceptionInfo;
2983       GetExceptionInfo( &exceptionInfo );
2984       MagickCore::Image* image =
2985         CloneImage( tmpTexture,
2986                     0, // columns
2987                     0, // rows
2988                     MagickTrue, // orphan
2989                     &exceptionInfo);
2990       texture.replaceImage( image );
2991       throwException( exceptionInfo );
2992   (void) DestroyExceptionInfo( &exceptionInfo );
2993     }
2994   return texture;
2995 }
2996
2997 // Filter used by zoom
2998 void Magick::Image::filterType ( const Magick::FilterTypes filterType_ )
2999 {
3000   modifyImage();
3001   image()->filter = filterType_;
3002 }
3003 Magick::FilterTypes Magick::Image::filterType ( void ) const
3004 {
3005   return constImage()->filter;
3006 }
3007
3008 // Font name
3009 void Magick::Image::font ( const std::string &font_ )
3010 {
3011   modifyImage();
3012   options()->font( font_ );
3013 }
3014 std::string Magick::Image::font ( void ) const
3015 {
3016   return constOptions()->font( );
3017 }
3018
3019 // Font point size
3020 void Magick::Image::fontPointsize ( const double pointSize_ )
3021 {
3022   modifyImage();
3023   options()->fontPointsize( pointSize_ );
3024 }
3025 double Magick::Image::fontPointsize ( void ) const
3026 {
3027   return constOptions()->fontPointsize( );
3028 }
3029
3030 // Font type metrics
3031 void Magick::Image::fontTypeMetrics( const std::string &text_,
3032                                      TypeMetric *metrics )
3033 {
3034   DrawInfo *drawInfo = options()->drawInfo();
3035   drawInfo->text = const_cast<char *>(text_.c_str());
3036   GetTypeMetrics( image(), drawInfo, &(metrics->_typeMetric) );
3037   drawInfo->text = 0;
3038 }
3039
3040 // Image format string
3041 std::string Magick::Image::format ( void ) const
3042 {
3043   ExceptionInfo exceptionInfo;
3044   GetExceptionInfo( &exceptionInfo );
3045   const MagickInfo * magick_info
3046     = GetMagickInfo( constImage()->magick, &exceptionInfo);
3047   throwException( exceptionInfo );
3048   (void) DestroyExceptionInfo( &exceptionInfo );
3049
3050   if (( magick_info != 0 ) &&
3051       ( *magick_info->description != '\0' ))
3052     return std::string(magick_info->description);
3053
3054   throwExceptionExplicit( CorruptImageWarning,
3055                           "Unrecognized image magick type" );
3056   return std::string();
3057 }
3058
3059 // Gamma adjustment
3060 double Magick::Image::gamma ( void ) const
3061 {
3062   return constImage()->gamma;
3063 }
3064
3065 Magick::Geometry Magick::Image::geometry ( void ) const
3066 {
3067   if ( constImage()->geometry )
3068   {
3069     return Geometry(constImage()->geometry);
3070   }
3071
3072   throwExceptionExplicit( OptionWarning,
3073                           "Image does not contain a geometry");
3074
3075   return Geometry();
3076 }
3077
3078 void Magick::Image::gifDisposeMethod ( const size_t disposeMethod_ )
3079 {
3080   modifyImage();
3081   image()->dispose = (DisposeType) disposeMethod_;
3082 }
3083 size_t Magick::Image::gifDisposeMethod ( void ) const
3084 {
3085   // FIXME: It would be better to return an enumeration
3086   return constImage()->dispose;
3087 }
3088
3089 // ICC ICM color profile (BLOB)
3090 void Magick::Image::iccColorProfile( const Magick::Blob &colorProfile_ )
3091 {
3092   profile("icm",colorProfile_);
3093 }
3094 Magick::Blob Magick::Image::iccColorProfile( void ) const
3095 {
3096   const StringInfo * color_profile = GetImageProfile( constImage(), "icc" );
3097   if ( color_profile == (StringInfo *) NULL)
3098     return Blob( 0, 0 );
3099   return Blob( GetStringInfoDatum(color_profile), GetStringInfoLength(color_profile) );
3100 }
3101
3102 void Magick::Image::interlaceType ( const Magick::InterlaceType interlace_ )
3103 {
3104   modifyImage();
3105   image()->interlace = interlace_;
3106   options()->interlaceType ( interlace_ );
3107 }
3108 Magick::InterlaceType Magick::Image::interlaceType ( void ) const
3109 {
3110   return constImage()->interlace;
3111 }
3112
3113 // IPTC profile (BLOB)
3114 void Magick::Image::iptcProfile( const Magick::Blob &iptcProfile_ )
3115 {
3116   modifyImage();
3117   if (  iptcProfile_.data() != 0 )
3118     {
3119       StringInfo * iptc_profile = AcquireStringInfo( iptcProfile_.length() );
3120       SetStringInfoDatum(iptc_profile ,(unsigned char *) iptcProfile_.data());
3121       (void) SetImageProfile( image(), "iptc", iptc_profile);
3122        iptc_profile =DestroyStringInfo( iptc_profile );
3123     }
3124 }
3125 Magick::Blob Magick::Image::iptcProfile( void ) const
3126 {
3127   const StringInfo * iptc_profile = GetImageProfile( constImage(), "iptc" );
3128   if ( iptc_profile == (StringInfo *) NULL)
3129     return Blob( 0, 0 );
3130   return Blob( GetStringInfoDatum(iptc_profile), GetStringInfoLength(iptc_profile));
3131 }
3132
3133 // Does object contain valid image?
3134 void Magick::Image::isValid ( const bool isValid_ )
3135 {
3136   if ( !isValid_ )
3137     {
3138       delete _imgRef;
3139       _imgRef = new ImageRef;
3140     }
3141   else if ( !isValid() )
3142     {
3143       // Construct with single-pixel black image to make
3144       // image valid.  This is an obvious hack.
3145       size( Geometry(1,1) );
3146       read( "xc:#000000" );
3147     }
3148 }
3149
3150 bool Magick::Image::isValid ( void ) const
3151 {
3152   if ( rows() && columns() )
3153     return true;
3154
3155   return false;
3156 }
3157
3158 // Label image
3159 void Magick::Image::label ( const std::string &label_ )
3160 {
3161   modifyImage();
3162   SetImageProperty ( image(), "Label", NULL );
3163   if ( label_.length() > 0 )
3164     SetImageProperty ( image(), "Label", label_.c_str() );
3165   throwImageException();
3166 }
3167 std::string Magick::Image::label ( void ) const
3168 {
3169   const char *value = GetImageProperty( constImage(), "Label" );
3170
3171   if ( value )
3172     return std::string( value );
3173
3174   return std::string();
3175 }
3176
3177 void Magick::Image::magick ( const std::string &magick_ )
3178 {
3179   modifyImage();
3180
3181   magick_.copy( image()->magick,
3182                 sizeof(image()->magick) - 1 );
3183   image()->magick[ magick_.length() ] = 0;
3184
3185   options()->magick( magick_ );
3186 }
3187 std::string Magick::Image::magick ( void ) const
3188 {
3189   if ( *(constImage()->magick) != '\0' )
3190     return std::string(constImage()->magick);
3191
3192   return constOptions()->magick( );
3193 }
3194
3195 void Magick::Image::matte ( const bool matteFlag_ )
3196 {
3197   modifyImage();
3198
3199   // If matte channel is requested, but image doesn't already have a
3200   // matte channel, then create an opaque matte channel.  Likewise, if
3201   // the image already has a matte channel but a matte channel is not
3202   // desired, then set the matte channel to opaque.
3203   if ((matteFlag_ && !constImage()->matte) ||
3204       (constImage()->matte && !matteFlag_))
3205     SetImageOpacity(image(),OpaqueOpacity);
3206
3207   image()->matte = (MagickBooleanType) matteFlag_;
3208 }
3209 bool Magick::Image::matte ( void ) const
3210 {
3211   if ( constImage()->matte )
3212     return true;
3213   else
3214     return false;
3215 }
3216
3217 void Magick::Image::matteColor ( const Color &matteColor_ )
3218 {
3219   modifyImage();
3220
3221   if ( matteColor_.isValid() )
3222     {
3223       image()->matte_color = matteColor_;
3224       options()->matteColor( matteColor_ );
3225     }
3226   else
3227     {
3228       // Set to default matte color
3229       Color tmpColor( "#BDBDBD" );
3230       image()->matte_color = tmpColor;
3231       options()->matteColor( tmpColor );
3232     }
3233 }
3234 Magick::Color Magick::Image::matteColor ( void ) const
3235 {
3236   return Color( constImage()->matte_color.red,
3237                 constImage()->matte_color.green,
3238                 constImage()->matte_color.blue );
3239 }
3240
3241 double Magick::Image::meanErrorPerPixel ( void ) const
3242 {
3243   return(constImage()->error.mean_error_per_pixel);
3244 }
3245
3246 // Image modulus depth (minimum number of bits required to support
3247 // red/green/blue components without loss of accuracy)
3248 void Magick::Image::modulusDepth ( const size_t depth_ )
3249 {
3250   modifyImage();
3251   SetImageDepth( image(), depth_ );
3252   options()->depth( depth_ );
3253 }
3254 size_t Magick::Image::modulusDepth ( void ) const
3255 {
3256   ExceptionInfo exceptionInfo;
3257   GetExceptionInfo( &exceptionInfo );
3258   size_t depth=GetImageDepth( constImage(), &exceptionInfo );
3259   throwException( exceptionInfo );
3260   (void) DestroyExceptionInfo( &exceptionInfo );
3261   return depth;
3262 }
3263
3264 void Magick::Image::monochrome ( const bool monochromeFlag_ )
3265 {
3266   modifyImage();
3267   options()->monochrome( monochromeFlag_ );
3268 }
3269 bool Magick::Image::monochrome ( void ) const
3270 {
3271   return constOptions()->monochrome( );
3272 }
3273
3274 Magick::Geometry Magick::Image::montageGeometry ( void ) const
3275 {
3276   if ( constImage()->montage )
3277     return Magick::Geometry(constImage()->montage);
3278
3279   throwExceptionExplicit( CorruptImageWarning,
3280                           "Image does not contain a montage" );
3281
3282   return Magick::Geometry();
3283 }
3284
3285 double Magick::Image::normalizedMaxError ( void ) const
3286 {
3287   return(constImage()->error.normalized_maximum_error);
3288 }
3289
3290 double Magick::Image::normalizedMeanError ( void ) const
3291 {
3292   return constImage()->error.normalized_mean_error;
3293 }
3294
3295 // Image orientation
3296 void Magick::Image::orientation ( const Magick::OrientationType orientation_ )
3297 {
3298   modifyImage();
3299   image()->orientation = orientation_;
3300 }
3301 Magick::OrientationType Magick::Image::orientation ( void ) const
3302 {
3303   return constImage()->orientation;
3304 }
3305
3306 void Magick::Image::penColor ( const Color &penColor_ )
3307 {
3308   modifyImage();
3309   options()->fillColor(penColor_);
3310   options()->strokeColor(penColor_);
3311 }
3312 Magick::Color Magick::Image::penColor ( void  ) const
3313 {
3314   return constOptions()->fillColor();
3315 }
3316
3317 void Magick::Image::penTexture ( const Image &penTexture_ )
3318 {
3319   modifyImage();
3320   if(penTexture_.isValid())
3321     options()->fillPattern( penTexture_.constImage() );
3322   else
3323     options()->fillPattern( static_cast<MagickCore::Image*>(NULL) );
3324 }
3325
3326 Magick::Image  Magick::Image::penTexture ( void  ) const
3327 {
3328   // FIXME: This is inordinately innefficient
3329   Image texture;
3330
3331   const MagickCore::Image* tmpTexture = constOptions()->fillPattern( );
3332
3333   if ( tmpTexture )
3334     {
3335       ExceptionInfo exceptionInfo;
3336       GetExceptionInfo( &exceptionInfo );
3337       MagickCore::Image* image =
3338         CloneImage( tmpTexture,
3339                     0, // columns
3340                     0, // rows
3341                     MagickTrue, // orphan
3342                     &exceptionInfo);
3343       texture.replaceImage( image );
3344       throwException( exceptionInfo );
3345   (void) DestroyExceptionInfo( &exceptionInfo );
3346     }
3347   return texture;
3348 }
3349
3350 // Set the color of a pixel.
3351 void Magick::Image::pixelColor ( const ssize_t x_, const ssize_t y_,
3352                                  const Color &color_ )
3353 {
3354   // Test arguments to ensure they are within the image.
3355   if ( y_ > (ssize_t) rows() || x_ > (ssize_t) columns() )
3356     throwExceptionExplicit( OptionError,
3357             "Access outside of image boundary" );
3358
3359   modifyImage();
3360
3361   // Set image to DirectClass
3362   classType( DirectClass );
3363
3364   // Get pixel view
3365   Pixels pixels(*this);
3366     // Set pixel value
3367   *(pixels.get(x_, y_, 1, 1 )) = color_;
3368   // Tell ImageMagick that pixels have been updated
3369   pixels.sync();
3370
3371   return;
3372 }
3373
3374 // Get the color of a pixel
3375 Magick::Color Magick::Image::pixelColor ( const ssize_t x_,
3376                                           const ssize_t y_ ) const
3377 {
3378   ClassType storage_class;
3379   storage_class = classType();
3380   // DirectClass
3381   const PixelPacket* pixel = getConstPixels( x_, y_, 1, 1 );
3382   if ( storage_class == DirectClass )
3383     {
3384       if ( pixel )
3385         return Color( *pixel );
3386     }
3387
3388   // PseudoClass
3389   if ( storage_class == PseudoClass )
3390     {
3391       const IndexPacket* indexes = getConstIndexes();
3392       if ( indexes )
3393         return colorMap( (size_t) *indexes );
3394     }
3395
3396   return Color(); // invalid
3397 }
3398
3399 // Preferred size and location of an image canvas.
3400 void Magick::Image::page ( const Magick::Geometry &pageSize_ )
3401 {
3402   modifyImage();
3403   options()->page( pageSize_ );
3404   image()->page = pageSize_;
3405 }
3406 Magick::Geometry Magick::Image::page ( void ) const
3407 {
3408   return Geometry( constImage()->page.width,
3409                    constImage()->page.height,
3410                    AbsoluteValue(constImage()->page.x),
3411                    AbsoluteValue(constImage()->page.y),
3412                    constImage()->page.x < 0 ? true : false,
3413                    constImage()->page.y < 0 ? true : false);
3414 }
3415
3416 // Add a named profile to an image or remove a named profile by
3417 // passing an empty Blob (use default Blob constructor).
3418 // Valid names are:
3419 // "*", "8BIM", "ICM", "IPTC", or a generic profile name.
3420 void Magick::Image::profile( const std::string name_,
3421                              const Magick::Blob &profile_ )
3422 {
3423   modifyImage();
3424   ssize_t result = ProfileImage( image(), name_.c_str(),
3425                              (unsigned char *)profile_.data(),
3426                              profile_.length(), MagickTrue);
3427
3428   if( !result )
3429     throwImageException();
3430 }
3431
3432 // Retrieve a named profile from the image.
3433 // Valid names are:
3434 // "8BIM", "8BIMTEXT", "APP1", "APP1JPEG", "ICC", "ICM", & "IPTC" or
3435 // an existing generic profile name.
3436 Magick::Blob Magick::Image::profile( const std::string name_ ) const
3437 {
3438   const MagickCore::Image* image = constImage();
3439
3440   const StringInfo * profile = GetImageProfile( image, name_.c_str() );
3441
3442   if ( profile != (StringInfo *) NULL)
3443       return Blob( (void*) GetStringInfoDatum(profile), GetStringInfoLength(profile));
3444
3445   Blob blob;
3446   Image temp_image = *this;
3447   temp_image.write( &blob, name_ );
3448   return blob;
3449 }
3450
3451 void Magick::Image::quality ( const size_t quality_ )
3452 {
3453   modifyImage();
3454   image()->quality = quality_;
3455   options()->quality( quality_ );
3456 }
3457 size_t Magick::Image::quality ( void ) const
3458 {
3459   return constImage()->quality;
3460 }
3461
3462 void Magick::Image::quantizeColors ( const size_t colors_ )
3463 {
3464   modifyImage();
3465   options()->quantizeColors( colors_ );
3466 }
3467 size_t Magick::Image::quantizeColors ( void ) const
3468 {
3469   return constOptions()->quantizeColors( );
3470 }
3471
3472 void Magick::Image::quantizeColorSpace
3473   ( const Magick::ColorspaceType colorSpace_ )
3474 {
3475   modifyImage();
3476   options()->quantizeColorSpace( colorSpace_ );
3477 }
3478 Magick::ColorspaceType Magick::Image::quantizeColorSpace ( void ) const
3479 {
3480   return constOptions()->quantizeColorSpace( );
3481 }
3482
3483 void Magick::Image::quantizeDither ( const bool ditherFlag_ )
3484 {
3485   modifyImage();
3486   options()->quantizeDither( ditherFlag_ );
3487 }
3488 bool Magick::Image::quantizeDither ( void ) const
3489 {
3490   return constOptions()->quantizeDither( );
3491 }
3492
3493 void Magick::Image::quantizeTreeDepth ( const size_t treeDepth_ )
3494 {
3495   modifyImage();
3496   options()->quantizeTreeDepth( treeDepth_ );
3497 }
3498 size_t Magick::Image::quantizeTreeDepth ( void ) const
3499 {
3500   return constOptions()->quantizeTreeDepth( );
3501 }
3502
3503 void Magick::Image::renderingIntent
3504   ( const Magick::RenderingIntent renderingIntent_ )
3505 {
3506   modifyImage();
3507   image()->rendering_intent = renderingIntent_;
3508 }
3509 Magick::RenderingIntent Magick::Image::renderingIntent ( void ) const
3510 {
3511   return static_cast<Magick::RenderingIntent>(constImage()->rendering_intent);
3512 }
3513
3514 void Magick::Image::resolutionUnits
3515   ( const Magick::ResolutionType resolutionUnits_ )
3516 {
3517   modifyImage();
3518   image()->units = resolutionUnits_;
3519   options()->resolutionUnits( resolutionUnits_ );
3520 }
3521 Magick::ResolutionType Magick::Image::resolutionUnits ( void ) const
3522 {
3523   return constOptions()->resolutionUnits( );
3524 }
3525
3526 void Magick::Image::scene ( const size_t scene_ )
3527 {
3528   modifyImage();
3529   image()->scene = scene_;
3530 }
3531 size_t Magick::Image::scene ( void ) const
3532 {
3533   return constImage()->scene;
3534 }
3535
3536 std::string Magick::Image::signature ( const bool force_ ) const
3537 {
3538   Lock( &_imgRef->_mutexLock );
3539
3540   // Re-calculate image signature if necessary
3541   if ( force_ ||
3542        !GetImageProperty(constImage(), "Signature") ||
3543        constImage()->taint )
3544     {
3545       SignatureImage( const_cast<MagickCore::Image *>(constImage()) );
3546     }
3547
3548   const char *property = GetImageProperty(constImage(), "Signature");
3549
3550   return std::string( property );
3551 }
3552
3553 void Magick::Image::size ( const Geometry &geometry_ )
3554 {
3555   modifyImage();
3556   options()->size( geometry_ );
3557   image()->rows = geometry_.height();
3558   image()->columns = geometry_.width();
3559 }
3560 Magick::Geometry Magick::Image::size ( void ) const
3561 {
3562   return Magick::Geometry( constImage()->columns, constImage()->rows );
3563 }
3564
3565 // Splice image
3566 void Magick::Image::splice( const Geometry &geometry_ )
3567 {
3568   RectangleInfo spliceInfo = geometry_;
3569   ExceptionInfo exceptionInfo;
3570   GetExceptionInfo( &exceptionInfo );
3571   MagickCore::Image* newImage =
3572     SpliceImage( image(), &spliceInfo, &exceptionInfo);
3573   replaceImage( newImage );
3574   throwException( exceptionInfo );
3575   (void) DestroyExceptionInfo( &exceptionInfo );
3576 }
3577
3578 // Obtain image statistics. Statistics are normalized to the range of
3579 // 0.0 to 1.0 and are output to the specified ImageStatistics
3580 // structure.
3581 void Magick::Image::statistics ( ImageStatistics *statistics ) const
3582 {
3583   double
3584     maximum,
3585     minimum;
3586
3587   ExceptionInfo exceptionInfo;
3588   GetExceptionInfo( &exceptionInfo );
3589   (void) GetImageChannelRange(constImage(),RedChannel,&minimum,&maximum,
3590     &exceptionInfo);
3591   statistics->red.minimum=minimum;
3592         statistics->red.maximum=maximum;
3593   (void) GetImageChannelMean(constImage(),RedChannel,
3594     &statistics->red.mean,&statistics->red.standard_deviation,&exceptionInfo);
3595   (void) GetImageChannelKurtosis(constImage(),RedChannel,
3596     &statistics->red.kurtosis,&statistics->red.skewness,&exceptionInfo);
3597   (void) GetImageChannelRange(constImage(),GreenChannel,&minimum,&maximum,
3598     &exceptionInfo);
3599   statistics->green.minimum=minimum;
3600         statistics->green.maximum=maximum;
3601   (void) GetImageChannelMean(constImage(),GreenChannel,
3602     &statistics->green.mean,&statistics->green.standard_deviation,
3603     &exceptionInfo);
3604   (void) GetImageChannelKurtosis(constImage(),GreenChannel,
3605     &statistics->green.kurtosis,&statistics->green.skewness,&exceptionInfo);
3606   (void) GetImageChannelRange(constImage(),BlueChannel,&minimum,&maximum,
3607     &exceptionInfo);
3608   statistics->blue.minimum=minimum;
3609         statistics->blue.maximum=maximum;
3610   (void) GetImageChannelMean(constImage(),BlueChannel,
3611     &statistics->blue.mean,&statistics->blue.standard_deviation,&exceptionInfo);
3612   (void) GetImageChannelKurtosis(constImage(),BlueChannel,
3613     &statistics->blue.kurtosis,&statistics->blue.skewness,&exceptionInfo);
3614   (void) GetImageChannelRange(constImage(),OpacityChannel,&minimum,&maximum,
3615     &exceptionInfo);
3616   statistics->opacity.minimum=minimum;
3617         statistics->opacity.maximum=maximum;
3618   (void) GetImageChannelMean(constImage(),OpacityChannel,
3619     &statistics->opacity.mean,&statistics->opacity.standard_deviation,
3620     &exceptionInfo);
3621   (void) GetImageChannelKurtosis(constImage(),OpacityChannel,
3622     &statistics->opacity.kurtosis,&statistics->opacity.skewness,&exceptionInfo);
3623   throwException( exceptionInfo );
3624   (void) DestroyExceptionInfo( &exceptionInfo );
3625 }
3626
3627 // Strip strips an image of all profiles and comments.
3628 void Magick::Image::strip ( void )
3629 {
3630   modifyImage();
3631   StripImage( image() );
3632   throwImageException();
3633 }
3634
3635 // enabled/disable stroke anti-aliasing
3636 void Magick::Image::strokeAntiAlias ( const bool flag_ )
3637 {
3638   modifyImage();
3639   options()->strokeAntiAlias(flag_);
3640 }
3641 bool Magick::Image::strokeAntiAlias ( void ) const
3642 {
3643   return constOptions()->strokeAntiAlias();
3644 }
3645
3646 // Color to use when drawing object outlines
3647 void Magick::Image::strokeColor ( const Magick::Color &strokeColor_ )
3648 {
3649   modifyImage();
3650   options()->strokeColor(strokeColor_);
3651 }
3652 Magick::Color Magick::Image::strokeColor ( void ) const
3653 {
3654   return constOptions()->strokeColor();
3655 }
3656
3657 // dash pattern for drawing vector objects (default one)
3658 void Magick::Image::strokeDashArray ( const double* strokeDashArray_ )
3659 {
3660   modifyImage();
3661   options()->strokeDashArray( strokeDashArray_ );
3662 }
3663
3664 const double* Magick::Image::strokeDashArray ( void ) const
3665 {
3666   return constOptions()->strokeDashArray( );
3667 }
3668
3669 // dash offset for drawing vector objects (default one)
3670 void Magick::Image::strokeDashOffset ( const double strokeDashOffset_ )
3671 {
3672   modifyImage();
3673   options()->strokeDashOffset( strokeDashOffset_ );
3674 }
3675
3676 double Magick::Image::strokeDashOffset ( void ) const
3677 {
3678   return constOptions()->strokeDashOffset( );
3679 }
3680
3681 // Specify the shape to be used at the end of open subpaths when they
3682 // are stroked. Values of LineCap are UndefinedCap, ButtCap, RoundCap,
3683 // and SquareCap.
3684 void Magick::Image::strokeLineCap ( const Magick::LineCap lineCap_ )
3685 {
3686   modifyImage();
3687   options()->strokeLineCap( lineCap_ );
3688 }
3689 Magick::LineCap Magick::Image::strokeLineCap ( void ) const
3690 {
3691   return constOptions()->strokeLineCap( );
3692 }
3693
3694 // Specify the shape to be used at the corners of paths (or other
3695 // vector shapes) when they are stroked. Values of LineJoin are
3696 // UndefinedJoin, MiterJoin, RoundJoin, and BevelJoin.
3697 void Magick::Image::strokeLineJoin ( const Magick::LineJoin lineJoin_ )
3698 {
3699   modifyImage();
3700   options()->strokeLineJoin( lineJoin_ );
3701 }
3702 Magick::LineJoin Magick::Image::strokeLineJoin ( void ) const
3703 {
3704   return constOptions()->strokeLineJoin( );
3705 }
3706
3707 // Specify miter limit. When two line segments meet at a sharp angle
3708 // and miter joins have been specified for 'lineJoin', it is possible
3709 // for the miter to extend far beyond the thickness of the line
3710 // stroking the path. The miterLimit' imposes a limit on the ratio of
3711 // the miter length to the 'lineWidth'. The default value of this
3712 // parameter is 4.
3713 void Magick::Image::strokeMiterLimit ( const size_t strokeMiterLimit_ )
3714 {
3715   modifyImage();
3716   options()->strokeMiterLimit( strokeMiterLimit_ );
3717 }
3718 size_t Magick::Image::strokeMiterLimit ( void ) const
3719 {
3720   return constOptions()->strokeMiterLimit( );
3721 }
3722
3723 // Pattern to use while stroking drawn objects.
3724 void Magick::Image::strokePattern ( const Image &strokePattern_ )
3725 {
3726   modifyImage();
3727   if(strokePattern_.isValid())
3728     options()->strokePattern( strokePattern_.constImage() );
3729   else
3730     options()->strokePattern( static_cast<MagickCore::Image*>(NULL) );
3731 }
3732 Magick::Image  Magick::Image::strokePattern ( void  ) const
3733 {
3734   // FIXME: This is inordinately innefficient
3735   Image texture;
3736
3737   const MagickCore::Image* tmpTexture = constOptions()->strokePattern( );
3738
3739   if ( tmpTexture )
3740     {
3741       ExceptionInfo exceptionInfo;
3742       GetExceptionInfo( &exceptionInfo );
3743       MagickCore::Image* image =
3744         CloneImage( tmpTexture,
3745                     0, // columns
3746                     0, // rows
3747                     MagickTrue, // orphan
3748                     &exceptionInfo);
3749       throwException( exceptionInfo );
3750   (void) DestroyExceptionInfo( &exceptionInfo );
3751       texture.replaceImage( image );
3752     }
3753   return texture;
3754 }
3755
3756 // Stroke width for drawing lines, circles, ellipses, etc.
3757 void Magick::Image::strokeWidth ( const double strokeWidth_ )
3758 {
3759   modifyImage();
3760   options()->strokeWidth( strokeWidth_ );
3761 }
3762 double Magick::Image::strokeWidth ( void ) const
3763 {
3764   return constOptions()->strokeWidth( );
3765 }
3766
3767 void Magick::Image::subImage ( const size_t subImage_ )
3768 {
3769   modifyImage();
3770   options()->subImage( subImage_ );
3771 }
3772 size_t Magick::Image::subImage ( void ) const
3773 {
3774   return constOptions()->subImage( );
3775 }
3776
3777 void Magick::Image::subRange ( const size_t subRange_ )
3778 {
3779   modifyImage();
3780   options()->subRange( subRange_ );
3781 }
3782 size_t Magick::Image::subRange ( void ) const
3783 {
3784   return constOptions()->subRange( );
3785 }
3786
3787 // Annotation text encoding (e.g. "UTF-16")
3788 void Magick::Image::textEncoding ( const std::string &encoding_ )
3789 {
3790   modifyImage();
3791   options()->textEncoding( encoding_ );
3792 }
3793 std::string Magick::Image::textEncoding ( void ) const
3794 {
3795   return constOptions()->textEncoding( );
3796 }
3797
3798 void Magick::Image::tileName ( const std::string &tileName_ )
3799 {
3800   modifyImage();
3801   options()->tileName( tileName_ );
3802 }
3803 std::string Magick::Image::tileName ( void ) const
3804 {
3805   return constOptions()->tileName( );
3806 }
3807
3808 size_t Magick::Image::totalColors ( void )
3809 {
3810   ExceptionInfo exceptionInfo;
3811   GetExceptionInfo( &exceptionInfo );
3812   size_t colors = GetNumberColors( image(), 0, &exceptionInfo);
3813   throwException( exceptionInfo );
3814   (void) DestroyExceptionInfo( &exceptionInfo );
3815   return colors;
3816 }
3817
3818 // Origin of coordinate system to use when annotating with text or drawing
3819 void Magick::Image::transformOrigin ( const double x_, const double y_ )
3820 {
3821   modifyImage();
3822   options()->transformOrigin( x_, y_ );
3823 }
3824
3825 // Rotation to use when annotating with text or drawing
3826 void Magick::Image::transformRotation ( const double angle_ )
3827 {
3828   modifyImage();
3829   options()->transformRotation( angle_ );
3830 }
3831
3832 // Reset transformation parameters to default
3833 void Magick::Image::transformReset ( void )
3834 {
3835   modifyImage();
3836   options()->transformReset();
3837 }
3838
3839 // Scale to use when annotating with text or drawing
3840 void Magick::Image::transformScale ( const double sx_, const double sy_ )
3841 {
3842   modifyImage();
3843   options()->transformScale( sx_, sy_ );
3844 }
3845
3846 // Skew to use in X axis when annotating with text or drawing
3847 void Magick::Image::transformSkewX ( const double skewx_ )
3848 {
3849   modifyImage();
3850   options()->transformSkewX( skewx_ );
3851 }
3852
3853 // Skew to use in Y axis when annotating with text or drawing
3854 void Magick::Image::transformSkewY ( const double skewy_ )
3855 {
3856   modifyImage();
3857   options()->transformSkewY( skewy_ );
3858 }
3859
3860 // Image representation type
3861 Magick::ImageType Magick::Image::type ( void ) const
3862 {
3863
3864   ExceptionInfo exceptionInfo;
3865   GetExceptionInfo( &exceptionInfo );
3866   ImageType image_type = constOptions()->type();
3867   if ( image_type == UndefinedType )
3868     image_type= GetImageType( constImage(), &exceptionInfo);
3869   throwException( exceptionInfo );
3870   (void) DestroyExceptionInfo( &exceptionInfo );
3871   return image_type;
3872 }
3873 void Magick::Image::type ( const Magick::ImageType type_)
3874 {
3875   modifyImage();
3876   options()->type( type_ );
3877   SetImageType( image(), type_ );
3878 }
3879
3880 void Magick::Image::verbose ( const bool verboseFlag_ )
3881 {
3882   modifyImage();
3883   options()->verbose( verboseFlag_ );
3884 }
3885 bool Magick::Image::verbose ( void ) const
3886 {
3887   return constOptions()->verbose( );
3888 }
3889
3890 void Magick::Image::view ( const std::string &view_ )
3891 {
3892   modifyImage();
3893   options()->view( view_ );
3894 }
3895 std::string Magick::Image::view ( void ) const
3896 {
3897   return constOptions()->view( );
3898 }
3899
3900 // Virtual pixel method
3901 void Magick::Image::virtualPixelMethod ( const VirtualPixelMethod virtual_pixel_method_ )
3902 {
3903   modifyImage();
3904   SetImageVirtualPixelMethod( image(), virtual_pixel_method_ );
3905   options()->virtualPixelMethod( virtual_pixel_method_ );
3906 }
3907 Magick::VirtualPixelMethod Magick::Image::virtualPixelMethod ( void ) const
3908 {
3909   return GetImageVirtualPixelMethod( constImage() );
3910 }
3911
3912 void Magick::Image::x11Display ( const std::string &display_ )
3913 {
3914   modifyImage();
3915   options()->x11Display( display_ );
3916 }
3917 std::string Magick::Image::x11Display ( void ) const
3918 {
3919   return constOptions()->x11Display( );
3920 }
3921
3922 double Magick::Image::xResolution ( void ) const
3923 {
3924   return constImage()->x_resolution;
3925 }
3926 double Magick::Image::yResolution ( void ) const
3927 {
3928   return constImage()->y_resolution;
3929 }
3930
3931 // Copy Constructor
3932 Magick::Image::Image( const Image & image_ )
3933   : _imgRef(image_._imgRef)
3934 {
3935   Lock( &_imgRef->_mutexLock );
3936
3937   // Increase reference count
3938   ++_imgRef->_refCount;
3939 }
3940
3941 // Assignment operator
3942 Magick::Image& Magick::Image::operator=( const Magick::Image &image_ )
3943 {
3944   if( this != &image_ )
3945     {
3946       {
3947         Lock( &image_._imgRef->_mutexLock );
3948         ++image_._imgRef->_refCount;
3949       }
3950
3951       bool doDelete = false;
3952       {
3953         Lock( &_imgRef->_mutexLock );
3954         if ( --_imgRef->_refCount == 0 )
3955           doDelete = true;
3956       }
3957
3958       if ( doDelete )
3959         {
3960           // Delete old image reference with associated image and options.
3961           delete _imgRef;
3962           _imgRef = 0;
3963         }
3964       // Use new image reference
3965       _imgRef = image_._imgRef;
3966     }
3967
3968   return *this;
3969 }
3970
3971 //////////////////////////////////////////////////////////////////////
3972 //
3973 // Low-level Pixel Access Routines
3974 //
3975 // Also see the Pixels class, which provides support for multiple
3976 // cache views. The low-level pixel access routines in the Image
3977 // class are provided in order to support backward compatability.
3978 //
3979 //////////////////////////////////////////////////////////////////////
3980
3981 // Transfers read-only pixels from the image to the pixel cache as
3982 // defined by the specified region
3983 const Magick::PixelPacket* Magick::Image::getConstPixels
3984   ( const ssize_t x_, const ssize_t y_,
3985     const size_t columns_,
3986     const size_t rows_ ) const
3987 {
3988   ExceptionInfo exceptionInfo;
3989   GetExceptionInfo( &exceptionInfo );
3990   const PixelPacket* p = (*GetVirtualPixels)( constImage(),
3991                                                 x_, y_,
3992                                                 columns_, rows_,
3993                                                 &exceptionInfo );
3994   throwException( exceptionInfo );
3995   (void) DestroyExceptionInfo( &exceptionInfo );
3996   return p;
3997 }
3998
3999 // Obtain read-only pixel indexes (valid for PseudoClass images)
4000 const Magick::IndexPacket* Magick::Image::getConstIndexes ( void ) const
4001 {
4002   const Magick::IndexPacket* result = GetVirtualIndexQueue( constImage() );
4003
4004   if( !result )
4005     throwImageException();
4006
4007   return result;
4008 }
4009
4010 // Obtain image pixel indexes (valid for PseudoClass images)
4011 Magick::IndexPacket* Magick::Image::getIndexes ( void )
4012 {
4013   Magick::IndexPacket* result = GetAuthenticIndexQueue( image() );
4014
4015   if( !result )
4016     throwImageException();
4017
4018   return ( result );
4019 }
4020
4021 // Transfers pixels from the image to the pixel cache as defined
4022 // by the specified region. Modified pixels may be subsequently
4023 // transferred back to the image via syncPixels.
4024 Magick::PixelPacket* Magick::Image::getPixels ( const ssize_t x_, const ssize_t y_,
4025                                                 const size_t columns_,
4026                                                 const size_t rows_ )
4027 {
4028   modifyImage();
4029   ExceptionInfo exceptionInfo;
4030   GetExceptionInfo( &exceptionInfo );
4031   PixelPacket* result = (*GetAuthenticPixels)( image(),
4032                                            x_, y_,
4033                                            columns_, rows_, &exceptionInfo );
4034   throwException( exceptionInfo );
4035   (void) DestroyExceptionInfo( &exceptionInfo );
4036
4037   return result;
4038 }
4039
4040 // Allocates a pixel cache region to store image pixels as defined
4041 // by the region rectangle.  This area is subsequently transferred
4042 // from the pixel cache to the image via syncPixels.
4043 Magick::PixelPacket* Magick::Image::setPixels ( const ssize_t x_, const ssize_t y_,
4044                                                 const size_t columns_,
4045                                                 const size_t rows_ )
4046 {
4047   modifyImage();
4048   ExceptionInfo exceptionInfo;
4049   GetExceptionInfo( &exceptionInfo );
4050   PixelPacket* result = (*QueueAuthenticPixels)( image(),
4051                                            x_, y_,
4052                                            columns_, rows_, &exceptionInfo );
4053   throwException( exceptionInfo );
4054   (void) DestroyExceptionInfo( &exceptionInfo );
4055
4056   return result;
4057 }
4058
4059 // Transfers the image cache pixels to the image.
4060 void Magick::Image::syncPixels ( void )
4061 {
4062   ExceptionInfo exceptionInfo;
4063   GetExceptionInfo( &exceptionInfo );
4064   (*SyncAuthenticPixels)( image(), &exceptionInfo );
4065   throwException( exceptionInfo );
4066   (void) DestroyExceptionInfo( &exceptionInfo );
4067 }
4068
4069 // Transfers one or more pixel components from a buffer or file
4070 // into the image pixel cache of an image.
4071 // Used to support image decoders.
4072 void Magick::Image::readPixels ( const Magick::QuantumType quantum_,
4073                                  const unsigned char *source_ )
4074 {
4075   QuantumInfo
4076     *quantum_info;
4077
4078   quantum_info=AcquireQuantumInfo(imageInfo(),image());
4079   ExceptionInfo exceptionInfo;
4080   GetExceptionInfo( &exceptionInfo );
4081   ImportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
4082     quantum_,source_, &exceptionInfo);
4083   throwException( exceptionInfo );
4084   (void) DestroyExceptionInfo( &exceptionInfo );
4085   quantum_info=DestroyQuantumInfo(quantum_info);
4086 }
4087
4088 // Transfers one or more pixel components from the image pixel
4089 // cache to a buffer or file.
4090 // Used to support image encoders.
4091 void Magick::Image::writePixels ( const Magick::QuantumType quantum_,
4092                                   unsigned char *destination_ )
4093 {
4094   QuantumInfo
4095     *quantum_info;
4096
4097   quantum_info=AcquireQuantumInfo(imageInfo(),image());
4098   ExceptionInfo exceptionInfo;
4099   GetExceptionInfo( &exceptionInfo );
4100   ExportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
4101     quantum_,destination_, &exceptionInfo);
4102   quantum_info=DestroyQuantumInfo(quantum_info);
4103   throwException( exceptionInfo );
4104   (void) DestroyExceptionInfo( &exceptionInfo );
4105 }
4106
4107 /////////////////////////////////////////////////////////////////////
4108 //
4109 // No end-user methods beyond this point
4110 //
4111 /////////////////////////////////////////////////////////////////////
4112
4113
4114 //
4115 // Construct using existing image and default options
4116 //
4117 Magick::Image::Image ( MagickCore::Image* image_ )
4118   : _imgRef(new ImageRef( image_))
4119 {
4120 }
4121
4122 // Get Magick::Options*
4123 Magick::Options* Magick::Image::options( void )
4124 {
4125   return _imgRef->options();
4126 }
4127 const Magick::Options* Magick::Image::constOptions( void ) const
4128 {
4129   return _imgRef->options();
4130 }
4131
4132 // Get MagickCore::Image*
4133 MagickCore::Image*& Magick::Image::image( void )
4134 {
4135   return _imgRef->image();
4136 }
4137 const MagickCore::Image* Magick::Image::constImage( void ) const
4138 {
4139   return _imgRef->image();
4140 }
4141
4142 // Get ImageInfo *
4143 MagickCore::ImageInfo* Magick::Image::imageInfo( void )
4144 {
4145   return _imgRef->options()->imageInfo();
4146 }
4147 const MagickCore::ImageInfo * Magick::Image::constImageInfo( void ) const
4148 {
4149   return _imgRef->options()->imageInfo();
4150 }
4151
4152 // Get QuantizeInfo *
4153 MagickCore::QuantizeInfo* Magick::Image::quantizeInfo( void )
4154 {
4155   return _imgRef->options()->quantizeInfo();
4156 }
4157 const MagickCore::QuantizeInfo * Magick::Image::constQuantizeInfo( void ) const
4158 {
4159   return _imgRef->options()->quantizeInfo();
4160 }
4161
4162 //
4163 // Replace current image
4164 //
4165 MagickCore::Image * Magick::Image::replaceImage
4166   ( MagickCore::Image* replacement_ )
4167 {
4168   MagickCore::Image* image;
4169
4170   if( replacement_ )
4171     image = replacement_;
4172   else
4173     image = AcquireImage(constImageInfo());
4174
4175   {
4176     Lock( &_imgRef->_mutexLock );
4177
4178     if ( _imgRef->_refCount == 1 )
4179       {
4180         // We own the image, just replace it, and de-register
4181         _imgRef->id( -1 );
4182         _imgRef->image(image);
4183       }
4184     else
4185       {
4186         // We don't own the image, dereference and replace with copy
4187         --_imgRef->_refCount;
4188         _imgRef = new ImageRef( image, constOptions() );
4189       }
4190   }
4191
4192   return _imgRef->_image;
4193 }
4194
4195 //
4196 // Prepare to modify image or image options
4197 // Replace current image and options with copy if reference count > 1
4198 //
4199 void Magick::Image::modifyImage( void )
4200 {
4201   {
4202     Lock( &_imgRef->_mutexLock );
4203     if ( _imgRef->_refCount == 1 )
4204       {
4205         // De-register image and return
4206         _imgRef->id( -1 );
4207         return;
4208       }
4209   }
4210
4211   ExceptionInfo exceptionInfo;
4212   GetExceptionInfo( &exceptionInfo );
4213   replaceImage( CloneImage( image(),
4214                             0, // columns
4215                             0, // rows
4216                             MagickTrue, // orphan
4217                             &exceptionInfo) );
4218   throwException( exceptionInfo );
4219   (void) DestroyExceptionInfo( &exceptionInfo );
4220   return;
4221 }
4222
4223 //
4224 // Test for an ImageMagick reported error and throw exception if one
4225 // has been reported.  Secretly resets image->exception back to default
4226 // state even though this method is const.
4227 //
4228 void Magick::Image::throwImageException( void ) const
4229 {
4230   // Throw C++ exception while resetting Image exception to default state
4231   throwException( const_cast<MagickCore::Image*>(constImage())->exception );
4232 }
4233
4234 // Register image with image registry or obtain registration id
4235 ssize_t Magick::Image::registerId( void )
4236 {
4237   Lock( &_imgRef->_mutexLock );
4238   if( _imgRef->id() < 0 )
4239     {
4240       char id[MaxTextExtent];
4241       ExceptionInfo exceptionInfo;
4242       GetExceptionInfo( &exceptionInfo );
4243       _imgRef->id(_imgRef->id()+1);
4244       sprintf(id,"%.20g\n",(double) _imgRef->id());
4245       SetImageRegistry(ImageRegistryType, id, image(), &exceptionInfo);
4246       throwException( exceptionInfo );
4247   (void) DestroyExceptionInfo( &exceptionInfo );
4248     }
4249   return _imgRef->id();
4250 }
4251
4252 // Unregister image from image registry
4253 void Magick::Image::unregisterId( void )
4254 {
4255   modifyImage();
4256   _imgRef->id( -1 );
4257 }
4258
4259 //
4260 // Create a local wrapper around MagickCoreTerminus
4261 //
4262 namespace Magick
4263 {
4264   extern "C" {
4265     void MagickPlusPlusDestroyMagick(void);
4266   }
4267 }
4268
4269 void Magick::MagickPlusPlusDestroyMagick(void)
4270 {
4271   if (magick_initialized)
4272     {
4273       magick_initialized=false;
4274       MagickCore::MagickCoreTerminus();
4275     }
4276 }
4277
4278 // C library initialization routine
4279 void MagickDLLDecl Magick::InitializeMagick(const char *path_)
4280 {
4281   MagickCore::MagickCoreGenesis(path_,MagickFalse);
4282   if (!magick_initialized)
4283     magick_initialized=true;
4284 }
4285
4286 //
4287 // Cleanup class to ensure that ImageMagick singletons are destroyed
4288 // so as to avoid any resemblence to a memory leak (which seems to
4289 // confuse users)
4290 //
4291 namespace Magick
4292 {
4293
4294   class MagickCleanUp
4295   {
4296   public:
4297     MagickCleanUp( void );
4298     ~MagickCleanUp( void );
4299   };
4300
4301   // The destructor for this object is invoked when the destructors for
4302   // static objects in this translation unit are invoked.
4303   static MagickCleanUp magickCleanUpGuard;
4304 }
4305
4306 Magick::MagickCleanUp::MagickCleanUp ( void )
4307 {
4308   // Don't even think about invoking InitializeMagick here!
4309 }
4310
4311 Magick::MagickCleanUp::~MagickCleanUp ( void )
4312 {
4313   MagickPlusPlusDestroyMagick();
4314 }