source: ImageMagick/branches/ImageMagick-6.7.1/Magick++/lib/Image.cpp @ 4769

Revision 4769, 122.1 KB checked in by cristy, 3 years ago (diff)
Line 
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
21using 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
33MagickDLLDeclExtern const char *Magick::borderGeometryDefault = "6x6+0+0";
34MagickDLLDeclExtern const char *Magick::frameGeometryDefault  = "25x25+6+6";
35MagickDLLDeclExtern const char *Magick::raiseGeometryDefault  = "6x6+0+0";
36
37static bool magick_initialized=false;
38
39//
40// Explicit template instantiations
41//
42
43//
44// Friend functions to compare Image objects
45//
46
47MagickDLLDecl 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}
56MagickDLLDecl int Magick::operator != ( const Magick::Image& left_,
57                                        const Magick::Image& right_ )
58{
59  return ( ! (left_ == right_) );
60}
61MagickDLLDecl int Magick::operator >  ( const Magick::Image& left_,
62                                        const Magick::Image& right_ )
63{
64  return ( !( left_ < right_ ) && ( left_ != right_ ) );
65}
66MagickDLLDecl 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}
74MagickDLLDecl int Magick::operator >= ( const Magick::Image& left_,
75                                        const Magick::Image& right_ )
76{
77  return ( ( left_ > right_ ) || ( left_ == right_ ) );
78}
79MagickDLLDecl 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
90Magick::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
111Magick::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
140Magick::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
161Magick::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
183Magick::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
206Magick::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
230Magick::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
254Magick::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
278Magick::Image::Image( void )
279  : _imgRef(new ImageRef)
280{
281}
282
283// Destructor
284/* virtual */
285Magick::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
302void 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
317void 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
331void 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
344void 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
360void 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
381void 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
387void 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.
395void 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        FormatLocaleString( 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.
461void 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
482void 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
493void 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
507void 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
520void Magick::Image::channel ( const ChannelType channel_ )
521{
522  modifyImage();
523  SeparateImageChannel ( image(), channel_ );
524  throwImageException();
525}
526
527// Set or obtain modulus channel depth
528void Magick::Image::channelDepth ( const ChannelType channel_,
529                                   const size_t depth_)
530{
531  modifyImage();
532  SetImageChannelDepth( image(), channel_, depth_);
533  throwImageException();
534}
535size_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
550void 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
562void 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.
576void Magick::Image::cdl ( const std::string &cdl_ )
577{
578  modifyImage();
579  (void) ColorDecisionListImage( image(), cdl_.c_str() );
580  throwImageException();
581}
582
583// Colorize
584void 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  FormatLocaleString(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}
607void 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).
615void 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.
639bool 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
648void 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}
664void 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}
685void 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
704void 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.
714void 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
728void 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
743void Magick::Image::cycleColormap ( const ssize_t amount_ )
744{
745  modifyImage();
746  CycleColormapImage( image(), amount_ );
747  throwImageException();
748}
749
750// Despeckle
751void 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
763void 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.
772void 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
788void 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
808void 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
834void 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)
846void 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)
858void 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)
870void Magick::Image::equalize ( void )
871{
872  modifyImage();
873  EqualizeImage( image() );
874  throwImageException();
875}
876
877// Erase image to current "background color"
878void Magick::Image::erase ( void )
879{
880  modifyImage();
881  SetImageBackgroundColor( image() );
882  throwImageException();
883}
884
885// Extends image as defined by the geometry.
886//
887void 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}
899void Magick::Image::extent ( const Geometry &geometry_, const Color &backgroundColor_ )
900{
901  backgroundColor ( backgroundColor_ );
902  extent ( geometry_ );
903}
904void Magick::Image::extent ( const Geometry &geometry_, const GravityType gravity_ )
905{
906  image()->gravity  = gravity_;
907  extent ( geometry_ );
908}
909void 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)
917void 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.
931void 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}
937void 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.
946void 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}
954void 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.
964void 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.
989void 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}
1019void 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.
1028void 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}
1053void  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)
1061void 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
1073void 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}
1092void 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.
1114void 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}
1124void 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
1137void Magick::Image::gamma ( const double gamma_ )
1138{
1139  char gamma[MaxTextExtent + 1];
1140  FormatLocaleString( gamma, MaxTextExtent, "%3.6f", gamma_);
1141
1142  modifyImage();
1143  GammaImage ( image(), gamma );
1144}
1145
1146void Magick::Image::gamma ( const double gammaRed_,
1147                            const double gammaGreen_,
1148                            const double gammaBlue_ )
1149{
1150  char gamma[MaxTextExtent + 1];
1151  FormatLocaleString( 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_'.
1163void 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
1174void 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.
1188void  Magick::Image::haldClut ( const Image &clutImage_ )
1189{
1190  modifyImage();
1191  (void) HaldClutImage( image(), clutImage_.constImage() );
1192  throwImageException();
1193}
1194
1195// Implode image
1196void 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.
1209void 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}
1219void 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.
1242void Magick::Image::level ( const double black_point,
1243                            const double white_point,
1244                            const double gamma )
1245{
1246  modifyImage();
1247  char levels[MaxTextExtent];
1248  FormatLocaleString( 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.
1264void  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
1276void 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
1288void 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
1297void 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
1316void 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
1329void 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
1341void Magick::Image::modulate ( const double brightness_,
1342                               const double saturation_,
1343                               const double hue_ )
1344{
1345  char modulate[MaxTextExtent + 1];
1346  FormatLocaleString( 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).
1360void            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
1375void Magick::Image::negate ( const bool grayscale_ )
1376{
1377  modifyImage();
1378  NegateImage ( image(), grayscale_ == true ? MagickTrue : MagickFalse );
1379  throwImageException();
1380}
1381
1382// Normalize image
1383void Magick::Image::normalize ( void )
1384{
1385  modifyImage();
1386  NormalizeImage ( image() );
1387  throwImageException();
1388}
1389
1390// Oilpaint image
1391void 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.
1408void 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.
1415void 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.
1445void 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.
1461void 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.
1476void 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
1490void 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.
1505void 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
1516void 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)
1543void 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.
1563void Magick::Image::randomThreshold( const Geometry &thresholds_ )
1564{
1565  randomThresholdChannel(thresholds_,DefaultChannels);
1566}
1567void 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
1582void 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
1609void 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
1617void 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
1633void  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
1643void 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
1656void 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
1674void 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)
1689void 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
1708void 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
1721void 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
1749void 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}
1766void 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
1781void 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
1793void 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
1814void 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.
1837void 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
1852void 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
1870void 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
1884void 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.
1901void 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
1916void 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
1932void 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)
1941void 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//
1951void 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
1966void 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)
1980void 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)
1994void 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
2008void 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
2021void Magick::Image::texture ( const Image &texture_ )
2022{
2023  modifyImage();
2024  TextureImage( image(), texture_.constImage() );
2025  throwImageException();
2026}
2027
2028// Threshold image
2029void 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
2037void 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
2045void 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
2055void 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
2073void 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
2099void 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.
2122void 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
2141void 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
2163void 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
2178void 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
2187void 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}
2202void 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}
2219void 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 );
2242void 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
2260void 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
2293void Magick::Image::adjoin ( const bool flag_ )
2294{
2295  modifyImage();
2296  options()->adjoin( flag_ );
2297}
2298bool Magick::Image::adjoin ( void ) const
2299{
2300  return constOptions()->adjoin();
2301}
2302
2303// Remove pixel aliasing
2304void Magick::Image::antiAlias( const bool flag_ )
2305{
2306  modifyImage();
2307  options()->antiAlias( static_cast<size_t>(flag_) );
2308}
2309bool Magick::Image::antiAlias( void )
2310{
2311  return static_cast<bool>( options()->antiAlias( ) );
2312}
2313
2314// Animation inter-frame delay
2315void Magick::Image::animationDelay ( const size_t delay_ )
2316{
2317  modifyImage();
2318  image()->delay = delay_;
2319}
2320size_t Magick::Image::animationDelay ( void ) const
2321{
2322  return constImage()->delay;
2323}
2324
2325// Number of iterations to play animation
2326void Magick::Image::animationIterations ( const size_t iterations_ )
2327{
2328  modifyImage();
2329  image()->iterations = iterations_;
2330}
2331size_t Magick::Image::animationIterations ( void ) const
2332{
2333  return constImage()->iterations;
2334}
2335
2336// Access/Update a named image attribute
2337void 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}
2343std::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
2354void 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}
2369Magick::Color Magick::Image::backgroundColor ( void ) const
2370{
2371  return constOptions()->backgroundColor( );
2372}
2373
2374// Background fill texture
2375void Magick::Image::backgroundTexture ( const std::string &backgroundTexture_ )
2376{
2377  modifyImage();
2378  options()->backgroundTexture( backgroundTexture_ );
2379}
2380std::string Magick::Image::backgroundTexture ( void ) const
2381{
2382  return constOptions()->backgroundTexture( );
2383}
2384
2385// Original image columns
2386size_t Magick::Image::baseColumns ( void ) const
2387{
2388  return constImage()->magick_columns;
2389}
2390
2391// Original image name
2392std::string Magick::Image::baseFilename ( void ) const
2393{
2394  return std::string(constImage()->magick_filename);
2395}
2396
2397// Original image rows
2398size_t Magick::Image::baseRows ( void ) const
2399{
2400  return constImage()->magick_rows;
2401}
2402
2403// Border color
2404void 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}
2419Magick::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));
2427Magick::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
2438void Magick::Image::boxColor ( const Color &boxColor_ )
2439{
2440  modifyImage();
2441  options()->boxColor( boxColor_ );
2442}
2443Magick::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 */
2452void Magick::Image::cacheThreshold ( const size_t threshold_ )
2453{
2454  SetMagickResourceLimit( MemoryResource, threshold_ );
2455}
2456
2457void 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}
2463void 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
2469void 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}
2475void 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
2481void 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}
2487void 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
2493void 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}
2499void 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
2506void 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.
2533void 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}
2548Magick::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
2559void Magick::Image::colorFuzz ( const double fuzz_ )
2560{
2561  modifyImage();
2562  image()->fuzz = fuzz_;
2563  options()->colorFuzz( fuzz_ );
2564}
2565double Magick::Image::colorFuzz ( void ) const
2566{
2567  return constOptions()->colorFuzz( );
2568}
2569
2570// Set color in colormap at index
2571void 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
2593Magick::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)
2609void 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}
2640size_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
2652void 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_ != sRGBColorspace &&
2662       colorSpace_ != TransparentColorspace &&
2663       colorSpace_ != GRAYColorspace )
2664    {
2665      if (image()->colorspace != RGBColorspace &&
2666          image()->colorspace != sRGBColorspace &&
2667          image()->colorspace != TransparentColorspace &&
2668          image()->colorspace != GRAYColorspace)
2669        {
2670          /* Transform to RGB colorspace as intermediate step */
2671          TransformRGBImage( image(), image()->colorspace );
2672          throwImageException();
2673        }
2674      /* Transform to final non-RGB colorspace */
2675      RGBTransformImage( image(), colorSpace_ );
2676      throwImageException();
2677      return;
2678    }
2679
2680  if ( colorSpace_ == RGBColorspace ||
2681       colorSpace_ == sRGBColorspace ||
2682       colorSpace_ == TransparentColorspace ||
2683       colorSpace_ == GRAYColorspace )
2684    {
2685      /* Transform to a RGB-type colorspace */
2686      TransformRGBImage( image(), image()->colorspace );
2687      throwImageException();
2688      return;
2689    }
2690}
2691Magick::ColorspaceType Magick::Image::colorSpace ( void ) const
2692{
2693  return constImage()->colorspace;
2694}
2695
2696// Set image colorspace type.
2697void Magick::Image::colorspaceType( const ColorspaceType colorSpace_ )
2698{
2699  modifyImage();
2700  options()->colorspaceType( colorSpace_ );
2701}
2702Magick::ColorspaceType Magick::Image::colorspaceType ( void ) const
2703{
2704  return constOptions()->colorspaceType();
2705}
2706
2707
2708// Comment string
2709void Magick::Image::comment ( const std::string &comment_ )
2710{
2711  modifyImage();
2712  SetImageProperty( image(), "Comment", NULL );
2713  if ( comment_.length() > 0 )
2714    SetImageProperty( image(), "Comment", comment_.c_str() );
2715  throwImageException();
2716}
2717std::string Magick::Image::comment ( void ) const
2718{
2719  const char *value = GetImageProperty( constImage(), "Comment" );
2720
2721  if ( value )
2722    return std::string( value );
2723
2724  return std::string(); // Intentionally no exception
2725}
2726
2727// Composition operator to be used when composition is implicitly used
2728// (such as for image flattening).
2729void Magick::Image::compose (const CompositeOperator compose_)
2730{
2731  image()->compose=compose_;
2732}
2733
2734Magick::CompositeOperator Magick::Image::compose ( void ) const
2735{
2736  return constImage()->compose;
2737}
2738
2739// Compression algorithm
2740void Magick::Image::compressType ( const CompressionType compressType_ )
2741{
2742  modifyImage();
2743  image()->compression = compressType_;
2744  options()->compressType( compressType_ );
2745}
2746Magick::CompressionType Magick::Image::compressType ( void ) const
2747{
2748  return constImage()->compression;
2749}
2750
2751// Enable printing of debug messages from ImageMagick
2752void Magick::Image::debug ( const bool flag_ )
2753{
2754  modifyImage();
2755  options()->debug( flag_ );
2756}
2757bool Magick::Image::debug ( void ) const
2758{
2759  return constOptions()->debug();
2760}
2761
2762// Tagged image format define (set/access coder-specific option) The
2763// magick_ option specifies the coder the define applies to.  The key_
2764// option provides the key specific to that coder.  The value_ option
2765// provides the value to set (if any). See the defineSet() method if the
2766// key must be removed entirely.
2767void Magick::Image::defineValue ( const std::string &magick_,
2768                                  const std::string &key_,
2769                                  const std::string &value_ )
2770{
2771  modifyImage();
2772  std::string format = magick_ + ":" + key_;
2773  std::string option = value_;
2774  (void) SetImageOption ( imageInfo(), format.c_str(), option.c_str() );
2775}
2776std::string Magick::Image::defineValue ( const std::string &magick_,
2777                                         const std::string &key_ ) const
2778{
2779  std::string definition = magick_ + ":" + key_;
2780  const char *option =
2781    GetImageOption ( constImageInfo(), definition.c_str() );
2782  if (option)
2783    return std::string( option );
2784  return std::string( );
2785}
2786
2787// Tagged image format define. Similar to the defineValue() method
2788// except that passing the flag_ value 'true' creates a value-less
2789// define with that format and key. Passing the flag_ value 'false'
2790// removes any existing matching definition. The method returns 'true'
2791// if a matching key exists, and 'false' if no matching key exists.
2792void Magick::Image::defineSet ( const std::string &magick_,
2793                                const std::string &key_,
2794                                bool flag_ )
2795{
2796  modifyImage();
2797  std::string definition = magick_ + ":" + key_;
2798  if (flag_)
2799    {
2800      (void) SetImageOption ( imageInfo(), definition.c_str(),  "" );
2801    }
2802  else
2803    {
2804      DeleteImageOption( imageInfo(), definition.c_str() );
2805    }
2806}
2807bool Magick::Image::defineSet ( const std::string &magick_,
2808                                const std::string &key_ ) const
2809{
2810  std::string key = magick_ + ":" + key_;
2811  const char *option =
2812    GetImageOption ( constImageInfo(), key.c_str() );
2813  if (option)
2814    return true;
2815  return false;
2816}
2817
2818// Pixel resolution
2819void Magick::Image::density ( const Geometry &density_ )
2820{
2821  modifyImage();
2822  options()->density( density_ );
2823  if ( density_.isValid() )
2824    {
2825      image()->x_resolution = density_.width();
2826      if ( density_.height() != 0 )
2827        {
2828          image()->y_resolution = density_.height();
2829        }
2830      else
2831        {
2832          image()->y_resolution = density_.width();
2833        }
2834    }
2835  else
2836    {
2837      // Reset to default
2838      image()->x_resolution = 0;
2839      image()->y_resolution = 0;
2840    }
2841}
2842Magick::Geometry Magick::Image::density ( void ) const
2843{
2844  if (isValid())
2845    {
2846      ssize_t x_resolution=72;
2847      ssize_t y_resolution=72;
2848
2849      if (constImage()->x_resolution > 0.0)
2850        x_resolution=static_cast<ssize_t>(constImage()->x_resolution + 0.5);
2851
2852      if (constImage()->y_resolution > 0.0)
2853        y_resolution=static_cast<ssize_t>(constImage()->y_resolution + 0.5);
2854
2855      return Geometry(x_resolution,y_resolution);
2856    }
2857
2858  return constOptions()->density( );
2859}
2860
2861// Image depth (bits allocated to red/green/blue components)
2862void Magick::Image::depth ( const size_t depth_ )
2863{
2864  size_t depth = depth_;
2865
2866  if (depth > MAGICKCORE_QUANTUM_DEPTH)
2867    depth=MAGICKCORE_QUANTUM_DEPTH;
2868
2869  modifyImage();
2870  image()->depth=depth;
2871  options()->depth( depth );
2872}
2873size_t Magick::Image::depth ( void ) const
2874{
2875  return constImage()->depth;
2876}
2877
2878std::string Magick::Image::directory ( void ) const
2879{
2880  if ( constImage()->directory )
2881    return std::string( constImage()->directory );
2882
2883  throwExceptionExplicit( CorruptImageWarning,
2884                          "Image does not contain a directory");
2885
2886  return std::string();
2887}
2888
2889// Endianness (little like Intel or big like SPARC) for image
2890// formats which support endian-specific options.
2891void Magick::Image::endian ( const Magick::EndianType endian_ )
2892{
2893  modifyImage();
2894  options()->endian( endian_ );
2895  image()->endian = endian_;
2896}
2897Magick::EndianType Magick::Image::endian ( void ) const
2898{
2899  return constImage()->endian;
2900}
2901
2902// EXIF profile (BLOB)
2903void Magick::Image::exifProfile( const Magick::Blob &exifProfile_ )
2904{
2905  modifyImage();
2906  if ( exifProfile_.data() != 0 )
2907    {
2908      StringInfo * exif_profile = AcquireStringInfo( exifProfile_.length() );
2909      SetStringInfoDatum(exif_profile ,(unsigned char *) exifProfile_.data());
2910      (void) SetImageProfile( image(), "exif", exif_profile);
2911      exif_profile =DestroyStringInfo( exif_profile );
2912    }
2913}
2914Magick::Blob Magick::Image::exifProfile( void ) const
2915{
2916  const StringInfo * exif_profile = GetImageProfile( constImage(), "exif" );
2917  if ( exif_profile == (StringInfo *) NULL)
2918    return Blob( 0, 0 );
2919  return Blob(GetStringInfoDatum(exif_profile),GetStringInfoLength(exif_profile));
2920}
2921
2922// Image file name
2923void Magick::Image::fileName ( const std::string &fileName_ )
2924{
2925  modifyImage();
2926
2927  fileName_.copy( image()->filename,
2928                  sizeof(image()->filename) - 1 );
2929  image()->filename[ fileName_.length() ] = 0; // Null terminate
2930 
2931  options()->fileName( fileName_ );
2932 
2933}
2934std::string Magick::Image::fileName ( void ) const
2935{
2936  return constOptions()->fileName( );
2937}
2938
2939// Image file size
2940off_t Magick::Image::fileSize ( void ) const
2941{
2942  return (off_t) GetBlobSize( constImage() );
2943}
2944
2945// Color to use when drawing inside an object
2946void Magick::Image::fillColor ( const Magick::Color &fillColor_ )
2947{
2948  modifyImage();
2949  options()->fillColor(fillColor_);
2950}
2951Magick::Color Magick::Image::fillColor ( void ) const
2952{
2953  return constOptions()->fillColor();
2954}
2955
2956// Rule to use when filling drawn objects
2957void Magick::Image::fillRule ( const Magick::FillRule &fillRule_ )
2958{
2959  modifyImage();
2960  options()->fillRule(fillRule_);
2961}
2962Magick::FillRule Magick::Image::fillRule ( void ) const
2963{
2964  return constOptions()->fillRule();
2965}
2966
2967// Pattern to use while filling drawn objects.
2968void Magick::Image::fillPattern ( const Image &fillPattern_ )
2969{
2970  modifyImage();
2971  if(fillPattern_.isValid())
2972    options()->fillPattern( fillPattern_.constImage() );
2973  else
2974    options()->fillPattern( static_cast<MagickCore::Image*>(NULL) );
2975}
2976Magick::Image  Magick::Image::fillPattern ( void  ) const
2977{
2978  // FIXME: This is inordinately innefficient
2979  Image texture;
2980 
2981  const MagickCore::Image* tmpTexture = constOptions()->fillPattern( );
2982
2983  if ( tmpTexture )
2984    {
2985      ExceptionInfo exceptionInfo;
2986      GetExceptionInfo( &exceptionInfo );
2987      MagickCore::Image* image =
2988        CloneImage( tmpTexture,
2989                    0, // columns
2990                    0, // rows
2991                    MagickTrue, // orphan
2992                    &exceptionInfo);
2993      texture.replaceImage( image );
2994      throwException( exceptionInfo );
2995  (void) DestroyExceptionInfo( &exceptionInfo );
2996    }
2997  return texture;
2998}
2999
3000// Filter used by zoom
3001void Magick::Image::filterType ( const Magick::FilterTypes filterType_ )
3002{
3003  modifyImage();
3004  image()->filter = filterType_;
3005}
3006Magick::FilterTypes Magick::Image::filterType ( void ) const
3007{
3008  return constImage()->filter;
3009}
3010
3011// Font name
3012void Magick::Image::font ( const std::string &font_ )
3013{
3014  modifyImage();
3015  options()->font( font_ );
3016}
3017std::string Magick::Image::font ( void ) const
3018{
3019  return constOptions()->font( );
3020}
3021
3022// Font point size
3023void Magick::Image::fontPointsize ( const double pointSize_ )
3024{
3025  modifyImage();
3026  options()->fontPointsize( pointSize_ );
3027}
3028double Magick::Image::fontPointsize ( void ) const
3029{
3030  return constOptions()->fontPointsize( );
3031}
3032
3033// Font type metrics
3034void Magick::Image::fontTypeMetrics( const std::string &text_,
3035                                     TypeMetric *metrics )
3036{
3037  DrawInfo *drawInfo = options()->drawInfo();
3038  drawInfo->text = const_cast<char *>(text_.c_str());
3039  GetTypeMetrics( image(), drawInfo, &(metrics->_typeMetric) );
3040  drawInfo->text = 0;
3041}
3042
3043// Image format string
3044std::string Magick::Image::format ( void ) const
3045{
3046  ExceptionInfo exceptionInfo;
3047  GetExceptionInfo( &exceptionInfo );
3048  const MagickInfo * magick_info
3049    = GetMagickInfo( constImage()->magick, &exceptionInfo);
3050  throwException( exceptionInfo );
3051  (void) DestroyExceptionInfo( &exceptionInfo );
3052
3053  if (( magick_info != 0 ) &&
3054      ( *magick_info->description != '\0' ))
3055    return std::string(magick_info->description);
3056
3057  throwExceptionExplicit( CorruptImageWarning,
3058                          "Unrecognized image magick type" );
3059  return std::string();
3060}
3061
3062// Gamma adjustment
3063double Magick::Image::gamma ( void ) const
3064{
3065  return constImage()->gamma;
3066}
3067
3068Magick::Geometry Magick::Image::geometry ( void ) const
3069{
3070  if ( constImage()->geometry )
3071  {
3072    return Geometry(constImage()->geometry);
3073  }
3074
3075  throwExceptionExplicit( OptionWarning,
3076                          "Image does not contain a geometry");
3077
3078  return Geometry();
3079}
3080
3081void Magick::Image::gifDisposeMethod ( const size_t disposeMethod_ )
3082{
3083  modifyImage();
3084  image()->dispose = (DisposeType) disposeMethod_;
3085}
3086size_t Magick::Image::gifDisposeMethod ( void ) const
3087{
3088  // FIXME: It would be better to return an enumeration
3089  return constImage()->dispose;
3090}
3091
3092// ICC ICM color profile (BLOB)
3093void Magick::Image::iccColorProfile( const Magick::Blob &colorProfile_ )
3094{
3095  profile("icm",colorProfile_);
3096}
3097Magick::Blob Magick::Image::iccColorProfile( void ) const
3098{
3099  const StringInfo * color_profile = GetImageProfile( constImage(), "icc" );
3100  if ( color_profile == (StringInfo *) NULL)
3101    return Blob( 0, 0 );
3102  return Blob( GetStringInfoDatum(color_profile), GetStringInfoLength(color_profile) );
3103}
3104
3105void Magick::Image::interlaceType ( const Magick::InterlaceType interlace_ )
3106{
3107  modifyImage();
3108  image()->interlace = interlace_;
3109  options()->interlaceType ( interlace_ );
3110}
3111Magick::InterlaceType Magick::Image::interlaceType ( void ) const
3112{
3113  return constImage()->interlace;
3114}
3115
3116// IPTC profile (BLOB)
3117void Magick::Image::iptcProfile( const Magick::Blob &iptcProfile_ )
3118{
3119  modifyImage();
3120  if (  iptcProfile_.data() != 0 )
3121    {
3122      StringInfo * iptc_profile = AcquireStringInfo( iptcProfile_.length() );
3123      SetStringInfoDatum(iptc_profile ,(unsigned char *) iptcProfile_.data());
3124      (void) SetImageProfile( image(), "iptc", iptc_profile);
3125       iptc_profile =DestroyStringInfo( iptc_profile );
3126    }
3127}
3128Magick::Blob Magick::Image::iptcProfile( void ) const
3129{
3130  const StringInfo * iptc_profile = GetImageProfile( constImage(), "iptc" );
3131  if ( iptc_profile == (StringInfo *) NULL)
3132    return Blob( 0, 0 );
3133  return Blob( GetStringInfoDatum(iptc_profile), GetStringInfoLength(iptc_profile));
3134}
3135
3136// Does object contain valid image?
3137void Magick::Image::isValid ( const bool isValid_ )
3138{
3139  if ( !isValid_ )
3140    {
3141      delete _imgRef;
3142      _imgRef = new ImageRef;
3143    }
3144  else if ( !isValid() )
3145    {
3146      // Construct with single-pixel black image to make
3147      // image valid.  This is an obvious hack.
3148      size( Geometry(1,1) );
3149      read( "xc:#000000" );
3150    }
3151}
3152
3153bool Magick::Image::isValid ( void ) const
3154{
3155  if ( rows() && columns() )
3156    return true;
3157
3158  return false;
3159}
3160
3161// Label image
3162void Magick::Image::label ( const std::string &label_ )
3163{
3164  modifyImage();
3165  SetImageProperty ( image(), "Label", NULL );
3166  if ( label_.length() > 0 )
3167    SetImageProperty ( image(), "Label", label_.c_str() );
3168  throwImageException();
3169}
3170std::string Magick::Image::label ( void ) const
3171{
3172  const char *value = GetImageProperty( constImage(), "Label" );
3173
3174  if ( value )
3175    return std::string( value );
3176
3177  return std::string();
3178}
3179
3180void Magick::Image::magick ( const std::string &magick_ )
3181{
3182  modifyImage();
3183
3184  magick_.copy( image()->magick,
3185                sizeof(image()->magick) - 1 );
3186  image()->magick[ magick_.length() ] = 0;
3187 
3188  options()->magick( magick_ );
3189}
3190std::string Magick::Image::magick ( void ) const
3191{
3192  if ( *(constImage()->magick) != '\0' )
3193    return std::string(constImage()->magick);
3194
3195  return constOptions()->magick( );
3196}
3197
3198void Magick::Image::matte ( const bool matteFlag_ )
3199{
3200  modifyImage();
3201
3202  // If matte channel is requested, but image doesn't already have a
3203  // matte channel, then create an opaque matte channel.  Likewise, if
3204  // the image already has a matte channel but a matte channel is not
3205  // desired, then set the matte channel to opaque.
3206  if ((matteFlag_ && !constImage()->matte) ||
3207      (constImage()->matte && !matteFlag_))
3208    SetImageOpacity(image(),OpaqueOpacity);
3209
3210  image()->matte = (MagickBooleanType) matteFlag_;
3211}
3212bool Magick::Image::matte ( void ) const
3213{
3214  if ( constImage()->matte )
3215    return true;
3216  else
3217    return false;
3218}
3219
3220void Magick::Image::matteColor ( const Color &matteColor_ )
3221{
3222  modifyImage();
3223 
3224  if ( matteColor_.isValid() )
3225    {
3226      image()->matte_color = matteColor_;
3227      options()->matteColor( matteColor_ );
3228    }
3229  else
3230    {
3231      // Set to default matte color
3232      Color tmpColor( "#BDBDBD" );
3233      image()->matte_color = tmpColor;
3234      options()->matteColor( tmpColor );
3235    }
3236}
3237Magick::Color Magick::Image::matteColor ( void ) const
3238{
3239  return Color( constImage()->matte_color.red,
3240                constImage()->matte_color.green,
3241                constImage()->matte_color.blue );
3242}
3243
3244double Magick::Image::meanErrorPerPixel ( void ) const
3245{
3246  return(constImage()->error.mean_error_per_pixel);
3247}
3248
3249// Image modulus depth (minimum number of bits required to support
3250// red/green/blue components without loss of accuracy)
3251void Magick::Image::modulusDepth ( const size_t depth_ )
3252{
3253  modifyImage();
3254  SetImageDepth( image(), depth_ );
3255  options()->depth( depth_ );
3256}
3257size_t Magick::Image::modulusDepth ( void ) const
3258{
3259  ExceptionInfo exceptionInfo;
3260  GetExceptionInfo( &exceptionInfo );
3261  size_t depth=GetImageDepth( constImage(), &exceptionInfo );
3262  throwException( exceptionInfo );
3263  (void) DestroyExceptionInfo( &exceptionInfo );
3264  return depth;
3265}
3266
3267void Magick::Image::monochrome ( const bool monochromeFlag_ )
3268{
3269  modifyImage();
3270  options()->monochrome( monochromeFlag_ );
3271}
3272bool Magick::Image::monochrome ( void ) const
3273{
3274  return constOptions()->monochrome( );
3275}
3276
3277Magick::Geometry Magick::Image::montageGeometry ( void ) const
3278{
3279  if ( constImage()->montage )
3280    return Magick::Geometry(constImage()->montage);
3281
3282  throwExceptionExplicit( CorruptImageWarning,
3283                          "Image does not contain a montage" );
3284
3285  return Magick::Geometry();
3286}
3287
3288double Magick::Image::normalizedMaxError ( void ) const
3289{
3290  return(constImage()->error.normalized_maximum_error);
3291}
3292
3293double Magick::Image::normalizedMeanError ( void ) const
3294{
3295  return constImage()->error.normalized_mean_error;
3296}
3297
3298// Image orientation
3299void Magick::Image::orientation ( const Magick::OrientationType orientation_ )
3300{
3301  modifyImage();
3302  image()->orientation = orientation_;
3303}
3304Magick::OrientationType Magick::Image::orientation ( void ) const
3305{
3306  return constImage()->orientation;
3307}
3308
3309void Magick::Image::penColor ( const Color &penColor_ )
3310{
3311  modifyImage();
3312  options()->fillColor(penColor_);
3313  options()->strokeColor(penColor_);
3314}
3315Magick::Color Magick::Image::penColor ( void  ) const
3316{
3317  return constOptions()->fillColor();
3318}
3319
3320void Magick::Image::penTexture ( const Image &penTexture_ )
3321{
3322  modifyImage();
3323  if(penTexture_.isValid())
3324    options()->fillPattern( penTexture_.constImage() );
3325  else
3326    options()->fillPattern( static_cast<MagickCore::Image*>(NULL) );
3327}
3328
3329Magick::Image  Magick::Image::penTexture ( void  ) const
3330{
3331  // FIXME: This is inordinately innefficient
3332  Image texture;
3333 
3334  const MagickCore::Image* tmpTexture = constOptions()->fillPattern( );
3335
3336  if ( tmpTexture )
3337    {
3338      ExceptionInfo exceptionInfo;
3339      GetExceptionInfo( &exceptionInfo );
3340      MagickCore::Image* image =
3341        CloneImage( tmpTexture,
3342                    0, // columns
3343                    0, // rows
3344                    MagickTrue, // orphan
3345                    &exceptionInfo);
3346      texture.replaceImage( image );
3347      throwException( exceptionInfo );
3348  (void) DestroyExceptionInfo( &exceptionInfo );
3349    }
3350  return texture;
3351}
3352
3353// Set the color of a pixel.
3354void Magick::Image::pixelColor ( const ssize_t x_, const ssize_t y_,
3355                                 const Color &color_ )
3356{
3357  // Test arguments to ensure they are within the image.
3358  if ( y_ > (ssize_t) rows() || x_ > (ssize_t) columns() )
3359    throwExceptionExplicit( OptionError,
3360            "Access outside of image boundary" );
3361     
3362  modifyImage();
3363
3364  // Set image to DirectClass
3365  classType( DirectClass );
3366
3367  // Get pixel view
3368  Pixels pixels(*this);
3369    // Set pixel value
3370  *(pixels.get(x_, y_, 1, 1 )) = color_;
3371  // Tell ImageMagick that pixels have been updated
3372  pixels.sync();
3373
3374  return;
3375}
3376
3377// Get the color of a pixel
3378Magick::Color Magick::Image::pixelColor ( const ssize_t x_,
3379                                          const ssize_t y_ ) const
3380{
3381  ClassType storage_class;
3382  storage_class = classType();
3383  // DirectClass
3384  const PixelPacket* pixel = getConstPixels( x_, y_, 1, 1 );
3385  if ( storage_class == DirectClass )
3386    {
3387      if ( pixel )
3388        return Color( *pixel );
3389    }
3390
3391  // PseudoClass
3392  if ( storage_class == PseudoClass )
3393    {
3394      const IndexPacket* indexes = getConstIndexes();
3395      if ( indexes )
3396        return colorMap( (size_t) *indexes );
3397    }
3398
3399  return Color(); // invalid
3400}
3401
3402// Preferred size and location of an image canvas.
3403void Magick::Image::page ( const Magick::Geometry &pageSize_ )
3404{
3405  modifyImage();
3406  options()->page( pageSize_ );
3407  image()->page = pageSize_;
3408}
3409Magick::Geometry Magick::Image::page ( void ) const
3410{
3411  return Geometry( constImage()->page.width,
3412                   constImage()->page.height,
3413                   AbsoluteValue(constImage()->page.x),
3414                   AbsoluteValue(constImage()->page.y),
3415                   constImage()->page.x < 0 ? true : false,
3416                   constImage()->page.y < 0 ? true : false);
3417}
3418
3419// Add a named profile to an image or remove a named profile by
3420// passing an empty Blob (use default Blob constructor).
3421// Valid names are:
3422// "*", "8BIM", "ICM", "IPTC", or a generic profile name.
3423void Magick::Image::profile( const std::string name_,
3424                             const Magick::Blob &profile_ )
3425{
3426  modifyImage();
3427  ssize_t result = ProfileImage( image(), name_.c_str(),
3428                             (unsigned char *)profile_.data(),
3429                             profile_.length(), MagickTrue);
3430
3431  if( !result )
3432    throwImageException();
3433}
3434
3435// Retrieve a named profile from the image.
3436// Valid names are:
3437// "8BIM", "8BIMTEXT", "APP1", "APP1JPEG", "ICC", "ICM", & "IPTC" or
3438// an existing generic profile name.
3439Magick::Blob Magick::Image::profile( const std::string name_ ) const
3440{
3441  const MagickCore::Image* image = constImage();
3442                                                                               
3443  const StringInfo * profile = GetImageProfile( image, name_.c_str() );
3444                                                                               
3445  if ( profile != (StringInfo *) NULL)
3446      return Blob( (void*) GetStringInfoDatum(profile), GetStringInfoLength(profile));
3447                                                                               
3448  Blob blob;
3449  Image temp_image = *this;
3450  temp_image.write( &blob, name_ );
3451  return blob;
3452}
3453
3454void Magick::Image::quality ( const size_t quality_ )
3455{
3456  modifyImage();
3457  image()->quality = quality_;
3458  options()->quality( quality_ );
3459}
3460size_t Magick::Image::quality ( void ) const
3461{
3462  return constImage()->quality;
3463}
3464
3465void Magick::Image::quantizeColors ( const size_t colors_ )
3466{
3467  modifyImage();
3468  options()->quantizeColors( colors_ );
3469}
3470size_t Magick::Image::quantizeColors ( void ) const
3471{
3472  return constOptions()->quantizeColors( );
3473}
3474
3475void Magick::Image::quantizeColorSpace
3476  ( const Magick::ColorspaceType colorSpace_ )
3477{
3478  modifyImage();
3479  options()->quantizeColorSpace( colorSpace_ );
3480}
3481Magick::ColorspaceType Magick::Image::quantizeColorSpace ( void ) const
3482{
3483  return constOptions()->quantizeColorSpace( );
3484}
3485
3486void Magick::Image::quantizeDither ( const bool ditherFlag_ )
3487{
3488  modifyImage();
3489  options()->quantizeDither( ditherFlag_ );
3490}
3491bool Magick::Image::quantizeDither ( void ) const
3492{
3493  return constOptions()->quantizeDither( );
3494}
3495
3496void Magick::Image::quantizeTreeDepth ( const size_t treeDepth_ )
3497{
3498  modifyImage();
3499  options()->quantizeTreeDepth( treeDepth_ );
3500}
3501size_t Magick::Image::quantizeTreeDepth ( void ) const
3502{
3503  return constOptions()->quantizeTreeDepth( );
3504}
3505
3506void Magick::Image::renderingIntent
3507  ( const Magick::RenderingIntent renderingIntent_ )
3508{
3509  modifyImage();
3510  image()->rendering_intent = renderingIntent_;
3511}
3512Magick::RenderingIntent Magick::Image::renderingIntent ( void ) const
3513{
3514  return static_cast<Magick::RenderingIntent>(constImage()->rendering_intent);
3515}
3516
3517void Magick::Image::resolutionUnits
3518  ( const Magick::ResolutionType resolutionUnits_ )
3519{
3520  modifyImage();
3521  image()->units = resolutionUnits_;
3522  options()->resolutionUnits( resolutionUnits_ );
3523}
3524Magick::ResolutionType Magick::Image::resolutionUnits ( void ) const
3525{
3526  return constOptions()->resolutionUnits( );
3527}
3528
3529void Magick::Image::scene ( const size_t scene_ )
3530{
3531  modifyImage();
3532  image()->scene = scene_;
3533}
3534size_t Magick::Image::scene ( void ) const
3535{
3536  return constImage()->scene;
3537}
3538
3539std::string Magick::Image::signature ( const bool force_ ) const
3540{
3541  Lock( &_imgRef->_mutexLock );
3542
3543  // Re-calculate image signature if necessary
3544  if ( force_ ||
3545       !GetImageProperty(constImage(), "Signature") ||
3546       constImage()->taint )
3547    {
3548      SignatureImage( const_cast<MagickCore::Image *>(constImage()) );
3549    }
3550
3551  const char *property = GetImageProperty(constImage(), "Signature");
3552
3553  return std::string( property );
3554}
3555
3556void Magick::Image::size ( const Geometry &geometry_ )
3557{
3558  modifyImage();
3559  options()->size( geometry_ );
3560  image()->rows = geometry_.height();
3561  image()->columns = geometry_.width();
3562}
3563Magick::Geometry Magick::Image::size ( void ) const
3564{
3565  return Magick::Geometry( constImage()->columns, constImage()->rows );
3566}
3567
3568// Splice image
3569void Magick::Image::splice( const Geometry &geometry_ )
3570{
3571  RectangleInfo spliceInfo = geometry_;
3572  ExceptionInfo exceptionInfo;
3573  GetExceptionInfo( &exceptionInfo );
3574  MagickCore::Image* newImage =
3575    SpliceImage( image(), &spliceInfo, &exceptionInfo);
3576  replaceImage( newImage );
3577  throwException( exceptionInfo );
3578  (void) DestroyExceptionInfo( &exceptionInfo );
3579}
3580
3581// Obtain image statistics. Statistics are normalized to the range of
3582// 0.0 to 1.0 and are output to the specified ImageStatistics
3583// structure.
3584void Magick::Image::statistics ( ImageStatistics *statistics ) const
3585{
3586  double
3587    maximum,
3588    minimum;
3589
3590  ExceptionInfo exceptionInfo;
3591  GetExceptionInfo( &exceptionInfo );
3592  (void) GetImageChannelRange(constImage(),RedChannel,&minimum,&maximum,
3593    &exceptionInfo);
3594  statistics->red.minimum=minimum;
3595        statistics->red.maximum=maximum;
3596  (void) GetImageChannelMean(constImage(),RedChannel,
3597    &statistics->red.mean,&statistics->red.standard_deviation,&exceptionInfo);
3598  (void) GetImageChannelKurtosis(constImage(),RedChannel,
3599    &statistics->red.kurtosis,&statistics->red.skewness,&exceptionInfo);
3600  (void) GetImageChannelRange(constImage(),GreenChannel,&minimum,&maximum,
3601    &exceptionInfo);
3602  statistics->green.minimum=minimum;
3603        statistics->green.maximum=maximum;
3604  (void) GetImageChannelMean(constImage(),GreenChannel,
3605    &statistics->green.mean,&statistics->green.standard_deviation,
3606    &exceptionInfo);
3607  (void) GetImageChannelKurtosis(constImage(),GreenChannel,
3608    &statistics->green.kurtosis,&statistics->green.skewness,&exceptionInfo);
3609  (void) GetImageChannelRange(constImage(),BlueChannel,&minimum,&maximum,
3610    &exceptionInfo);
3611  statistics->blue.minimum=minimum;
3612        statistics->blue.maximum=maximum;
3613  (void) GetImageChannelMean(constImage(),BlueChannel,
3614    &statistics->blue.mean,&statistics->blue.standard_deviation,&exceptionInfo);
3615  (void) GetImageChannelKurtosis(constImage(),BlueChannel,
3616    &statistics->blue.kurtosis,&statistics->blue.skewness,&exceptionInfo);
3617  (void) GetImageChannelRange(constImage(),OpacityChannel,&minimum,&maximum,
3618    &exceptionInfo);
3619  statistics->opacity.minimum=minimum;
3620        statistics->opacity.maximum=maximum;
3621  (void) GetImageChannelMean(constImage(),OpacityChannel,
3622    &statistics->opacity.mean,&statistics->opacity.standard_deviation,
3623    &exceptionInfo);
3624  (void) GetImageChannelKurtosis(constImage(),OpacityChannel,
3625    &statistics->opacity.kurtosis,&statistics->opacity.skewness,&exceptionInfo);
3626  throwException( exceptionInfo );
3627  (void) DestroyExceptionInfo( &exceptionInfo );
3628}
3629
3630// Strip strips an image of all profiles and comments.
3631void Magick::Image::strip ( void )
3632{
3633  modifyImage();
3634  StripImage( image() );
3635  throwImageException();
3636}
3637
3638// enabled/disable stroke anti-aliasing
3639void Magick::Image::strokeAntiAlias ( const bool flag_ )
3640{
3641  modifyImage();
3642  options()->strokeAntiAlias(flag_);
3643}
3644bool Magick::Image::strokeAntiAlias ( void ) const
3645{
3646  return constOptions()->strokeAntiAlias();
3647}
3648
3649// Color to use when drawing object outlines
3650void Magick::Image::strokeColor ( const Magick::Color &strokeColor_ )
3651{
3652  modifyImage();
3653  options()->strokeColor(strokeColor_);
3654}
3655Magick::Color Magick::Image::strokeColor ( void ) const
3656{
3657  return constOptions()->strokeColor();
3658}
3659
3660// dash pattern for drawing vector objects (default one)
3661void Magick::Image::strokeDashArray ( const double* strokeDashArray_ )
3662{
3663  modifyImage();
3664  options()->strokeDashArray( strokeDashArray_ );
3665}
3666
3667const double* Magick::Image::strokeDashArray ( void ) const
3668{
3669  return constOptions()->strokeDashArray( );
3670}
3671
3672// dash offset for drawing vector objects (default one)
3673void Magick::Image::strokeDashOffset ( const double strokeDashOffset_ )
3674{
3675  modifyImage();
3676  options()->strokeDashOffset( strokeDashOffset_ );
3677}
3678
3679double Magick::Image::strokeDashOffset ( void ) const
3680{
3681  return constOptions()->strokeDashOffset( );
3682}
3683
3684// Specify the shape to be used at the end of open subpaths when they
3685// are stroked. Values of LineCap are UndefinedCap, ButtCap, RoundCap,
3686// and SquareCap.
3687void Magick::Image::strokeLineCap ( const Magick::LineCap lineCap_ )
3688{
3689  modifyImage();
3690  options()->strokeLineCap( lineCap_ );
3691}
3692Magick::LineCap Magick::Image::strokeLineCap ( void ) const
3693{
3694  return constOptions()->strokeLineCap( );
3695}
3696
3697// Specify the shape to be used at the corners of paths (or other
3698// vector shapes) when they are stroked. Values of LineJoin are
3699// UndefinedJoin, MiterJoin, RoundJoin, and BevelJoin.
3700void Magick::Image::strokeLineJoin ( const Magick::LineJoin lineJoin_ )
3701{
3702  modifyImage();
3703  options()->strokeLineJoin( lineJoin_ );
3704}
3705Magick::LineJoin Magick::Image::strokeLineJoin ( void ) const
3706{
3707  return constOptions()->strokeLineJoin( );
3708}
3709
3710// Specify miter limit. When two line segments meet at a sharp angle
3711// and miter joins have been specified for 'lineJoin', it is possible
3712// for the miter to extend far beyond the thickness of the line
3713// stroking the path. The miterLimit' imposes a limit on the ratio of
3714// the miter length to the 'lineWidth'. The default value of this
3715// parameter is 4.
3716void Magick::Image::strokeMiterLimit ( const size_t strokeMiterLimit_ )
3717{
3718  modifyImage();
3719  options()->strokeMiterLimit( strokeMiterLimit_ );
3720}
3721size_t Magick::Image::strokeMiterLimit ( void ) const
3722{
3723  return constOptions()->strokeMiterLimit( );
3724}
3725
3726// Pattern to use while stroking drawn objects.
3727void Magick::Image::strokePattern ( const Image &strokePattern_ )
3728{
3729  modifyImage();
3730  if(strokePattern_.isValid())
3731    options()->strokePattern( strokePattern_.constImage() );
3732  else
3733    options()->strokePattern( static_cast<MagickCore::Image*>(NULL) );
3734}
3735Magick::Image  Magick::Image::strokePattern ( void  ) const
3736{
3737  // FIXME: This is inordinately innefficient
3738  Image texture;
3739 
3740  const MagickCore::Image* tmpTexture = constOptions()->strokePattern( );
3741
3742  if ( tmpTexture )
3743    {
3744      ExceptionInfo exceptionInfo;
3745      GetExceptionInfo( &exceptionInfo );
3746      MagickCore::Image* image =
3747        CloneImage( tmpTexture,
3748                    0, // columns
3749                    0, // rows
3750                    MagickTrue, // orphan
3751                    &exceptionInfo);
3752      throwException( exceptionInfo );
3753  (void) DestroyExceptionInfo( &exceptionInfo );
3754      texture.replaceImage( image );
3755    }
3756  return texture;
3757}
3758
3759// Stroke width for drawing lines, circles, ellipses, etc.
3760void Magick::Image::strokeWidth ( const double strokeWidth_ )
3761{
3762  modifyImage();
3763  options()->strokeWidth( strokeWidth_ );
3764}
3765double Magick::Image::strokeWidth ( void ) const
3766{
3767  return constOptions()->strokeWidth( );
3768}
3769
3770void Magick::Image::subImage ( const size_t subImage_ )
3771{
3772  modifyImage();
3773  options()->subImage( subImage_ );
3774}
3775size_t Magick::Image::subImage ( void ) const
3776{
3777  return constOptions()->subImage( );
3778}
3779
3780void Magick::Image::subRange ( const size_t subRange_ )
3781{
3782  modifyImage();
3783  options()->subRange( subRange_ );
3784}
3785size_t Magick::Image::subRange ( void ) const
3786{
3787  return constOptions()->subRange( );
3788}
3789
3790// Annotation text encoding (e.g. "UTF-16")
3791void Magick::Image::textEncoding ( const std::string &encoding_ )
3792{
3793  modifyImage();
3794  options()->textEncoding( encoding_ );
3795}
3796std::string Magick::Image::textEncoding ( void ) const
3797{
3798  return constOptions()->textEncoding( );
3799}
3800
3801void Magick::Image::tileName ( const std::string &tileName_ )
3802{
3803  modifyImage();
3804  options()->tileName( tileName_ );
3805}
3806std::string Magick::Image::tileName ( void ) const
3807{
3808  return constOptions()->tileName( );
3809}
3810
3811size_t Magick::Image::totalColors ( void )
3812{
3813  ExceptionInfo exceptionInfo;
3814  GetExceptionInfo( &exceptionInfo );
3815  size_t colors = GetNumberColors( image(), 0, &exceptionInfo);
3816  throwException( exceptionInfo );
3817  (void) DestroyExceptionInfo( &exceptionInfo );
3818  return colors;
3819}
3820
3821// Origin of coordinate system to use when annotating with text or drawing
3822void Magick::Image::transformOrigin ( const double x_, const double y_ )
3823{
3824  modifyImage();
3825  options()->transformOrigin( x_, y_ );
3826}
3827
3828// Rotation to use when annotating with text or drawing
3829void Magick::Image::transformRotation ( const double angle_ )
3830{
3831  modifyImage();
3832  options()->transformRotation( angle_ );
3833}
3834
3835// Reset transformation parameters to default
3836void Magick::Image::transformReset ( void )
3837{
3838  modifyImage();
3839  options()->transformReset();
3840}
3841
3842// Scale to use when annotating with text or drawing
3843void Magick::Image::transformScale ( const double sx_, const double sy_ )
3844{
3845  modifyImage();
3846  options()->transformScale( sx_, sy_ );
3847}
3848
3849// Skew to use in X axis when annotating with text or drawing
3850void Magick::Image::transformSkewX ( const double skewx_ )
3851{
3852  modifyImage();
3853  options()->transformSkewX( skewx_ );
3854}
3855
3856// Skew to use in Y axis when annotating with text or drawing
3857void Magick::Image::transformSkewY ( const double skewy_ )
3858{
3859  modifyImage();
3860  options()->transformSkewY( skewy_ );
3861}
3862
3863// Image representation type
3864Magick::ImageType Magick::Image::type ( void ) const
3865{
3866
3867  ExceptionInfo exceptionInfo;
3868  GetExceptionInfo( &exceptionInfo );
3869  ImageType image_type = constOptions()->type();
3870  if ( image_type == UndefinedType )
3871    image_type= GetImageType( constImage(), &exceptionInfo);
3872  throwException( exceptionInfo );
3873  (void) DestroyExceptionInfo( &exceptionInfo );
3874  return image_type;
3875}
3876void Magick::Image::type ( const Magick::ImageType type_)
3877{
3878  modifyImage();
3879  options()->type( type_ );
3880  SetImageType( image(), type_ );
3881}
3882
3883void Magick::Image::verbose ( const bool verboseFlag_ )
3884{
3885  modifyImage();
3886  options()->verbose( verboseFlag_ );
3887}
3888bool Magick::Image::verbose ( void ) const
3889{
3890  return constOptions()->verbose( );
3891}
3892
3893void Magick::Image::view ( const std::string &view_ )
3894{
3895  modifyImage();
3896  options()->view( view_ );
3897}
3898std::string Magick::Image::view ( void ) const
3899{
3900  return constOptions()->view( );
3901}
3902
3903// Virtual pixel method
3904void Magick::Image::virtualPixelMethod ( const VirtualPixelMethod virtual_pixel_method_ )
3905{
3906  modifyImage();
3907  SetImageVirtualPixelMethod( image(), virtual_pixel_method_ );
3908  options()->virtualPixelMethod( virtual_pixel_method_ );
3909}
3910Magick::VirtualPixelMethod Magick::Image::virtualPixelMethod ( void ) const
3911{
3912  return GetImageVirtualPixelMethod( constImage() );
3913}
3914
3915void Magick::Image::x11Display ( const std::string &display_ )
3916{
3917  modifyImage();
3918  options()->x11Display( display_ );
3919}
3920std::string Magick::Image::x11Display ( void ) const
3921{
3922  return constOptions()->x11Display( );
3923}
3924
3925double Magick::Image::xResolution ( void ) const
3926{
3927  return constImage()->x_resolution;
3928}
3929double Magick::Image::yResolution ( void ) const
3930{
3931  return constImage()->y_resolution;
3932}
3933
3934// Copy Constructor
3935Magick::Image::Image( const Image & image_ )
3936  : _imgRef(image_._imgRef)
3937{
3938  Lock( &_imgRef->_mutexLock );
3939
3940  // Increase reference count
3941  ++_imgRef->_refCount;
3942}
3943
3944// Assignment operator
3945Magick::Image& Magick::Image::operator=( const Magick::Image &image_ )
3946{
3947  if( this != &image_ )
3948    {
3949      {
3950        Lock( &image_._imgRef->_mutexLock );
3951        ++image_._imgRef->_refCount;
3952      }
3953
3954      bool doDelete = false;
3955      {
3956        Lock( &_imgRef->_mutexLock );
3957        if ( --_imgRef->_refCount == 0 )
3958          doDelete = true;
3959      }
3960
3961      if ( doDelete )
3962        {
3963          // Delete old image reference with associated image and options.
3964          delete _imgRef;
3965          _imgRef = 0;
3966        }
3967      // Use new image reference
3968      _imgRef = image_._imgRef;
3969    }
3970
3971  return *this;
3972}
3973
3974//////////////////////////////////////////////////////////////////////   
3975//
3976// Low-level Pixel Access Routines
3977//
3978// Also see the Pixels class, which provides support for multiple
3979// cache views. The low-level pixel access routines in the Image
3980// class are provided in order to support backward compatability.
3981//
3982//////////////////////////////////////////////////////////////////////
3983
3984// Transfers read-only pixels from the image to the pixel cache as
3985// defined by the specified region
3986const Magick::PixelPacket* Magick::Image::getConstPixels
3987  ( const ssize_t x_, const ssize_t y_,
3988    const size_t columns_,
3989    const size_t rows_ ) const
3990{
3991  ExceptionInfo exceptionInfo;
3992  GetExceptionInfo( &exceptionInfo );
3993  const PixelPacket* p = (*GetVirtualPixels)( constImage(),
3994                                                x_, y_,
3995                                                columns_, rows_,
3996                                                &exceptionInfo );
3997  throwException( exceptionInfo );
3998  (void) DestroyExceptionInfo( &exceptionInfo );
3999  return p;
4000}
4001
4002// Obtain read-only pixel indexes (valid for PseudoClass images)
4003const Magick::IndexPacket* Magick::Image::getConstIndexes ( void ) const
4004{
4005  const Magick::IndexPacket* result = GetVirtualIndexQueue( constImage() );
4006
4007  if( !result )
4008    throwImageException();
4009
4010  return result;
4011}
4012
4013// Obtain image pixel indexes (valid for PseudoClass images)
4014Magick::IndexPacket* Magick::Image::getIndexes ( void )
4015{
4016  Magick::IndexPacket* result = GetAuthenticIndexQueue( image() );
4017
4018  if( !result )
4019    throwImageException();
4020
4021  return ( result );
4022}
4023
4024// Transfers pixels from the image to the pixel cache as defined
4025// by the specified region. Modified pixels may be subsequently
4026// transferred back to the image via syncPixels.
4027Magick::PixelPacket* Magick::Image::getPixels ( const ssize_t x_, const ssize_t y_,
4028                                                const size_t columns_,
4029                                                const size_t rows_ )
4030{
4031  modifyImage();
4032  ExceptionInfo exceptionInfo;
4033  GetExceptionInfo( &exceptionInfo );
4034  PixelPacket* result = (*GetAuthenticPixels)( image(),
4035                                           x_, y_,
4036                                           columns_, rows_, &exceptionInfo );
4037  throwException( exceptionInfo );
4038  (void) DestroyExceptionInfo( &exceptionInfo );
4039
4040  return result;
4041}
4042
4043// Allocates a pixel cache region to store image pixels as defined
4044// by the region rectangle.  This area is subsequently transferred
4045// from the pixel cache to the image via syncPixels.
4046Magick::PixelPacket* Magick::Image::setPixels ( const ssize_t x_, const ssize_t y_,
4047                                                const size_t columns_,
4048                                                const size_t rows_ )
4049{
4050  modifyImage();
4051  ExceptionInfo exceptionInfo;
4052  GetExceptionInfo( &exceptionInfo );
4053  PixelPacket* result = (*QueueAuthenticPixels)( image(),
4054                                           x_, y_,
4055                                           columns_, rows_, &exceptionInfo );
4056  throwException( exceptionInfo );
4057  (void) DestroyExceptionInfo( &exceptionInfo );
4058
4059  return result;
4060}
4061
4062// Transfers the image cache pixels to the image.
4063void Magick::Image::syncPixels ( void )
4064{
4065  ExceptionInfo exceptionInfo;
4066  GetExceptionInfo( &exceptionInfo );
4067  (*SyncAuthenticPixels)( image(), &exceptionInfo );
4068  throwException( exceptionInfo );
4069  (void) DestroyExceptionInfo( &exceptionInfo );
4070}
4071
4072// Transfers one or more pixel components from a buffer or file
4073// into the image pixel cache of an image.
4074// Used to support image decoders.
4075void Magick::Image::readPixels ( const Magick::QuantumType quantum_,
4076                                 const unsigned char *source_ )
4077{
4078  QuantumInfo
4079    *quantum_info;
4080
4081  quantum_info=AcquireQuantumInfo(imageInfo(),image());
4082  ExceptionInfo exceptionInfo;
4083  GetExceptionInfo( &exceptionInfo );
4084  ImportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
4085    quantum_,source_, &exceptionInfo);
4086  throwException( exceptionInfo );
4087  (void) DestroyExceptionInfo( &exceptionInfo );
4088  quantum_info=DestroyQuantumInfo(quantum_info);
4089}
4090
4091// Transfers one or more pixel components from the image pixel
4092// cache to a buffer or file.
4093// Used to support image encoders.
4094void Magick::Image::writePixels ( const Magick::QuantumType quantum_,
4095                                  unsigned char *destination_ )
4096{
4097  QuantumInfo
4098    *quantum_info;
4099
4100  quantum_info=AcquireQuantumInfo(imageInfo(),image());
4101  ExceptionInfo exceptionInfo;
4102  GetExceptionInfo( &exceptionInfo );
4103  ExportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
4104    quantum_,destination_, &exceptionInfo);
4105  quantum_info=DestroyQuantumInfo(quantum_info);
4106  throwException( exceptionInfo );
4107  (void) DestroyExceptionInfo( &exceptionInfo );
4108}
4109
4110/////////////////////////////////////////////////////////////////////
4111//
4112// No end-user methods beyond this point
4113//
4114/////////////////////////////////////////////////////////////////////
4115
4116
4117//
4118// Construct using existing image and default options
4119//
4120Magick::Image::Image ( MagickCore::Image* image_ )
4121  : _imgRef(new ImageRef( image_))
4122{
4123}
4124
4125// Get Magick::Options*
4126Magick::Options* Magick::Image::options( void )
4127{
4128  return _imgRef->options();
4129}
4130const Magick::Options* Magick::Image::constOptions( void ) const
4131{
4132  return _imgRef->options();
4133}
4134
4135// Get MagickCore::Image*
4136MagickCore::Image*& Magick::Image::image( void )
4137{
4138  return _imgRef->image();
4139}
4140const MagickCore::Image* Magick::Image::constImage( void ) const
4141{
4142  return _imgRef->image();
4143}
4144
4145// Get ImageInfo *
4146MagickCore::ImageInfo* Magick::Image::imageInfo( void )
4147{
4148  return _imgRef->options()->imageInfo();
4149}
4150const MagickCore::ImageInfo * Magick::Image::constImageInfo( void ) const
4151{
4152  return _imgRef->options()->imageInfo();
4153}
4154
4155// Get QuantizeInfo *
4156MagickCore::QuantizeInfo* Magick::Image::quantizeInfo( void )
4157{
4158  return _imgRef->options()->quantizeInfo();
4159}
4160const MagickCore::QuantizeInfo * Magick::Image::constQuantizeInfo( void ) const
4161{
4162  return _imgRef->options()->quantizeInfo();
4163}
4164
4165//
4166// Replace current image
4167//
4168MagickCore::Image * Magick::Image::replaceImage
4169  ( MagickCore::Image* replacement_ )
4170{
4171  MagickCore::Image* image;
4172 
4173  if( replacement_ )
4174    image = replacement_;
4175  else
4176    image = AcquireImage(constImageInfo());
4177
4178  {
4179    Lock( &_imgRef->_mutexLock );
4180
4181    if ( _imgRef->_refCount == 1 )
4182      {
4183        // We own the image, just replace it, and de-register
4184        _imgRef->id( -1 );
4185        _imgRef->image(image);
4186      }
4187    else
4188      {
4189        // We don't own the image, dereference and replace with copy
4190        --_imgRef->_refCount;
4191        _imgRef = new ImageRef( image, constOptions() );
4192      }
4193  }
4194
4195  return _imgRef->_image;
4196}
4197
4198//
4199// Prepare to modify image or image options
4200// Replace current image and options with copy if reference count > 1
4201//
4202void Magick::Image::modifyImage( void )
4203{
4204  {
4205    Lock( &_imgRef->_mutexLock );
4206    if ( _imgRef->_refCount == 1 )
4207      {
4208        // De-register image and return
4209        _imgRef->id( -1 );
4210        return;
4211      }
4212  }
4213
4214  ExceptionInfo exceptionInfo;
4215  GetExceptionInfo( &exceptionInfo );
4216  replaceImage( CloneImage( image(),
4217                            0, // columns
4218                            0, // rows
4219                            MagickTrue, // orphan
4220                            &exceptionInfo) );
4221  throwException( exceptionInfo );
4222  (void) DestroyExceptionInfo( &exceptionInfo );
4223  return;
4224}
4225
4226//
4227// Test for an ImageMagick reported error and throw exception if one
4228// has been reported.  Secretly resets image->exception back to default
4229// state even though this method is const.
4230//
4231void Magick::Image::throwImageException( void ) const
4232{
4233  // Throw C++ exception while resetting Image exception to default state
4234  throwException( const_cast<MagickCore::Image*>(constImage())->exception );
4235}
4236
4237// Register image with image registry or obtain registration id
4238ssize_t Magick::Image::registerId( void )
4239{
4240  Lock( &_imgRef->_mutexLock );
4241  if( _imgRef->id() < 0 )
4242    {
4243      char id[MaxTextExtent];
4244      ExceptionInfo exceptionInfo;
4245      GetExceptionInfo( &exceptionInfo );
4246      _imgRef->id(_imgRef->id()+1);
4247      sprintf(id,"%.20g\n",(double) _imgRef->id());
4248      SetImageRegistry(ImageRegistryType, id, image(), &exceptionInfo);
4249      throwException( exceptionInfo );
4250  (void) DestroyExceptionInfo( &exceptionInfo );
4251    }
4252  return _imgRef->id();
4253}
4254
4255// Unregister image from image registry
4256void Magick::Image::unregisterId( void )
4257{
4258  modifyImage();
4259  _imgRef->id( -1 );
4260}
4261
4262//
4263// Create a local wrapper around MagickCoreTerminus
4264//
4265namespace Magick
4266{
4267  extern "C" {
4268    void MagickPlusPlusDestroyMagick(void);
4269  }
4270}
4271
4272void Magick::MagickPlusPlusDestroyMagick(void)
4273{
4274  if (magick_initialized)
4275    {
4276      magick_initialized=false;
4277      MagickCore::MagickCoreTerminus();
4278    }
4279}
4280
4281// C library initialization routine
4282void MagickDLLDecl Magick::InitializeMagick(const char *path_)
4283{
4284  MagickCore::MagickCoreGenesis(path_,MagickFalse);
4285  if (!magick_initialized)
4286    magick_initialized=true;
4287}
4288
4289//
4290// Cleanup class to ensure that ImageMagick singletons are destroyed
4291// so as to avoid any resemblence to a memory leak (which seems to
4292// confuse users)
4293//
4294namespace Magick
4295{
4296
4297  class MagickCleanUp
4298  {
4299  public:
4300    MagickCleanUp( void );
4301    ~MagickCleanUp( void );
4302  };
4303
4304  // The destructor for this object is invoked when the destructors for
4305  // static objects in this translation unit are invoked.
4306  static MagickCleanUp magickCleanUpGuard;
4307}
4308
4309Magick::MagickCleanUp::MagickCleanUp ( void )
4310{
4311  // Don't even think about invoking InitializeMagick here!
4312}
4313
4314Magick::MagickCleanUp::~MagickCleanUp ( void )
4315{
4316  MagickPlusPlusDestroyMagick();
4317}
Note: See TracBrowser for help on using the repository browser.