1 // This may look like C code, but it is really -*- C++ -*-
3 // Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
5 // Implementation of Image
8 #define MAGICKCORE_IMPLEMENTATION 1
9 #define MAGICK_PLUSPLUS_IMPLEMENTATION 1
16 #include "Magick++/Include.h"
20 #include "Magick++/Image.h"
21 #include "Magick++/Functions.h"
22 #include "Magick++/Pixels.h"
23 #include "Magick++/Options.h"
24 #include "Magick++/ImageRef.h"
26 #define AbsoluteValue(x) ((x) < 0 ? -(x) : (x))
27 #define DegreesToRadians(x) (MagickPI*(x)/180.0)
29 MagickPPExport const char *Magick::borderGeometryDefault = "6x6+0+0";
30 MagickPPExport const char *Magick::frameGeometryDefault = "25x25+6+6";
31 MagickPPExport const char *Magick::raiseGeometryDefault = "6x6+0+0";
33 static bool magick_initialized=false;
36 // Explicit template instantiations
40 // Friend functions to compare Image objects
43 MagickPPExport int Magick::operator == ( const Magick::Image& left_,
44 const Magick::Image& right_ )
46 // If image pixels and signature are the same, then the image is identical
47 return ( ( left_.rows() == right_.rows() ) &&
48 ( left_.columns() == right_.columns() ) &&
49 ( left_.signature() == right_.signature() )
52 MagickPPExport int Magick::operator != ( const Magick::Image& left_,
53 const Magick::Image& right_ )
55 return ( ! (left_ == right_) );
57 MagickPPExport int Magick::operator > ( const Magick::Image& left_,
58 const Magick::Image& right_ )
60 return ( !( left_ < right_ ) && ( left_ != right_ ) );
62 MagickPPExport int Magick::operator < ( const Magick::Image& left_,
63 const Magick::Image& right_ )
65 // If image pixels are less, then image is smaller
66 return ( ( left_.rows() * left_.columns() ) <
67 ( right_.rows() * right_.columns() )
70 MagickPPExport int Magick::operator >= ( const Magick::Image& left_,
71 const Magick::Image& right_ )
73 return ( ( left_ > right_ ) || ( left_ == right_ ) );
75 MagickPPExport int Magick::operator <= ( const Magick::Image& left_,
76 const Magick::Image& right_ )
78 return ( ( left_ < right_ ) || ( left_ == right_ ) );
82 // Image object implementation
85 // Construct from image file or image specification
86 Magick::Image::Image( const std::string &imageSpec_ )
87 : _imgRef(new ImageRef)
91 // Initialize, Allocate and Read images
94 catch ( const Warning & /*warning_*/ )
96 // FIXME: need a way to report warnings in constructor
98 catch ( const Error & /*error_*/ )
106 // Construct a blank image canvas of specified size and color
107 Magick::Image::Image( const Geometry &size_,
108 const Color &color_ )
109 : _imgRef(new ImageRef)
111 // xc: prefix specifies an X11 color string
112 std::string imageSpec("xc:");
120 // Initialize, Allocate and Read images
123 catch ( const Warning & /*warning_*/ )
125 // FIXME: need a way to report warnings in constructor
127 catch ( const Error & /*error_*/ )
135 // Construct Image from in-memory BLOB
136 Magick::Image::Image ( const Blob &blob_ )
137 : _imgRef(new ImageRef)
141 // Initialize, Allocate and Read images
144 catch ( const Warning & /*warning_*/ )
146 // FIXME: need a way to report warnings in constructor
148 catch ( const Error & /*error_*/ )
156 // Construct Image of specified size from in-memory BLOB
157 Magick::Image::Image ( const Blob &blob_,
158 const Geometry &size_ )
159 : _imgRef(new ImageRef)
164 read( blob_, size_ );
166 catch ( const Warning & /*warning_*/ )
168 // FIXME: need a way to report warnings in constructor
170 catch ( const Error & /*error_*/ )
178 // Construct Image of specified size and depth from in-memory BLOB
179 Magick::Image::Image ( const Blob &blob_,
180 const Geometry &size_,
181 const size_t depth_ )
182 : _imgRef(new ImageRef)
187 read( blob_, size_, depth_ );
189 catch ( const Warning & /*warning_*/ )
191 // FIXME: need a way to report warnings in constructor
193 catch ( const Error & /*error_*/ )
201 // Construct Image of specified size, depth, and format from in-memory BLOB
202 Magick::Image::Image ( const Blob &blob_,
203 const Geometry &size_,
205 const std::string &magick_ )
206 : _imgRef(new ImageRef)
211 read( blob_, size_, depth_, magick_ );
213 catch ( const Warning & /*warning_*/ )
215 // FIXME: need a way to report warnings in constructor
217 catch ( const Error & /*error_*/ )
225 // Construct Image of specified size, and format from in-memory BLOB
226 Magick::Image::Image ( const Blob &blob_,
227 const Geometry &size_,
228 const std::string &magick_ )
229 : _imgRef(new ImageRef)
234 read( blob_, size_, magick_ );
236 catch ( const Warning & /*warning_*/ )
238 // FIXME: need a way to report warnings in constructor
240 catch ( const Error & /*error_*/ )
248 // Construct an image based on an array of raw pixels, of specified
249 // type and mapping, in memory
250 Magick::Image::Image ( const size_t width_,
251 const size_t height_,
252 const std::string &map_,
253 const StorageType type_,
254 const void *pixels_ )
255 : _imgRef(new ImageRef)
259 read( width_, height_, map_.c_str(), type_, pixels_ );
261 catch ( const Warning & /*warning_*/ )
263 // FIXME: need a way to report warnings in constructor
265 catch ( const Error & /*error_*/ )
273 // Default constructor
274 Magick::Image::Image( void )
275 : _imgRef(new ImageRef)
281 Magick::Image::~Image()
283 bool doDelete = false;
285 Lock( &_imgRef->_mutexLock );
286 if ( --_imgRef->_refCount == 0 )
297 // Adaptive-blur image
298 void Magick::Image::adaptiveBlur( const double radius_, const double sigma_ )
300 ExceptionInfo exceptionInfo;
301 GetExceptionInfo( &exceptionInfo );
302 MagickCore::Image* newImage =
303 AdaptiveBlurImage( image(), radius_, sigma_, image()->bias, &exceptionInfo);
304 replaceImage( newImage );
305 throwException( exceptionInfo );
306 (void) DestroyExceptionInfo( &exceptionInfo );
309 // Local adaptive threshold image
310 // http://www.dai.ed.ac.uk/HIPR2/adpthrsh.htm
311 // Width x height define the size of the pixel neighborhood
312 // offset = constant to subtract from pixel neighborhood mean
313 void Magick::Image::adaptiveThreshold ( const size_t width_,
314 const size_t height_,
315 const ssize_t offset_ )
317 ExceptionInfo exceptionInfo;
318 GetExceptionInfo( &exceptionInfo );
319 MagickCore::Image* newImage =
320 AdaptiveThresholdImage( constImage(), width_, height_, offset_, &exceptionInfo );
321 replaceImage( newImage );
322 throwException( exceptionInfo );
323 (void) DestroyExceptionInfo( &exceptionInfo );
326 // Add noise to image
327 void Magick::Image::addNoise( const NoiseType noiseType_ )
329 ExceptionInfo exceptionInfo;
330 GetExceptionInfo( &exceptionInfo );
331 MagickCore::Image* newImage =
332 AddNoiseImage ( image(),
335 replaceImage( newImage );
336 throwException( exceptionInfo );
337 (void) DestroyExceptionInfo( &exceptionInfo );
340 void Magick::Image::addNoiseChannel( const ChannelType channel_,
341 const NoiseType noiseType_ )
343 ExceptionInfo exceptionInfo;
344 GetExceptionInfo( &exceptionInfo );
345 ChannelType channel_mask = SetPixelChannelMask( image(), channel_);
346 MagickCore::Image* newImage =
347 AddNoiseImage ( image(),
350 (void) SetPixelChannelMap( image(), channel_mask );
351 replaceImage( newImage );
352 throwException( exceptionInfo );
353 (void) DestroyExceptionInfo( &exceptionInfo );
356 // Affine Transform image
357 void Magick::Image::affineTransform ( const DrawableAffine &affine_ )
359 ExceptionInfo exceptionInfo;
360 GetExceptionInfo( &exceptionInfo );
362 AffineMatrix _affine;
363 _affine.sx = affine_.sx();
364 _affine.sy = affine_.sy();
365 _affine.rx = affine_.rx();
366 _affine.ry = affine_.ry();
367 _affine.tx = affine_.tx();
368 _affine.ty = affine_.ty();
370 MagickCore::Image* newImage =
371 AffineTransformImage( image(), &_affine, &exceptionInfo);
372 replaceImage( newImage );
373 throwException( exceptionInfo );
374 (void) DestroyExceptionInfo( &exceptionInfo );
377 // Annotate using specified text, and placement location
378 void Magick::Image::annotate ( const std::string &text_,
379 const Geometry &location_ )
381 annotate ( text_, location_, NorthWestGravity, 0.0 );
383 // Annotate using specified text, bounding area, and placement gravity
384 void Magick::Image::annotate ( const std::string &text_,
385 const Geometry &boundingArea_,
386 const GravityType gravity_ )
388 annotate ( text_, boundingArea_, gravity_, 0.0 );
390 // Annotate with text using specified text, bounding area, placement
391 // gravity, and rotation.
392 void Magick::Image::annotate ( const std::string &text_,
393 const Geometry &boundingArea_,
394 const GravityType gravity_,
395 const double degrees_ )
400 = options()->drawInfo();
402 drawInfo->text = const_cast<char *>(text_.c_str());
404 char boundingArea[MaxTextExtent];
406 drawInfo->geometry = 0;
407 if ( boundingArea_.isValid() ){
408 if ( boundingArea_.width() == 0 || boundingArea_.height() == 0 )
410 FormatLocaleString( boundingArea, MaxTextExtent, "%+.20g%+.20g",
411 (double) boundingArea_.xOff(), (double) boundingArea_.yOff() );
415 (void) CopyMagickString( boundingArea, string(boundingArea_).c_str(),
418 drawInfo->geometry = boundingArea;
421 drawInfo->gravity = gravity_;
423 AffineMatrix oaffine = drawInfo->affine;
424 if ( degrees_ != 0.0)
434 AffineMatrix current = drawInfo->affine;
435 affine.sx=cos(DegreesToRadians(fmod(degrees_,360.0)));
436 affine.rx=sin(DegreesToRadians(fmod(degrees_,360.0)));
437 affine.ry=(-sin(DegreesToRadians(fmod(degrees_,360.0))));
438 affine.sy=cos(DegreesToRadians(fmod(degrees_,360.0)));
440 drawInfo->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
441 drawInfo->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
442 drawInfo->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
443 drawInfo->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
444 drawInfo->affine.tx=current.sx*affine.tx+current.ry*affine.ty
448 ExceptionInfo exceptionInfo;
449 GetExceptionInfo( &exceptionInfo );
450 AnnotateImage( image(), drawInfo, &exceptionInfo );
452 // Restore original values
453 drawInfo->affine = oaffine;
455 drawInfo->geometry = 0;
457 throwException( exceptionInfo );
458 (void) DestroyExceptionInfo( &exceptionInfo );
460 // Annotate with text (bounding area is entire image) and placement gravity.
461 void Magick::Image::annotate ( const std::string &text_,
462 const GravityType gravity_ )
467 = options()->drawInfo();
469 drawInfo->text = const_cast<char *>(text_.c_str());
471 drawInfo->gravity = gravity_;
473 ExceptionInfo exceptionInfo;
474 GetExceptionInfo( &exceptionInfo );
475 AnnotateImage( image(), drawInfo, &exceptionInfo );
477 drawInfo->gravity = NorthWestGravity;
480 throwException( exceptionInfo );
481 (void) DestroyExceptionInfo( &exceptionInfo );
485 void Magick::Image::blur( const double radius_, const double sigma_ )
487 ExceptionInfo exceptionInfo;
488 GetExceptionInfo( &exceptionInfo );
489 MagickCore::Image* newImage =
490 BlurImage( image(), radius_, sigma_, image()->bias, &exceptionInfo);
491 replaceImage( newImage );
492 throwException( exceptionInfo );
493 (void) DestroyExceptionInfo( &exceptionInfo );
496 void Magick::Image::blurChannel( const ChannelType channel_,
497 const double radius_, const double sigma_ )
499 ExceptionInfo exceptionInfo;
500 GetExceptionInfo( &exceptionInfo );
501 ChannelType channel_mask = SetPixelChannelMask( image(), channel_ );
502 MagickCore::Image* newImage =
503 BlurImage( image(), radius_, sigma_, image()->bias, &exceptionInfo);
504 (void) SetPixelChannelMap( image(), channel_mask );
505 replaceImage( newImage );
506 throwException( exceptionInfo );
507 (void) DestroyExceptionInfo( &exceptionInfo );
510 // Add border to image
511 // Only uses width & height
512 void Magick::Image::border( const Geometry &geometry_ )
514 RectangleInfo borderInfo = geometry_;
515 ExceptionInfo exceptionInfo;
516 GetExceptionInfo( &exceptionInfo );
517 MagickCore::Image* newImage =
518 BorderImage( image(), &borderInfo, image()->compose, &exceptionInfo);
519 replaceImage( newImage );
520 throwException( exceptionInfo );
521 (void) DestroyExceptionInfo( &exceptionInfo );
524 // Extract channel from image
525 void Magick::Image::channel ( const ChannelType channel_ )
528 ChannelType channel_mask = SetPixelChannelMask( image(), channel_ );
529 SeparateImage ( image() );
530 (void) SetPixelChannelMap( image(), channel_mask );
531 throwImageException();
534 // Set or obtain modulus channel depth
535 void Magick::Image::channelDepth ( const size_t depth_ )
538 SetImageDepth( image(), depth_);
539 throwImageException();
541 size_t Magick::Image::channelDepth ( )
543 size_t channel_depth;
545 ExceptionInfo exceptionInfo;
546 GetExceptionInfo( &exceptionInfo );
547 channel_depth=GetImageDepth( constImage(), &exceptionInfo );
548 throwException( exceptionInfo );
549 (void) DestroyExceptionInfo( &exceptionInfo );
550 return channel_depth;
554 // Charcoal-effect image
555 void Magick::Image::charcoal( const double radius_, const double sigma_ )
557 ExceptionInfo exceptionInfo;
558 GetExceptionInfo( &exceptionInfo );
559 MagickCore::Image* newImage =
560 CharcoalImage( image(), radius_, sigma_, image()->bias, &exceptionInfo );
561 replaceImage( newImage );
562 throwException( exceptionInfo );
563 (void) DestroyExceptionInfo( &exceptionInfo );
567 void Magick::Image::chop( const Geometry &geometry_ )
569 RectangleInfo chopInfo = geometry_;
570 ExceptionInfo exceptionInfo;
571 GetExceptionInfo( &exceptionInfo );
572 MagickCore::Image* newImage =
573 ChopImage( image(), &chopInfo, &exceptionInfo);
574 replaceImage( newImage );
575 throwException( exceptionInfo );
576 (void) DestroyExceptionInfo( &exceptionInfo );
579 // contains one or more color corrections and applies the correction to the
581 void Magick::Image::cdl ( const std::string &cdl_ )
584 ExceptionInfo exceptionInfo;
585 GetExceptionInfo( &exceptionInfo );
586 (void) ColorDecisionListImage( image(), cdl_.c_str(), &exceptionInfo );
587 throwException( exceptionInfo );
588 (void) DestroyExceptionInfo( &exceptionInfo );
592 void Magick::Image::colorize ( const unsigned int alphaRed_,
593 const unsigned int alphaGreen_,
594 const unsigned int alphaBlue_,
595 const Color &penColor_ )
597 if ( !penColor_.isValid() )
599 throwExceptionExplicit( OptionError,
600 "Pen color argument is invalid");
603 char alpha[MaxTextExtent];
604 FormatLocaleString(alpha,MaxTextExtent,"%u/%u/%u",alphaRed_,alphaGreen_,alphaBlue_);
606 ExceptionInfo exceptionInfo;
607 GetExceptionInfo( &exceptionInfo );
608 MagickCore::Image* newImage =
609 ColorizeImage ( image(), alpha,
610 penColor_, &exceptionInfo );
611 replaceImage( newImage );
612 throwException( exceptionInfo );
613 (void) DestroyExceptionInfo( &exceptionInfo );
615 void Magick::Image::colorize ( const unsigned int alpha_,
616 const Color &penColor_ )
618 colorize( alpha_, alpha_, alpha_, penColor_ );
621 // Apply a color matrix to the image channels. The user supplied
622 // matrix may be of order 1 to 6 (1x1 through 6x6).
623 void Magick::Image::colorMatrix (const size_t order_,
624 const double *color_matrix_)
629 ExceptionInfo exceptionInfo;
630 GetExceptionInfo( &exceptionInfo );
631 kernel_info=AcquireKernelInfo((const char *) NULL);
632 kernel_info->width=order_;
633 kernel_info->height=order_;
634 kernel_info->values=(double *) color_matrix_;
635 MagickCore::Image* newImage =
636 ColorMatrixImage( image(), kernel_info, &exceptionInfo );
637 kernel_info->values=(double *) NULL;
638 kernel_info=DestroyKernelInfo(kernel_info);
639 replaceImage( newImage );
640 throwException( exceptionInfo );
641 (void) DestroyExceptionInfo( &exceptionInfo );
644 // Compare current image with another image
645 // Sets meanErrorPerPixel, normalizedMaxError, and normalizedMeanError
646 // in the current image. False is returned if the images are identical.
647 bool Magick::Image::compare ( const Image &reference_ )
649 ExceptionInfo exceptionInfo;
650 GetExceptionInfo( &exceptionInfo );
652 Image ref = reference_;
655 static_cast<bool>(IsImagesEqual(image(), ref.image(), &exceptionInfo));
656 throwException( exceptionInfo );
657 (void) DestroyExceptionInfo( &exceptionInfo );
661 // Composite two images
662 void Magick::Image::composite ( const Image &compositeImage_,
663 const ssize_t xOffset_,
664 const ssize_t yOffset_,
665 const CompositeOperator compose_ )
667 // Image supplied as compositeImage is composited with current image and
668 // results in updating current image.
671 CompositeImage( image(),
673 compositeImage_.constImage(),
676 throwImageException();
678 void Magick::Image::composite ( const Image &compositeImage_,
679 const Geometry &offset_,
680 const CompositeOperator compose_ )
684 ssize_t x = offset_.xOff();
685 ssize_t y = offset_.yOff();
686 size_t width = columns();
687 size_t height = rows();
689 ParseMetaGeometry (static_cast<std::string>(offset_).c_str(),
693 CompositeImage( image(),
695 compositeImage_.constImage(),
697 throwImageException();
699 void Magick::Image::composite ( const Image &compositeImage_,
700 const GravityType gravity_,
701 const CompositeOperator compose_ )
705 RectangleInfo geometry;
707 SetGeometry(compositeImage_.constImage(), &geometry);
708 GravityAdjustGeometry(columns(), rows(), gravity_, &geometry);
710 CompositeImage( image(),
712 compositeImage_.constImage(),
713 geometry.x, geometry.y );
714 throwImageException();
718 void Magick::Image::contrast ( const size_t sharpen_ )
721 ExceptionInfo exceptionInfo;
722 GetExceptionInfo( &exceptionInfo );
723 ContrastImage ( image(), (MagickBooleanType) sharpen_, &exceptionInfo );
724 throwException( exceptionInfo );
725 (void) DestroyExceptionInfo( &exceptionInfo );
728 // Convolve image. Applies a general image convolution kernel to the image.
729 // order_ represents the number of columns and rows in the filter kernel.
730 // kernel_ is an array of doubles representing the convolution kernel.
731 void Magick::Image::convolve ( const size_t order_,
732 const double *kernel_ )
737 ExceptionInfo exceptionInfo;
738 GetExceptionInfo( &exceptionInfo );
739 kernel_info=AcquireKernelInfo((const char *) NULL);
740 kernel_info->width=order_;
741 kernel_info->height=order_;
742 kernel_info->values=(double *) kernel_;
743 kernel_info->bias=image()->bias;
744 MagickCore::Image* newImage =
745 ConvolveImage ( image(), kernel_info, &exceptionInfo );
746 kernel_info->values=(double *) NULL;
747 kernel_info=DestroyKernelInfo(kernel_info);
748 replaceImage( newImage );
749 throwException( exceptionInfo );
750 (void) DestroyExceptionInfo( &exceptionInfo );
754 void Magick::Image::crop ( const Geometry &geometry_ )
756 RectangleInfo cropInfo = geometry_;
757 ExceptionInfo exceptionInfo;
758 GetExceptionInfo( &exceptionInfo );
759 MagickCore::Image* newImage =
763 replaceImage( newImage );
764 throwException( exceptionInfo );
765 (void) DestroyExceptionInfo( &exceptionInfo );
769 void Magick::Image::cycleColormap ( const ssize_t amount_ )
771 ExceptionInfo exceptionInfo;
772 GetExceptionInfo( &exceptionInfo );
774 CycleColormapImage( image(), amount_, &exceptionInfo );
775 throwException( exceptionInfo );
776 (void) DestroyExceptionInfo( &exceptionInfo );
780 void Magick::Image::despeckle ( void )
782 ExceptionInfo exceptionInfo;
783 GetExceptionInfo( &exceptionInfo );
784 MagickCore::Image* newImage =
785 DespeckleImage( image(), &exceptionInfo );
786 replaceImage( newImage );
787 throwException( exceptionInfo );
788 (void) DestroyExceptionInfo( &exceptionInfo );
792 void Magick::Image::display( void )
794 ExceptionInfo exceptionInfo;
795 GetExceptionInfo( &exceptionInfo );
796 DisplayImages( imageInfo(), image(), &exceptionInfo );
797 throwException( exceptionInfo );
798 (void) DestroyExceptionInfo( &exceptionInfo );
801 // Distort image. distorts an image using various distortion methods, by
802 // mapping color lookups of the source image to a new destination image
803 // usally of the same size as the source image, unless 'bestfit' is set to
805 void Magick::Image::distort ( const DistortImageMethod method_,
806 const size_t number_arguments_,
807 const double *arguments_,
808 const bool bestfit_ )
810 ExceptionInfo exceptionInfo;
811 GetExceptionInfo( &exceptionInfo );
812 MagickCore::Image* newImage = DistortImage ( image(), method_,
813 number_arguments_, arguments_, bestfit_ == true ? MagickTrue : MagickFalse,
815 replaceImage( newImage );
816 throwException( exceptionInfo );
817 (void) DestroyExceptionInfo( &exceptionInfo );
820 // Draw on image using single drawable
821 void Magick::Image::draw ( const Magick::Drawable &drawable_ )
825 DrawingWand *wand = DrawAllocateWand( options()->drawInfo(), image());
829 drawable_.operator()(wand);
831 if( constImage()->exception.severity == UndefinedException)
834 wand=DestroyDrawingWand(wand);
837 throwImageException();
840 // Draw on image using a drawable list
841 void Magick::Image::draw ( const std::list<Magick::Drawable> &drawable_ )
845 DrawingWand *wand = DrawAllocateWand( options()->drawInfo(), image());
849 for( std::list<Magick::Drawable>::const_iterator p = drawable_.begin();
850 p != drawable_.end(); p++ )
853 if( constImage()->exception.severity != UndefinedException)
857 if( constImage()->exception.severity == UndefinedException)
860 wand=DestroyDrawingWand(wand);
863 throwImageException();
866 // Hilight edges in image
867 void Magick::Image::edge ( const double radius_, const double sigma_ )
869 ExceptionInfo exceptionInfo;
870 GetExceptionInfo( &exceptionInfo );
871 MagickCore::Image* newImage =
872 EdgeImage( image(), radius_, sigma_, &exceptionInfo );
873 replaceImage( newImage );
874 throwException( exceptionInfo );
875 (void) DestroyExceptionInfo( &exceptionInfo );
878 // Emboss image (hilight edges)
879 void Magick::Image::emboss ( const double radius_, const double sigma_ )
881 ExceptionInfo exceptionInfo;
882 GetExceptionInfo( &exceptionInfo );
883 MagickCore::Image* newImage =
884 EmbossImage( image(), radius_, sigma_, &exceptionInfo );
885 replaceImage( newImage );
886 throwException( exceptionInfo );
887 (void) DestroyExceptionInfo( &exceptionInfo );
890 // Enhance image (minimize noise)
891 void Magick::Image::enhance ( void )
893 ExceptionInfo exceptionInfo;
894 GetExceptionInfo( &exceptionInfo );
895 MagickCore::Image* newImage =
896 EnhanceImage( image(), &exceptionInfo );
897 replaceImage( newImage );
898 throwException( exceptionInfo );
899 (void) DestroyExceptionInfo( &exceptionInfo );
902 // Equalize image (histogram equalization)
903 void Magick::Image::equalize ( void )
905 ExceptionInfo exceptionInfo;
906 GetExceptionInfo( &exceptionInfo );
908 EqualizeImage( image(), &exceptionInfo );
909 throwException( exceptionInfo );
912 // Erase image to current "background color"
913 void Magick::Image::erase ( void )
916 SetImageBackgroundColor( image() );
917 throwImageException();
920 // Extends image as defined by the geometry.
922 void Magick::Image::extent ( const Geometry &geometry_ )
924 RectangleInfo extentInfo = geometry_;
926 ExceptionInfo exceptionInfo;
927 GetExceptionInfo( &exceptionInfo );
928 MagickCore::Image* newImage =
929 ExtentImage ( image(), &extentInfo, &exceptionInfo );
930 replaceImage( newImage );
931 throwException( exceptionInfo );
932 (void) DestroyExceptionInfo( &exceptionInfo );
934 void Magick::Image::extent ( const Geometry &geometry_, const Color &backgroundColor_ )
936 backgroundColor ( backgroundColor_ );
937 extent ( geometry_ );
939 void Magick::Image::extent ( const Geometry &geometry_, const GravityType gravity_ )
941 image()->gravity = gravity_;
942 extent ( geometry_ );
944 void Magick::Image::extent ( const Geometry &geometry_, const Color &backgroundColor_, const GravityType gravity_ )
946 image()->gravity = gravity_;
947 backgroundColor ( backgroundColor_ );
948 extent ( geometry_ );
951 // Flip image (reflect each scanline in the vertical direction)
952 void Magick::Image::flip ( void )
954 ExceptionInfo exceptionInfo;
955 GetExceptionInfo( &exceptionInfo );
956 MagickCore::Image* newImage =
957 FlipImage( image(), &exceptionInfo );
958 replaceImage( newImage );
959 throwException( exceptionInfo );
960 (void) DestroyExceptionInfo( &exceptionInfo );
963 // Flood-fill color across pixels that match the color of the
964 // target pixel and are neighbors of the target pixel.
965 // Uses current fuzz setting when determining color match.
966 void Magick::Image::floodFillColor( const ssize_t x_,
968 const Magick::Color &fillColor_ )
970 floodFillTexture( x_, y_, Image( Geometry( 1, 1), fillColor_ ) );
972 void Magick::Image::floodFillColor( const Geometry &point_,
973 const Magick::Color &fillColor_ )
975 floodFillTexture( point_, Image( Geometry( 1, 1), fillColor_) );
978 // Flood-fill color across pixels starting at target-pixel and
979 // stopping at pixels matching specified border color.
980 // Uses current fuzz setting when determining color match.
981 void Magick::Image::floodFillColor( const ssize_t x_,
983 const Magick::Color &fillColor_,
984 const Magick::Color &borderColor_ )
986 floodFillTexture( x_, y_, Image( Geometry( 1, 1), fillColor_),
989 void Magick::Image::floodFillColor( const Geometry &point_,
990 const Magick::Color &fillColor_,
991 const Magick::Color &borderColor_ )
993 floodFillTexture( point_, Image( Geometry( 1, 1), fillColor_),
997 // Floodfill pixels matching color (within fuzz factor) of target
998 // pixel(x,y) with replacement alpha value using method.
999 void Magick::Image::floodFillOpacity( const ssize_t x_,
1001 const unsigned int alpha_,
1002 const PaintMethod method_ )
1006 GetPixelInfo(image(),&target);
1007 PixelPacket pixel=static_cast<PixelPacket>(pixelColor(x_,y_));
1008 target.red=pixel.red;
1009 target.green=pixel.green;
1010 target.blue=pixel.blue;
1011 target.alpha=alpha_;
1012 ExceptionInfo exceptionInfo;
1013 GetExceptionInfo( &exceptionInfo );
1014 FloodfillPaintImage ( image(),
1015 options()->drawInfo(), // const DrawInfo *draw_info
1017 static_cast<ssize_t>(x_), static_cast<ssize_t>(y_),
1018 method_ == FloodfillMethod ? MagickFalse : MagickTrue,
1020 throwException( exceptionInfo );
1021 (void) DestroyExceptionInfo( &exceptionInfo );
1024 // Flood-fill texture across pixels that match the color of the
1025 // target pixel and are neighbors of the target pixel.
1026 // Uses current fuzz setting when determining color match.
1027 void Magick::Image::floodFillTexture( const ssize_t x_,
1029 const Magick::Image &texture_ )
1033 // Set drawing pattern
1034 options()->fillPattern(texture_.constImage());
1037 Pixels pixels(*this);
1039 Quantum *p = pixels.get(x_, y_, 1, 1 );
1041 GetPixelInfo(constImage(),&target);
1042 target.red=GetPixelRed(constImage(),p);
1043 target.green=GetPixelGreen(constImage(),p);
1044 target.blue=GetPixelBlue(constImage(),p);
1045 ExceptionInfo exceptionInfo;
1046 GetExceptionInfo( &exceptionInfo );
1048 FloodfillPaintImage ( image(), // Image *image
1049 options()->drawInfo(), // const DrawInfo *draw_info
1050 &target, // const MagickPacket target
1051 static_cast<ssize_t>(x_), // const ssize_t x_offset
1052 static_cast<ssize_t>(y_), // const ssize_t y_offset
1053 MagickFalse, // const PaintMethod method
1055 throwException( exceptionInfo );
1056 (void) DestroyExceptionInfo( &exceptionInfo );
1059 void Magick::Image::floodFillTexture( const Magick::Geometry &point_,
1060 const Magick::Image &texture_ )
1062 floodFillTexture( point_.xOff(), point_.yOff(), texture_ );
1065 // Flood-fill texture across pixels starting at target-pixel and
1066 // stopping at pixels matching specified border color.
1067 // Uses current fuzz setting when determining color match.
1068 void Magick::Image::floodFillTexture( const ssize_t x_,
1070 const Magick::Image &texture_,
1071 const Magick::Color &borderColor_ )
1075 // Set drawing fill pattern
1076 options()->fillPattern(texture_.constImage());
1079 GetPixelInfo(constImage(),&target);
1080 target.red=static_cast<PixelPacket>(borderColor_).red;
1081 target.green=static_cast<PixelPacket>(borderColor_).green;
1082 target.blue=static_cast<PixelPacket>(borderColor_).blue;
1083 ExceptionInfo exceptionInfo;
1084 GetExceptionInfo( &exceptionInfo );
1085 FloodfillPaintImage ( image(),
1086 options()->drawInfo(),
1088 static_cast<ssize_t>(x_),
1089 static_cast<ssize_t>(y_),
1090 MagickTrue, &exceptionInfo);
1092 throwException( exceptionInfo );
1093 (void) DestroyExceptionInfo( &exceptionInfo );
1095 void Magick::Image::floodFillTexture( const Magick::Geometry &point_,
1096 const Magick::Image &texture_,
1097 const Magick::Color &borderColor_ )
1099 floodFillTexture( point_.xOff(), point_.yOff(), texture_, borderColor_ );
1102 // Flop image (reflect each scanline in the horizontal direction)
1103 void Magick::Image::flop ( void )
1105 ExceptionInfo exceptionInfo;
1106 GetExceptionInfo( &exceptionInfo );
1107 MagickCore::Image* newImage =
1108 FlopImage( image(), &exceptionInfo );
1109 replaceImage( newImage );
1110 throwException( exceptionInfo );
1111 (void) DestroyExceptionInfo( &exceptionInfo );
1115 void Magick::Image::frame ( const Geometry &geometry_ )
1119 info.x = static_cast<ssize_t>(geometry_.width());
1120 info.y = static_cast<ssize_t>(geometry_.height());
1121 info.width = columns() + ( static_cast<size_t>(info.x) << 1 );
1122 info.height = rows() + ( static_cast<size_t>(info.y) << 1 );
1123 info.outer_bevel = geometry_.xOff();
1124 info.inner_bevel = geometry_.yOff();
1126 ExceptionInfo exceptionInfo;
1127 GetExceptionInfo( &exceptionInfo );
1128 MagickCore::Image* newImage =
1129 FrameImage( image(), &info, image()->compose, &exceptionInfo );
1130 replaceImage( newImage );
1131 throwException( exceptionInfo );
1132 (void) DestroyExceptionInfo( &exceptionInfo );
1134 void Magick::Image::frame ( const size_t width_,
1135 const size_t height_,
1136 const ssize_t outerBevel_, const ssize_t innerBevel_ )
1139 info.x = static_cast<ssize_t>(width_);
1140 info.y = static_cast<ssize_t>(height_);
1141 info.width = columns() + ( static_cast<size_t>(info.x) << 1 );
1142 info.height = rows() + ( static_cast<size_t>(info.y) << 1 );
1143 info.outer_bevel = static_cast<ssize_t>(outerBevel_);
1144 info.inner_bevel = static_cast<ssize_t>(innerBevel_);
1146 ExceptionInfo exceptionInfo;
1147 GetExceptionInfo( &exceptionInfo );
1148 MagickCore::Image* newImage =
1149 FrameImage( image(), &info, image()->compose, &exceptionInfo );
1150 replaceImage( newImage );
1151 throwException( exceptionInfo );
1152 (void) DestroyExceptionInfo( &exceptionInfo );
1155 // Fx image. Applies a mathematical expression to the image.
1156 void Magick::Image::fx ( const std::string expression )
1158 ExceptionInfo exceptionInfo;
1159 GetExceptionInfo( &exceptionInfo );
1160 MagickCore::Image* newImage =
1161 FxImage ( image(), expression.c_str(), &exceptionInfo );
1162 replaceImage( newImage );
1163 throwException( exceptionInfo );
1164 (void) DestroyExceptionInfo( &exceptionInfo );
1166 void Magick::Image::fx ( const std::string expression,
1167 const Magick::ChannelType channel )
1169 ExceptionInfo exceptionInfo;
1170 GetExceptionInfo( &exceptionInfo );
1171 ChannelType channel_mask = SetPixelChannelMask( image(), channel );
1172 MagickCore::Image* newImage =
1173 FxImage ( image(), expression.c_str(), &exceptionInfo );
1174 (void) SetPixelChannelMap( image(), channel_mask );
1175 replaceImage( newImage );
1176 throwException( exceptionInfo );
1177 (void) DestroyExceptionInfo( &exceptionInfo );
1180 // Gamma correct image
1181 void Magick::Image::gamma ( const double gamma_ )
1183 ExceptionInfo exceptionInfo;
1184 GetExceptionInfo( &exceptionInfo );
1186 GammaImage ( image(), gamma_, &exceptionInfo );
1187 throwException( exceptionInfo );
1188 (void) DestroyExceptionInfo( &exceptionInfo );
1191 void Magick::Image::gamma ( const double gammaRed_,
1192 const double gammaGreen_,
1193 const double gammaBlue_ )
1195 char gamma[MaxTextExtent + 1];
1196 FormatLocaleString( gamma, MaxTextExtent, "%3.6f/%3.6f/%3.6f/",
1197 gammaRed_, gammaGreen_, gammaBlue_);
1199 ExceptionInfo exceptionInfo;
1200 GetExceptionInfo( &exceptionInfo );
1202 GammaImage ( image(), atof(gamma), &exceptionInfo );
1203 throwException( exceptionInfo );
1204 (void) DestroyExceptionInfo( &exceptionInfo );
1207 // Gaussian blur image
1208 // The number of neighbor pixels to be included in the convolution
1209 // mask is specified by 'width_'. The standard deviation of the
1210 // gaussian bell curve is specified by 'sigma_'.
1211 void Magick::Image::gaussianBlur ( const double width_, const double sigma_ )
1213 ExceptionInfo exceptionInfo;
1214 GetExceptionInfo( &exceptionInfo );
1215 MagickCore::Image* newImage =
1216 GaussianBlurImage( image(), width_, sigma_, image()->bias, &exceptionInfo );
1217 replaceImage( newImage );
1218 throwException( exceptionInfo );
1219 (void) DestroyExceptionInfo( &exceptionInfo );
1222 void Magick::Image::gaussianBlurChannel ( const ChannelType channel_,
1223 const double width_,
1224 const double sigma_ )
1226 ExceptionInfo exceptionInfo;
1227 GetExceptionInfo( &exceptionInfo );
1228 ChannelType channel_mask = SetPixelChannelMask( image(), channel_ );
1229 MagickCore::Image* newImage =
1230 GaussianBlurImage( image(), width_, sigma_, image()->bias, &exceptionInfo );
1231 (void) SetPixelChannelMap( image(), channel_mask );
1232 replaceImage( newImage );
1233 throwException( exceptionInfo );
1234 (void) DestroyExceptionInfo( &exceptionInfo );
1237 // Apply a color lookup table (Hald CLUT) to the image.
1238 void Magick::Image::haldClut ( const Image &clutImage_ )
1240 ExceptionInfo exceptionInfo;
1241 GetExceptionInfo( &exceptionInfo );
1243 (void) HaldClutImage( image(), clutImage_.constImage(), &exceptionInfo );
1244 throwException( exceptionInfo );
1245 (void) DestroyExceptionInfo( &exceptionInfo );
1249 void Magick::Image::implode ( const double factor_ )
1251 ExceptionInfo exceptionInfo;
1252 GetExceptionInfo( &exceptionInfo );
1253 MagickCore::Image* newImage =
1254 ImplodeImage( image(), factor_, image()->interpolate, &exceptionInfo );
1255 replaceImage( newImage );
1256 throwException( exceptionInfo );
1257 (void) DestroyExceptionInfo( &exceptionInfo );
1260 // implements the inverse discrete Fourier transform (IFT) of the image either
1261 // as a magnitude / phase or real / imaginary image pair.
1262 void Magick::Image::inverseFourierTransform ( const Image &phase_ )
1264 ExceptionInfo exceptionInfo;
1265 GetExceptionInfo( &exceptionInfo );
1266 MagickCore::Image* newImage = InverseFourierTransformImage( image(),
1267 phase_.constImage(), MagickTrue, &exceptionInfo);
1268 replaceImage( newImage );
1269 throwException( exceptionInfo );
1270 (void) DestroyExceptionInfo( &exceptionInfo );
1272 void Magick::Image::inverseFourierTransform ( const Image &phase_,
1273 const bool magnitude_ )
1275 ExceptionInfo exceptionInfo;
1276 GetExceptionInfo( &exceptionInfo );
1277 MagickCore::Image* newImage = InverseFourierTransformImage( image(),
1278 phase_.constImage(), magnitude_ == true ? MagickTrue : MagickFalse,
1280 replaceImage( newImage );
1281 throwException( exceptionInfo );
1282 (void) DestroyExceptionInfo( &exceptionInfo );
1285 // Level image. Adjust the levels of the image by scaling the colors
1286 // falling between specified white and black points to the full
1287 // available quantum range. The parameters provided represent the
1288 // black, mid (gamma), and white points. The black point specifies
1289 // the darkest color in the image. Colors darker than the black point
1290 // are set to zero. Mid point (gamma) specifies a gamma correction to
1291 // apply to the image. White point specifies the lightest color in the
1292 // image. Colors brighter than the white point are set to the maximum
1293 // quantum value. The black and white point have the valid range 0 to
1294 // QuantumRange while gamma has a useful range of 0 to ten.
1295 void Magick::Image::level ( const double black_point,
1296 const double white_point,
1297 const double gamma )
1299 ExceptionInfo exceptionInfo;
1300 GetExceptionInfo( &exceptionInfo );
1302 (void) LevelImage( image(), black_point, white_point, gamma, &exceptionInfo );
1303 throwException( exceptionInfo );
1304 (void) DestroyExceptionInfo( &exceptionInfo );
1307 // Magnify image by integral size
1308 void Magick::Image::magnify ( void )
1310 ExceptionInfo exceptionInfo;
1311 GetExceptionInfo( &exceptionInfo );
1312 MagickCore::Image* newImage =
1313 MagnifyImage( image(), &exceptionInfo );
1314 replaceImage( newImage );
1315 throwException( exceptionInfo );
1316 (void) DestroyExceptionInfo( &exceptionInfo );
1319 // Remap image colors with closest color from reference image
1320 void Magick::Image::map ( const Image &mapImage_ , const bool dither_ )
1322 ExceptionInfo exceptionInfo;
1323 GetExceptionInfo( &exceptionInfo );
1325 options()->quantizeDither( dither_ );
1326 RemapImage ( options()->quantizeInfo(), image(),
1327 mapImage_.constImage(), &exceptionInfo);
1328 throwException( exceptionInfo );
1329 (void) DestroyExceptionInfo( &exceptionInfo );
1331 // Floodfill designated area with replacement alpha value
1332 void Magick::Image::matteFloodfill ( const Color &target_ ,
1333 const unsigned int alpha_,
1334 const ssize_t x_, const ssize_t y_,
1335 const Magick::PaintMethod method_ )
1339 GetPixelInfo(constImage(),&target);
1340 target.red=static_cast<PixelPacket>(target_).red;
1341 target.green=static_cast<PixelPacket>(target_).green;
1342 target.blue=static_cast<PixelPacket>(target_).blue;
1343 target.alpha=alpha_;
1344 ChannelType channel_mask = SetPixelChannelMask( image(), AlphaChannel );
1345 ExceptionInfo exceptionInfo;
1346 GetExceptionInfo( &exceptionInfo );
1347 FloodfillPaintImage ( image(), options()->drawInfo(), &target, x_, y_,
1348 method_ == FloodfillMethod ? MagickFalse : MagickTrue, &exceptionInfo);
1349 (void) SetPixelChannelMap( image(), channel_mask );
1350 throwException( exceptionInfo );
1351 (void) DestroyExceptionInfo( &exceptionInfo );
1354 // Filter image by replacing each pixel component with the median
1355 // color in a circular neighborhood
1356 void Magick::Image::medianFilter ( const double radius_ )
1358 ExceptionInfo exceptionInfo;
1359 GetExceptionInfo( &exceptionInfo );
1360 MagickCore::Image* newImage =
1361 StatisticImage ( image(), MedianStatistic, (size_t) radius_, (size_t)
1362 radius_,&exceptionInfo );
1363 replaceImage( newImage );
1364 throwException( exceptionInfo );
1365 (void) DestroyExceptionInfo( &exceptionInfo );
1368 // Reduce image by integral size
1369 void Magick::Image::minify ( void )
1371 ExceptionInfo exceptionInfo;
1372 GetExceptionInfo( &exceptionInfo );
1373 MagickCore::Image* newImage =
1374 MinifyImage( image(), &exceptionInfo );
1375 replaceImage( newImage );
1376 throwException( exceptionInfo );
1377 (void) DestroyExceptionInfo( &exceptionInfo );
1380 // Modulate percent hue, saturation, and brightness of an image
1381 void Magick::Image::modulate ( const double brightness_,
1382 const double saturation_,
1385 char modulate[MaxTextExtent + 1];
1386 FormatLocaleString( modulate, MaxTextExtent, "%3.6f,%3.6f,%3.6f",
1387 brightness_, saturation_, hue_);
1389 ExceptionInfo exceptionInfo;
1390 GetExceptionInfo( &exceptionInfo );
1392 ModulateImage( image(), modulate, &exceptionInfo );
1393 throwException( exceptionInfo );
1394 (void) DestroyExceptionInfo( &exceptionInfo );
1397 // Motion blur image with specified blur factor
1398 // The radius_ parameter specifies the radius of the Gaussian, in
1399 // pixels, not counting the center pixel. The sigma_ parameter
1400 // specifies the standard deviation of the Laplacian, in pixels.
1401 // The angle_ parameter specifies the angle the object appears
1402 // to be comming from (zero degrees is from the right).
1403 void Magick::Image::motionBlur ( const double radius_,
1404 const double sigma_,
1405 const double angle_ )
1407 ExceptionInfo exceptionInfo;
1408 GetExceptionInfo( &exceptionInfo );
1409 MagickCore::Image* newImage =
1410 MotionBlurImage( image(), radius_, sigma_, angle_, 0.0, &exceptionInfo);
1411 replaceImage( newImage );
1412 throwException( exceptionInfo );
1413 (void) DestroyExceptionInfo( &exceptionInfo );
1416 // Negate image. Set grayscale_ to true to effect grayscale values
1418 void Magick::Image::negate ( const bool grayscale_ )
1420 ExceptionInfo exceptionInfo;
1421 GetExceptionInfo( &exceptionInfo );
1423 NegateImage ( image(), grayscale_ == true ? MagickTrue : MagickFalse,
1425 throwException( exceptionInfo );
1426 (void) DestroyExceptionInfo( &exceptionInfo );
1430 void Magick::Image::normalize ( void )
1433 ExceptionInfo exceptionInfo;
1434 GetExceptionInfo( &exceptionInfo );
1435 NormalizeImage ( image(), &exceptionInfo );
1436 throwException( exceptionInfo );
1437 (void) DestroyExceptionInfo( &exceptionInfo );
1441 void Magick::Image::oilPaint ( const double radius_, const double sigma_ )
1443 ExceptionInfo exceptionInfo;
1444 GetExceptionInfo( &exceptionInfo );
1445 MagickCore::Image* newImage =
1446 OilPaintImage( image(), radius_, sigma_, &exceptionInfo );
1447 replaceImage( newImage );
1448 throwException( exceptionInfo );
1449 (void) DestroyExceptionInfo( &exceptionInfo );
1452 // Set or attenuate the alpha channel. If the image pixels are
1453 // opaque then they are set to the specified alpha value, otherwise
1454 // they are blended with the supplied alpha value. The value of
1455 // alpha_ ranges from 0 (completely opaque) to QuantumRange. The defines
1456 // OpaqueAlpha and TransparentAlpha are available to specify
1457 // completely opaque or completely transparent, respectively.
1458 void Magick::Image::alpha ( const unsigned int alpha_ )
1461 SetImageOpacity( image(), alpha_ );
1464 // Change the color of an opaque pixel to the pen color.
1465 void Magick::Image::opaque ( const Color &opaqueColor_,
1466 const Color &penColor_ )
1468 if ( !opaqueColor_.isValid() )
1470 throwExceptionExplicit( OptionError,
1471 "Opaque color argument is invalid" );
1473 if ( !penColor_.isValid() )
1475 throwExceptionExplicit( OptionError,
1476 "Pen color argument is invalid" );
1480 std::string opaqueColor = opaqueColor_;
1481 std::string penColor = penColor_;
1485 ExceptionInfo exceptionInfo;
1486 GetExceptionInfo( &exceptionInfo );
1487 (void) QueryMagickColorCompliance(std::string(opaqueColor_).c_str(),
1488 AllCompliance, &opaque, &exceptionInfo);
1489 (void) QueryMagickColorCompliance(std::string(penColor_).c_str(),
1490 AllCompliance, &pen, &exceptionInfo);
1491 OpaquePaintImage ( image(), &opaque, &pen, MagickFalse, &exceptionInfo );
1492 throwException( exceptionInfo );
1493 (void) DestroyExceptionInfo( &exceptionInfo );
1496 // Ping is similar to read except only enough of the image is read to
1497 // determine the image columns, rows, and filesize. Access the
1498 // columns(), rows(), and fileSize() attributes after invoking ping.
1499 // The image data is not valid after calling ping.
1500 void Magick::Image::ping ( const std::string &imageSpec_ )
1502 options()->fileName( imageSpec_ );
1503 ExceptionInfo exceptionInfo;
1504 GetExceptionInfo( &exceptionInfo );
1505 MagickCore::Image* image =
1506 PingImage( imageInfo(), &exceptionInfo );
1507 replaceImage( image );
1508 throwException( exceptionInfo );
1509 (void) DestroyExceptionInfo( &exceptionInfo );
1512 // Ping is similar to read except only enough of the image is read
1513 // to determine the image columns, rows, and filesize. Access the
1514 // columns(), rows(), and fileSize() attributes after invoking
1515 // ping. The image data is not valid after calling ping.
1516 void Magick::Image::ping ( const Blob& blob_ )
1518 ExceptionInfo exceptionInfo;
1519 GetExceptionInfo( &exceptionInfo );
1520 MagickCore::Image* image =
1521 PingBlob( imageInfo(), blob_.data(), blob_.length(), &exceptionInfo );
1522 replaceImage( image );
1523 throwException( exceptionInfo );
1524 (void) DestroyExceptionInfo( &exceptionInfo );
1527 // Execute a named process module using an argc/argv syntax similar to
1528 // that accepted by a C 'main' routine. An exception is thrown if the
1529 // requested process module doesn't exist, fails to load, or fails during
1531 void Magick::Image::process( std::string name_, const ssize_t argc, const char **argv )
1536 InvokeDynamicImageFilter( name_.c_str(), &image(), argc, argv,
1537 &image()->exception );
1539 if (status == false)
1540 throwException( image()->exception );
1543 // Quantize colors in image using current quantization settings
1544 // Set measureError_ to true in order to measure quantization error
1545 void Magick::Image::quantize ( const bool measureError_ )
1550 options()->quantizeInfo()->measure_error=MagickTrue;
1552 options()->quantizeInfo()->measure_error=MagickFalse;
1554 ExceptionInfo exceptionInfo;
1555 GetExceptionInfo( &exceptionInfo );
1556 QuantizeImage( options()->quantizeInfo(), image(), &exceptionInfo );
1558 throwException( exceptionInfo );
1559 (void) DestroyExceptionInfo( &exceptionInfo );
1562 // Apply an arithmetic or bitwise operator to the image pixel quantums.
1563 void Magick::Image::quantumOperator ( const ChannelType channel_,
1564 const MagickEvaluateOperator operator_,
1567 ExceptionInfo exceptionInfo;
1568 GetExceptionInfo( &exceptionInfo );
1569 ChannelType channel_mask = SetPixelChannelMask( image(), channel_ );
1570 EvaluateImage( image(), operator_, rvalue_, &exceptionInfo);
1571 (void) SetPixelChannelMap( image(), channel_mask );
1572 throwException( exceptionInfo );
1573 (void) DestroyExceptionInfo( &exceptionInfo );
1576 void Magick::Image::quantumOperator ( const ssize_t x_,const ssize_t y_,
1577 const size_t columns_,
1579 const ChannelType channel_,
1580 const MagickEvaluateOperator operator_,
1581 const double rvalue_)
1583 ExceptionInfo exceptionInfo;
1584 GetExceptionInfo( &exceptionInfo );
1585 RectangleInfo geometry;
1586 geometry.width = columns_;
1587 geometry.height = rows_;
1590 MagickCore::Image *crop_image = CropImage( image(), &geometry,
1592 ChannelType channel_mask = SetPixelChannelMask( image(), channel_);
1593 EvaluateImage( crop_image, operator_, rvalue_, &exceptionInfo );
1594 (void) SetPixelChannelMap( image(), channel_mask );
1595 (void) CompositeImage( image(), image()->matte != MagickFalse ?
1596 OverCompositeOp : CopyCompositeOp, crop_image, geometry.x, geometry.y );
1597 crop_image = DestroyImageList(crop_image);
1598 throwException( exceptionInfo );
1599 (void) DestroyExceptionInfo( &exceptionInfo );
1602 // Raise image (lighten or darken the edges of an image to give a 3-D
1603 // raised or lowered effect)
1604 void Magick::Image::raise ( const Geometry &geometry_ ,
1605 const bool raisedFlag_ )
1607 ExceptionInfo exceptionInfo;
1608 GetExceptionInfo( &exceptionInfo );
1609 RectangleInfo raiseInfo = geometry_;
1611 RaiseImage ( image(), &raiseInfo, raisedFlag_ == true ? MagickTrue : MagickFalse, &exceptionInfo );
1612 throwException( exceptionInfo );
1613 (void) DestroyExceptionInfo( &exceptionInfo );
1617 // Random threshold image.
1619 // Changes the value of individual pixels based on the intensity
1620 // of each pixel compared to a random threshold. The result is a
1621 // low-contrast, two color image. The thresholds_ argument is a
1622 // geometry containing LOWxHIGH thresholds. If the string
1623 // contains 2x2, 3x3, or 4x4, then an ordered dither of order 2,
1624 // 3, or 4 will be performed instead. If a channel_ argument is
1625 // specified then only the specified channel is altered. This is
1626 // a very fast alternative to 'quantize' based dithering.
1627 void Magick::Image::randomThreshold( const Geometry &thresholds_ )
1629 randomThresholdChannel(thresholds_,DefaultChannels);
1631 void Magick::Image::randomThresholdChannel( const Geometry &thresholds_,
1632 const ChannelType channel_ )
1634 ExceptionInfo exceptionInfo;
1635 GetExceptionInfo( &exceptionInfo );
1637 ChannelType channel_mask = SetPixelChannelMask( image(), channel_);
1638 (void) RandomThresholdImage( image(),
1639 static_cast<std::string>(thresholds_).c_str(),
1641 (void) SetPixelChannelMap( image(), channel_mask );
1642 throwImageException();
1643 (void) DestroyExceptionInfo( &exceptionInfo );
1646 // Read image into current object
1647 void Magick::Image::read ( const std::string &imageSpec_ )
1649 options()->fileName( imageSpec_ );
1651 ExceptionInfo exceptionInfo;
1652 GetExceptionInfo( &exceptionInfo );
1653 MagickCore::Image* image =
1654 ReadImage( imageInfo(), &exceptionInfo );
1656 // Ensure that multiple image frames were not read.
1657 if ( image && image->next )
1659 // Destroy any extra image frames
1660 MagickCore::Image* next = image->next;
1663 DestroyImageList( next );
1666 replaceImage( image );
1667 throwException( exceptionInfo );
1669 throwException( image->exception );
1670 (void) DestroyExceptionInfo( &exceptionInfo );
1673 // Read image of specified size into current object
1674 void Magick::Image::read ( const Geometry &size_,
1675 const std::string &imageSpec_ )
1681 // Read image from in-memory BLOB
1682 void Magick::Image::read ( const Blob &blob_ )
1684 ExceptionInfo exceptionInfo;
1685 GetExceptionInfo( &exceptionInfo );
1686 MagickCore::Image* image =
1687 BlobToImage( imageInfo(),
1688 static_cast<const void *>(blob_.data()),
1689 blob_.length(), &exceptionInfo );
1690 replaceImage( image );
1691 throwException( exceptionInfo );
1693 throwException( image->exception );
1694 (void) DestroyExceptionInfo( &exceptionInfo );
1697 // Read image of specified size from in-memory BLOB
1698 void Magick::Image::read ( const Blob &blob_,
1699 const Geometry &size_ )
1707 // Read image of specified size and depth from in-memory BLOB
1708 void Magick::Image::read ( const Blob &blob_,
1709 const Geometry &size_,
1710 const size_t depth_ )
1720 // Read image of specified size, depth, and format from in-memory BLOB
1721 void Magick::Image::read ( const Blob &blob_,
1722 const Geometry &size_,
1723 const size_t depth_,
1724 const std::string &magick_ )
1732 // Set explicit image format
1733 fileName( magick_ + ':');
1738 // Read image of specified size, and format from in-memory BLOB
1739 void Magick::Image::read ( const Blob &blob_,
1740 const Geometry &size_,
1741 const std::string &magick_ )
1747 // Set explicit image format
1748 fileName( magick_ + ':');
1753 // Read image based on raw pixels in memory (ConstituteImage)
1754 void Magick::Image::read ( const size_t width_,
1755 const size_t height_,
1756 const std::string &map_,
1757 const StorageType type_,
1758 const void *pixels_ )
1760 ExceptionInfo exceptionInfo;
1761 GetExceptionInfo( &exceptionInfo );
1762 MagickCore::Image* image =
1763 ConstituteImage( width_, height_, map_.c_str(), type_, pixels_,
1765 replaceImage( image );
1766 throwException( exceptionInfo );
1768 throwException( image->exception );
1769 (void) DestroyExceptionInfo( &exceptionInfo );
1772 // Reduce noise in image
1773 void Magick::Image::reduceNoise ( const double order_ )
1775 ExceptionInfo exceptionInfo;
1776 GetExceptionInfo( &exceptionInfo );
1777 MagickCore::Image* newImage =
1778 StatisticImage( image(), NonpeakStatistic, (size_t) order_, (size_t) order_,
1780 replaceImage( newImage );
1781 throwException( exceptionInfo );
1782 (void) DestroyExceptionInfo( &exceptionInfo );
1786 void Magick::Image::resize( const Geometry &geometry_ )
1788 // Calculate new size. This code should be supported using binary arguments
1789 // in the ImageMagick library.
1792 size_t width = columns();
1793 size_t height = rows();
1795 ParseMetaGeometry (static_cast<std::string>(geometry_).c_str(),
1799 ExceptionInfo exceptionInfo;
1800 GetExceptionInfo( &exceptionInfo );
1801 MagickCore::Image* newImage =
1802 ResizeImage( image(),
1808 replaceImage( newImage );
1809 throwException( exceptionInfo );
1810 (void) DestroyExceptionInfo( &exceptionInfo );
1814 void Magick::Image::roll ( const Geometry &roll_ )
1816 ssize_t xOff = roll_.xOff();
1817 if ( roll_.xNegative() )
1819 ssize_t yOff = roll_.yOff();
1820 if ( roll_.yNegative() )
1823 ExceptionInfo exceptionInfo;
1824 GetExceptionInfo( &exceptionInfo );
1825 MagickCore::Image* newImage =
1826 RollImage( image(), xOff, yOff, &exceptionInfo );
1827 replaceImage( newImage );
1828 throwException( exceptionInfo );
1829 (void) DestroyExceptionInfo( &exceptionInfo );
1831 void Magick::Image::roll ( const size_t columns_,
1832 const size_t rows_ )
1834 ExceptionInfo exceptionInfo;
1835 GetExceptionInfo( &exceptionInfo );
1836 MagickCore::Image* newImage =
1838 static_cast<ssize_t>(columns_),
1839 static_cast<ssize_t>(rows_), &exceptionInfo );
1840 replaceImage( newImage );
1841 throwException( exceptionInfo );
1842 (void) DestroyExceptionInfo( &exceptionInfo );
1846 void Magick::Image::rotate ( const double degrees_ )
1848 ExceptionInfo exceptionInfo;
1849 GetExceptionInfo( &exceptionInfo );
1850 MagickCore::Image* newImage =
1851 RotateImage( image(), degrees_, &exceptionInfo);
1852 replaceImage( newImage );
1853 throwException( exceptionInfo );
1854 (void) DestroyExceptionInfo( &exceptionInfo );
1858 void Magick::Image::sample ( const Geometry &geometry_ )
1862 size_t width = columns();
1863 size_t height = rows();
1865 ParseMetaGeometry (static_cast<std::string>(geometry_).c_str(),
1869 ExceptionInfo exceptionInfo;
1870 GetExceptionInfo( &exceptionInfo );
1871 MagickCore::Image* newImage =
1872 SampleImage( image(), width, height, &exceptionInfo );
1873 replaceImage( newImage );
1874 throwException( exceptionInfo );
1875 (void) DestroyExceptionInfo( &exceptionInfo );
1879 void Magick::Image::scale ( const Geometry &geometry_ )
1883 size_t width = columns();
1884 size_t height = rows();
1886 ParseMetaGeometry (static_cast<std::string>(geometry_).c_str(),
1890 ExceptionInfo exceptionInfo;
1891 GetExceptionInfo( &exceptionInfo );
1892 MagickCore::Image* newImage =
1893 ScaleImage( image(), width, height, &exceptionInfo );
1894 replaceImage( newImage );
1895 throwException( exceptionInfo );
1896 (void) DestroyExceptionInfo( &exceptionInfo );
1899 // Segment (coalesce similar image components) by analyzing the
1900 // histograms of the color components and identifying units that are
1901 // homogeneous with the fuzzy c-means technique.
1902 void Magick::Image::segment ( const double clusterThreshold_,
1903 const double smoothingThreshold_ )
1905 ExceptionInfo exceptionInfo;
1906 GetExceptionInfo( &exceptionInfo );
1908 SegmentImage ( image(),
1909 options()->quantizeColorSpace(),
1910 (MagickBooleanType) options()->verbose(),
1912 smoothingThreshold_, &exceptionInfo );
1913 throwException( exceptionInfo );
1914 (void) DestroyExceptionInfo( &exceptionInfo );
1915 SyncImage( image() );
1918 // Shade image using distant light source
1919 void Magick::Image::shade ( const double azimuth_,
1920 const double elevation_,
1921 const bool colorShading_ )
1923 ExceptionInfo exceptionInfo;
1924 GetExceptionInfo( &exceptionInfo );
1925 MagickCore::Image* newImage =
1926 ShadeImage( image(),
1927 colorShading_ == true ? MagickTrue : MagickFalse,
1931 replaceImage( newImage );
1932 throwException( exceptionInfo );
1933 (void) DestroyExceptionInfo( &exceptionInfo );
1936 // Sharpen pixels in image
1937 void Magick::Image::sharpen ( const double radius_, const double sigma_ )
1939 ExceptionInfo exceptionInfo;
1940 GetExceptionInfo( &exceptionInfo );
1941 MagickCore::Image* newImage =
1942 SharpenImage( image(),
1947 replaceImage( newImage );
1948 throwException( exceptionInfo );
1949 (void) DestroyExceptionInfo( &exceptionInfo );
1952 void Magick::Image::sharpenChannel ( const ChannelType channel_,
1953 const double radius_, const double sigma_ )
1955 ExceptionInfo exceptionInfo;
1956 GetExceptionInfo( &exceptionInfo );
1957 ChannelType channel_mask = SetPixelChannelMask( image(), channel_ );
1958 MagickCore::Image* newImage =
1959 SharpenImage( image(),
1964 (void) SetPixelChannelMap( image(), channel_mask );
1965 replaceImage( newImage );
1966 throwException( exceptionInfo );
1967 (void) DestroyExceptionInfo( &exceptionInfo );
1970 // Shave pixels from image edges.
1971 void Magick::Image::shave ( const Geometry &geometry_ )
1973 RectangleInfo shaveInfo = geometry_;
1974 ExceptionInfo exceptionInfo;
1975 GetExceptionInfo( &exceptionInfo );
1976 MagickCore::Image* newImage =
1977 ShaveImage( image(),
1980 replaceImage( newImage );
1981 throwException( exceptionInfo );
1982 (void) DestroyExceptionInfo( &exceptionInfo );
1986 void Magick::Image::shear ( const double xShearAngle_,
1987 const double yShearAngle_ )
1989 ExceptionInfo exceptionInfo;
1990 GetExceptionInfo( &exceptionInfo );
1991 MagickCore::Image* newImage =
1992 ShearImage( image(),
1996 replaceImage( newImage );
1997 throwException( exceptionInfo );
1998 (void) DestroyExceptionInfo( &exceptionInfo );
2002 void Magick::Image::sigmoidalContrast ( const size_t sharpen_, const double contrast, const double midpoint )
2004 ExceptionInfo exceptionInfo;
2005 GetExceptionInfo( &exceptionInfo );
2007 (void) SigmoidalContrastImage( image(), (MagickBooleanType) sharpen_, contrast, midpoint, &exceptionInfo );
2008 throwException( exceptionInfo );
2009 (void) DestroyExceptionInfo( &exceptionInfo );
2012 // Solarize image (similar to effect seen when exposing a photographic
2013 // film to light during the development process)
2014 void Magick::Image::solarize ( const double factor_ )
2016 ExceptionInfo exceptionInfo;
2017 GetExceptionInfo( &exceptionInfo );
2019 SolarizeImage ( image(), factor_, &exceptionInfo );
2020 throwException( exceptionInfo );
2021 (void) DestroyExceptionInfo( &exceptionInfo );
2024 // Sparse color image, given a set of coordinates, interpolates the colors
2025 // found at those coordinates, across the whole image, using various methods.
2027 void Magick::Image::sparseColor ( const ChannelType channel,
2028 const SparseColorMethod method,
2029 const size_t number_arguments,
2030 const double *arguments )
2032 ExceptionInfo exceptionInfo;
2033 GetExceptionInfo( &exceptionInfo );
2035 ChannelType channel_mask = SetPixelChannelMask( image(), channel );
2036 MagickCore::Image* newImage = SparseColorImage ( image(), method,
2037 number_arguments, arguments, &exceptionInfo );
2038 (void) SetPixelChannelMap( image(), channel_mask );
2039 replaceImage( newImage );
2040 throwException( exceptionInfo );
2041 (void) DestroyExceptionInfo( &exceptionInfo );
2044 // Spread pixels randomly within image by specified ammount
2045 void Magick::Image::spread ( const size_t amount_ )
2047 ExceptionInfo exceptionInfo;
2048 GetExceptionInfo( &exceptionInfo );
2049 MagickCore::Image* newImage =
2050 SpreadImage( image(),
2052 image()->interpolate,
2054 replaceImage( newImage );
2055 throwException( exceptionInfo );
2056 (void) DestroyExceptionInfo( &exceptionInfo );
2059 // Add a digital watermark to the image (based on second image)
2060 void Magick::Image::stegano ( const Image &watermark_ )
2062 ExceptionInfo exceptionInfo;
2063 GetExceptionInfo( &exceptionInfo );
2064 MagickCore::Image* newImage =
2065 SteganoImage( image(),
2066 watermark_.constImage(),
2068 replaceImage( newImage );
2069 throwException( exceptionInfo );
2070 (void) DestroyExceptionInfo( &exceptionInfo );
2073 // Stereo image (left image is current image)
2074 void Magick::Image::stereo ( const Image &rightImage_ )
2076 ExceptionInfo exceptionInfo;
2077 GetExceptionInfo( &exceptionInfo );
2078 MagickCore::Image* newImage =
2079 StereoImage( image(),
2080 rightImage_.constImage(),
2082 replaceImage( newImage );
2083 throwException( exceptionInfo );
2084 (void) DestroyExceptionInfo( &exceptionInfo );
2088 void Magick::Image::swirl ( const double degrees_ )
2090 ExceptionInfo exceptionInfo;
2091 GetExceptionInfo( &exceptionInfo );
2092 MagickCore::Image* newImage =
2093 SwirlImage( image(), degrees_, image()->interpolate,
2095 replaceImage( newImage );
2096 throwException( exceptionInfo );
2097 (void) DestroyExceptionInfo( &exceptionInfo );
2101 void Magick::Image::texture ( const Image &texture_ )
2104 TextureImage( image(), texture_.constImage() );
2105 throwImageException();
2109 void Magick::Image::threshold ( const double threshold_ )
2112 BilevelImage( image(), threshold_ );
2113 throwImageException();
2116 // Transform image based on image geometry only
2117 void Magick::Image::transform ( const Geometry &imageGeometry_ )
2120 TransformImage ( &(image()), 0,
2121 std::string(imageGeometry_).c_str() );
2122 throwImageException();
2124 // Transform image based on image and crop geometries
2125 void Magick::Image::transform ( const Geometry &imageGeometry_,
2126 const Geometry &cropGeometry_ )
2129 TransformImage ( &(image()), std::string(cropGeometry_).c_str(),
2130 std::string(imageGeometry_).c_str() );
2131 throwImageException();
2134 // Add matte image to image, setting pixels matching color to transparent
2135 void Magick::Image::transparent ( const Color &color_ )
2137 if ( !color_.isValid() )
2139 throwExceptionExplicit( OptionError,
2140 "Color argument is invalid" );
2143 std::string color = color_;
2146 (void) QueryMagickColorCompliance(std::string(color_).c_str(),AllCompliance,
2147 &target,&image()->exception);
2148 ExceptionInfo exceptionInfo;
2149 GetExceptionInfo( &exceptionInfo );
2151 TransparentPaintImage ( image(), &target, TransparentAlpha, MagickFalse,
2153 throwException( exceptionInfo );
2154 (void) DestroyExceptionInfo( &exceptionInfo );
2157 // Add matte image to image, setting pixels matching color to transparent
2158 void Magick::Image::transparentChroma(const Color &colorLow_,
2159 const Color &colorHigh_)
2161 if ( !colorLow_.isValid() || !colorHigh_.isValid() )
2163 throwExceptionExplicit( OptionError,
2164 "Color argument is invalid" );
2167 std::string colorLow = colorLow_;
2168 std::string colorHigh = colorHigh_;
2170 PixelInfo targetLow;
2171 PixelInfo targetHigh;
2172 (void) QueryMagickColorCompliance(std::string(colorLow_).c_str(),
2173 AllCompliance,&targetLow,&image()->exception);
2174 (void) QueryMagickColorCompliance(std::string(colorHigh_).c_str(),
2175 AllCompliance,&targetHigh,&image()->exception);
2176 ExceptionInfo exceptionInfo;
2177 GetExceptionInfo( &exceptionInfo );
2179 TransparentPaintImageChroma ( image(), &targetLow, &targetHigh,
2180 TransparentAlpha, MagickFalse, &exceptionInfo );
2181 throwException( exceptionInfo );
2182 (void) DestroyExceptionInfo( &exceptionInfo );
2186 // Trim edges that are the background color from the image
2187 void Magick::Image::trim ( void )
2189 ExceptionInfo exceptionInfo;
2190 GetExceptionInfo( &exceptionInfo );
2191 MagickCore::Image* newImage =
2192 TrimImage( image(), &exceptionInfo);
2193 replaceImage( newImage );
2194 throwException( exceptionInfo );
2195 (void) DestroyExceptionInfo( &exceptionInfo );
2198 // Replace image with a sharpened version of the original image
2199 // using the unsharp mask algorithm.
2201 // the radius of the Gaussian, in pixels, not counting the
2204 // the standard deviation of the Gaussian, in pixels.
2206 // the percentage of the difference between the original and
2207 // the blur image that is added back into the original.
2209 // the threshold in pixels needed to apply the diffence amount.
2210 void Magick::Image::unsharpmask ( const double radius_,
2211 const double sigma_,
2212 const double amount_,
2213 const double threshold_ )
2215 ExceptionInfo exceptionInfo;
2216 GetExceptionInfo( &exceptionInfo );
2217 MagickCore::Image* newImage =
2218 UnsharpMaskImage( image(),
2224 replaceImage( newImage );
2225 throwException( exceptionInfo );
2226 (void) DestroyExceptionInfo( &exceptionInfo );
2229 void Magick::Image::unsharpmaskChannel ( const ChannelType channel_,
2230 const double radius_,
2231 const double sigma_,
2232 const double amount_,
2233 const double threshold_ )
2235 ExceptionInfo exceptionInfo;
2236 GetExceptionInfo( &exceptionInfo );
2237 ChannelType channel_mask = SetPixelChannelMask( image(), channel_ );
2238 MagickCore::Image* newImage =
2239 UnsharpMaskImage( image(),
2245 (void) SetPixelChannelMap( image(), channel_mask );
2246 replaceImage( newImage );
2247 throwException( exceptionInfo );
2248 (void) DestroyExceptionInfo( &exceptionInfo );
2251 // Map image pixels to a sine wave
2252 void Magick::Image::wave ( const double amplitude_, const double wavelength_ )
2254 ExceptionInfo exceptionInfo;
2255 GetExceptionInfo( &exceptionInfo );
2256 MagickCore::Image* newImage =
2260 image()->interpolate,
2262 replaceImage( newImage );
2263 throwException( exceptionInfo );
2264 (void) DestroyExceptionInfo( &exceptionInfo );
2267 // Write image to file
2268 void Magick::Image::write( const std::string &imageSpec_ )
2270 ExceptionInfo exceptionInfo;
2271 GetExceptionInfo( &exceptionInfo );
2273 fileName( imageSpec_ );
2274 WriteImage( imageInfo(), image(), &exceptionInfo );
2275 throwException( exceptionInfo );
2276 (void) DestroyExceptionInfo( &exceptionInfo );
2279 // Write image to in-memory BLOB
2280 void Magick::Image::write ( Blob *blob_ )
2283 size_t length = 2048; // Efficient size for small images
2284 ExceptionInfo exceptionInfo;
2285 GetExceptionInfo( &exceptionInfo );
2286 void* data = ImageToBlob( imageInfo(),
2290 throwException( exceptionInfo );
2291 blob_->updateNoCopy( data, length, Blob::MallocAllocator );
2292 throwImageException();
2293 (void) DestroyExceptionInfo( &exceptionInfo );
2295 void Magick::Image::write ( Blob *blob_,
2296 const std::string &magick_ )
2300 size_t length = 2048; // Efficient size for small images
2301 ExceptionInfo exceptionInfo;
2302 GetExceptionInfo( &exceptionInfo );
2303 void* data = ImageToBlob( imageInfo(),
2307 throwException( exceptionInfo );
2308 blob_->updateNoCopy( data, length, Blob::MallocAllocator );
2309 throwImageException();
2310 (void) DestroyExceptionInfo( &exceptionInfo );
2312 void Magick::Image::write ( Blob *blob_,
2313 const std::string &magick_,
2314 const size_t depth_ )
2319 size_t length = 2048; // Efficient size for small images
2320 ExceptionInfo exceptionInfo;
2321 GetExceptionInfo( &exceptionInfo );
2322 void* data = ImageToBlob( imageInfo(),
2326 throwException( exceptionInfo );
2327 blob_->updateNoCopy( data, length, Blob::MallocAllocator );
2328 throwImageException();
2329 (void) DestroyExceptionInfo( &exceptionInfo );
2332 // Write image to an array of pixels with storage type specified
2333 // by user (ExportImagePixels), e.g.
2334 // image.write( 0, 0, 640, 1, "RGB", 0, pixels );
2335 void Magick::Image::write ( const ssize_t x_,
2337 const size_t columns_,
2339 const std::string &map_,
2340 const StorageType type_,
2343 ExceptionInfo exceptionInfo;
2344 GetExceptionInfo( &exceptionInfo );
2345 ExportImagePixels( image(), x_, y_, columns_, rows_, map_.c_str(), type_,
2348 throwException( exceptionInfo );
2349 (void) DestroyExceptionInfo( &exceptionInfo );
2353 void Magick::Image::zoom( const Geometry &geometry_ )
2355 // Calculate new size. This code should be supported using binary arguments
2356 // in the ImageMagick library.
2359 size_t width = columns();
2360 size_t height = rows();
2362 ParseMetaGeometry (static_cast<std::string>(geometry_).c_str(),
2366 ExceptionInfo exceptionInfo;
2367 GetExceptionInfo( &exceptionInfo );
2368 MagickCore::Image* newImage =
2369 ResizeImage( image(),
2375 replaceImage( newImage );
2376 throwException( exceptionInfo );
2377 (void) DestroyExceptionInfo( &exceptionInfo );
2381 * Methods for setting image attributes
2385 // Join images into a single multi-image file
2386 void Magick::Image::adjoin ( const bool flag_ )
2389 options()->adjoin( flag_ );
2391 bool Magick::Image::adjoin ( void ) const
2393 return constOptions()->adjoin();
2396 // Remove pixel aliasing
2397 void Magick::Image::antiAlias( const bool flag_ )
2400 options()->antiAlias( static_cast<size_t>(flag_) );
2402 bool Magick::Image::antiAlias( void )
2404 return static_cast<bool>( options()->antiAlias( ) );
2407 // Animation inter-frame delay
2408 void Magick::Image::animationDelay ( const size_t delay_ )
2411 image()->delay = delay_;
2413 size_t Magick::Image::animationDelay ( void ) const
2415 return constImage()->delay;
2418 // Number of iterations to play animation
2419 void Magick::Image::animationIterations ( const size_t iterations_ )
2422 image()->iterations = iterations_;
2424 size_t Magick::Image::animationIterations ( void ) const
2426 return constImage()->iterations;
2429 // Access/Update a named image attribute
2430 void Magick::Image::attribute ( const std::string name_,
2431 const std::string value_ )
2434 SetImageProperty( image(), name_.c_str(), value_.c_str() );
2436 std::string Magick::Image::attribute ( const std::string name_ )
2438 const char *value = GetImageProperty( constImage(), name_.c_str() );
2441 return std::string( value );
2443 return std::string(); // Intentionally no exception
2447 void Magick::Image::backgroundColor ( const Color &backgroundColor_ )
2451 if ( backgroundColor_.isValid() )
2453 image()->background_color = backgroundColor_;
2457 image()->background_color = Color();
2460 options()->backgroundColor( backgroundColor_ );
2462 Magick::Color Magick::Image::backgroundColor ( void ) const
2464 return constOptions()->backgroundColor( );
2467 // Background fill texture
2468 void Magick::Image::backgroundTexture ( const std::string &backgroundTexture_ )
2471 options()->backgroundTexture( backgroundTexture_ );
2473 std::string Magick::Image::backgroundTexture ( void ) const
2475 return constOptions()->backgroundTexture( );
2478 // Original image columns
2479 size_t Magick::Image::baseColumns ( void ) const
2481 return constImage()->magick_columns;
2484 // Original image name
2485 std::string Magick::Image::baseFilename ( void ) const
2487 return std::string(constImage()->magick_filename);
2490 // Original image rows
2491 size_t Magick::Image::baseRows ( void ) const
2493 return constImage()->magick_rows;
2497 void Magick::Image::borderColor ( const Color &borderColor_ )
2501 if ( borderColor_.isValid() )
2503 image()->border_color = borderColor_;
2507 image()->border_color = Color();
2510 options()->borderColor( borderColor_ );
2512 Magick::Color Magick::Image::borderColor ( void ) const
2514 return constOptions()->borderColor( );
2517 // Return smallest bounding box enclosing non-border pixels. The
2518 // current fuzz value is used when discriminating between pixels.
2519 // This is the crop bounding box used by crop(Geometry(0,0));
2520 Magick::Geometry Magick::Image::boundingBox ( void ) const
2522 ExceptionInfo exceptionInfo;
2523 GetExceptionInfo( &exceptionInfo );
2524 RectangleInfo bbox = GetImageBoundingBox( constImage(), &exceptionInfo);
2525 throwException( exceptionInfo );
2526 (void) DestroyExceptionInfo( &exceptionInfo );
2527 return Geometry( bbox );
2530 // Text bounding-box base color
2531 void Magick::Image::boxColor ( const Color &boxColor_ )
2534 options()->boxColor( boxColor_ );
2536 Magick::Color Magick::Image::boxColor ( void ) const
2538 return constOptions()->boxColor( );
2541 // Pixel cache threshold. Once this threshold is exceeded, all
2542 // subsequent pixels cache operations are to/from disk.
2543 // This setting is shared by all Image objects.
2545 void Magick::Image::cacheThreshold ( const size_t threshold_ )
2547 SetMagickResourceLimit( MemoryResource, threshold_ );
2550 void Magick::Image::chromaBluePrimary ( const double x_, const double y_ )
2553 image()->chromaticity.blue_primary.x = x_;
2554 image()->chromaticity.blue_primary.y = y_;
2556 void Magick::Image::chromaBluePrimary ( double *x_, double *y_ ) const
2558 *x_ = constImage()->chromaticity.blue_primary.x;
2559 *y_ = constImage()->chromaticity.blue_primary.y;
2562 void Magick::Image::chromaGreenPrimary ( const double x_, const double y_ )
2565 image()->chromaticity.green_primary.x = x_;
2566 image()->chromaticity.green_primary.y = y_;
2568 void Magick::Image::chromaGreenPrimary ( double *x_, double *y_ ) const
2570 *x_ = constImage()->chromaticity.green_primary.x;
2571 *y_ = constImage()->chromaticity.green_primary.y;
2574 void Magick::Image::chromaRedPrimary ( const double x_, const double y_ )
2577 image()->chromaticity.red_primary.x = x_;
2578 image()->chromaticity.red_primary.y = y_;
2580 void Magick::Image::chromaRedPrimary ( double *x_, double *y_ ) const
2582 *x_ = constImage()->chromaticity.red_primary.x;
2583 *y_ = constImage()->chromaticity.red_primary.y;
2586 void Magick::Image::chromaWhitePoint ( const double x_, const double y_ )
2589 image()->chromaticity.white_point.x = x_;
2590 image()->chromaticity.white_point.y = y_;
2592 void Magick::Image::chromaWhitePoint ( double *x_, double *y_ ) const
2594 *x_ = constImage()->chromaticity.white_point.x;
2595 *y_ = constImage()->chromaticity.white_point.y;
2598 // Set image storage class
2599 void Magick::Image::classType ( const ClassType class_ )
2601 if ( classType() == PseudoClass && class_ == DirectClass )
2603 // Use SyncImage to synchronize the DirectClass pixels with the
2604 // color map and then set to DirectClass type.
2606 SyncImage( image() );
2607 image()->colormap = (PixelPacket *)
2608 RelinquishMagickMemory( image()->colormap );
2609 image()->storage_class = static_cast<MagickCore::ClassType>(DirectClass);
2613 if ( classType() == DirectClass && class_ == PseudoClass )
2615 // Quantize to create PseudoClass color map
2617 quantizeColors(MaxColormapSize);
2619 image()->storage_class = static_cast<MagickCore::ClassType>(PseudoClass);
2623 // Associate a clip mask with the image. The clip mask must be the
2624 // same dimensions as the image. Pass an invalid image to unset an
2625 // existing clip mask.
2626 void Magick::Image::clipMask ( const Magick::Image & clipMask_ )
2630 ExceptionInfo exceptionInfo;
2631 GetExceptionInfo( &exceptionInfo );
2632 if( clipMask_.isValid() )
2635 SetImageClipMask( image(), clipMask_.constImage(), &exceptionInfo );
2639 // Unset existing clip mask
2640 SetImageClipMask( image(), 0, &exceptionInfo );
2642 throwException( exceptionInfo );
2643 (void) DestroyExceptionInfo( &exceptionInfo );
2645 Magick::Image Magick::Image::clipMask ( void ) const
2647 ExceptionInfo exceptionInfo;
2648 GetExceptionInfo( &exceptionInfo );
2649 MagickCore::Image* image =
2650 GetImageClipMask( constImage(), &exceptionInfo );
2651 throwException( exceptionInfo );
2652 (void) DestroyExceptionInfo( &exceptionInfo );
2653 return Magick::Image( image );
2656 void Magick::Image::colorFuzz ( const double fuzz_ )
2659 image()->fuzz = fuzz_;
2660 options()->colorFuzz( fuzz_ );
2662 double Magick::Image::colorFuzz ( void ) const
2664 return constOptions()->colorFuzz( );
2667 // Set color in colormap at index
2668 void Magick::Image::colorMap ( const size_t index_,
2669 const Color &color_ )
2671 MagickCore::Image* imageptr = image();
2673 if (index_ > (MaxColormapSize-1) )
2674 throwExceptionExplicit( OptionError,
2675 "Colormap index must be less than MaxColormapSize" );
2677 if ( !color_.isValid() )
2678 throwExceptionExplicit( OptionError,
2679 "Color argument is invalid");
2682 // Ensure that colormap size is large enough
2683 if ( colorMapSize() < (index_+1) )
2684 colorMapSize( index_ + 1 );
2686 // Set color at index in colormap
2687 (imageptr->colormap)[index_] = color_;
2689 // Return color in colormap at index
2690 Magick::Color Magick::Image::colorMap ( const size_t index_ ) const
2692 const MagickCore::Image* imageptr = constImage();
2694 if ( !imageptr->colormap )
2695 throwExceptionExplicit( OptionError,
2696 "Image does not contain a colormap");
2698 if ( index_ > imageptr->colors-1 )
2699 throwExceptionExplicit( OptionError,
2700 "Index out of range");
2702 return Magick::Color( (imageptr->colormap)[index_] );
2705 // Colormap size (number of colormap entries)
2706 void Magick::Image::colorMapSize ( const size_t entries_ )
2708 if (entries_ >MaxColormapSize )
2709 throwExceptionExplicit( OptionError,
2710 "Colormap entries must not exceed MaxColormapSize" );
2714 MagickCore::Image* imageptr = image();
2716 if( !imageptr->colormap )
2718 // Allocate colormap
2719 imageptr->colormap =
2720 static_cast<PixelPacket*>(AcquireMagickMemory(entries_*sizeof(PixelPacket)));
2721 imageptr->colors = 0;
2723 else if ( entries_ > imageptr->colors )
2725 // Re-allocate colormap
2726 imageptr->colormap=(PixelPacket *)
2727 ResizeMagickMemory(imageptr->colormap,(entries_)*sizeof(PixelPacket));
2730 // Initialize any new colormap entries as all black
2732 for( size_t i=imageptr->colors; i<(entries_-1); i++ )
2733 (imageptr->colormap)[i] = black;
2735 imageptr->colors = entries_;
2737 size_t Magick::Image::colorMapSize ( void )
2739 const MagickCore::Image* imageptr = constImage();
2741 if ( !imageptr->colormap )
2742 throwExceptionExplicit( OptionError,
2743 "Image does not contain a colormap");
2745 return imageptr->colors;
2749 void Magick::Image::colorSpace( const ColorspaceType colorSpace_ )
2752 if ( image()->colorspace == colorSpace_ )
2757 if ( colorSpace_ != RGBColorspace &&
2758 colorSpace_ != sRGBColorspace &&
2759 colorSpace_ != TransparentColorspace &&
2760 colorSpace_ != GRAYColorspace )
2762 if (image()->colorspace != RGBColorspace &&
2763 image()->colorspace != sRGBColorspace &&
2764 image()->colorspace != TransparentColorspace &&
2765 image()->colorspace != GRAYColorspace)
2767 /* Transform to RGB colorspace as intermediate step */
2768 TransformRGBImage( image(), image()->colorspace );
2769 throwImageException();
2771 /* Transform to final non-RGB colorspace */
2772 RGBTransformImage( image(), colorSpace_ );
2773 throwImageException();
2777 if ( colorSpace_ == RGBColorspace ||
2778 colorSpace_ == sRGBColorspace ||
2779 colorSpace_ == TransparentColorspace ||
2780 colorSpace_ == GRAYColorspace )
2782 /* Transform to a RGB-type colorspace */
2783 TransformRGBImage( image(), image()->colorspace );
2784 throwImageException();
2788 Magick::ColorspaceType Magick::Image::colorSpace ( void ) const
2790 return constImage()->colorspace;
2793 // Set image colorspace type.
2794 void Magick::Image::colorspaceType( const ColorspaceType colorSpace_ )
2797 options()->colorspaceType( colorSpace_ );
2799 Magick::ColorspaceType Magick::Image::colorspaceType ( void ) const
2801 return constOptions()->colorspaceType();
2806 void Magick::Image::comment ( const std::string &comment_ )
2809 SetImageProperty( image(), "Comment", NULL );
2810 if ( comment_.length() > 0 )
2811 SetImageProperty( image(), "Comment", comment_.c_str() );
2812 throwImageException();
2814 std::string Magick::Image::comment ( void ) const
2816 const char *value = GetImageProperty( constImage(), "Comment" );
2819 return std::string( value );
2821 return std::string(); // Intentionally no exception
2824 // Composition operator to be used when composition is implicitly used
2825 // (such as for image flattening).
2826 void Magick::Image::compose (const CompositeOperator compose_)
2828 image()->compose=compose_;
2831 Magick::CompositeOperator Magick::Image::compose ( void ) const
2833 return constImage()->compose;
2836 // Compression algorithm
2837 void Magick::Image::compressType ( const CompressionType compressType_ )
2840 image()->compression = compressType_;
2841 options()->compressType( compressType_ );
2843 Magick::CompressionType Magick::Image::compressType ( void ) const
2845 return constImage()->compression;
2848 // Enable printing of debug messages from ImageMagick
2849 void Magick::Image::debug ( const bool flag_ )
2852 options()->debug( flag_ );
2854 bool Magick::Image::debug ( void ) const
2856 return constOptions()->debug();
2859 // Tagged image format define (set/access coder-specific option) The
2860 // magick_ option specifies the coder the define applies to. The key_
2861 // option provides the key specific to that coder. The value_ option
2862 // provides the value to set (if any). See the defineSet() method if the
2863 // key must be removed entirely.
2864 void Magick::Image::defineValue ( const std::string &magick_,
2865 const std::string &key_,
2866 const std::string &value_ )
2869 std::string format = magick_ + ":" + key_;
2870 std::string option = value_;
2871 (void) SetImageOption ( imageInfo(), format.c_str(), option.c_str() );
2873 std::string Magick::Image::defineValue ( const std::string &magick_,
2874 const std::string &key_ ) const
2876 std::string definition = magick_ + ":" + key_;
2877 const char *option =
2878 GetImageOption ( constImageInfo(), definition.c_str() );
2880 return std::string( option );
2881 return std::string( );
2884 // Tagged image format define. Similar to the defineValue() method
2885 // except that passing the flag_ value 'true' creates a value-less
2886 // define with that format and key. Passing the flag_ value 'false'
2887 // removes any existing matching definition. The method returns 'true'
2888 // if a matching key exists, and 'false' if no matching key exists.
2889 void Magick::Image::defineSet ( const std::string &magick_,
2890 const std::string &key_,
2894 std::string definition = magick_ + ":" + key_;
2897 (void) SetImageOption ( imageInfo(), definition.c_str(), "" );
2901 DeleteImageOption( imageInfo(), definition.c_str() );
2904 bool Magick::Image::defineSet ( const std::string &magick_,
2905 const std::string &key_ ) const
2907 std::string key = magick_ + ":" + key_;
2908 const char *option =
2909 GetImageOption ( constImageInfo(), key.c_str() );
2916 void Magick::Image::density ( const Geometry &density_ )
2919 options()->density( density_ );
2920 if ( density_.isValid() )
2922 image()->x_resolution = density_.width();
2923 if ( density_.height() != 0 )
2925 image()->y_resolution = density_.height();
2929 image()->y_resolution = density_.width();
2935 image()->x_resolution = 0;
2936 image()->y_resolution = 0;
2939 Magick::Geometry Magick::Image::density ( void ) const
2943 ssize_t x_resolution=72;
2944 ssize_t y_resolution=72;
2946 if (constImage()->x_resolution > 0.0)
2947 x_resolution=static_cast<ssize_t>(constImage()->x_resolution + 0.5);
2949 if (constImage()->y_resolution > 0.0)
2950 y_resolution=static_cast<ssize_t>(constImage()->y_resolution + 0.5);
2952 return Geometry(x_resolution,y_resolution);
2955 return constOptions()->density( );
2958 // Image depth (bits allocated to red/green/blue components)
2959 void Magick::Image::depth ( const size_t depth_ )
2961 size_t depth = depth_;
2963 if (depth > MAGICKCORE_QUANTUM_DEPTH)
2964 depth=MAGICKCORE_QUANTUM_DEPTH;
2967 image()->depth=depth;
2968 options()->depth( depth );
2970 size_t Magick::Image::depth ( void ) const
2972 return constImage()->depth;
2975 std::string Magick::Image::directory ( void ) const
2977 if ( constImage()->directory )
2978 return std::string( constImage()->directory );
2980 throwExceptionExplicit( CorruptImageWarning,
2981 "Image does not contain a directory");
2983 return std::string();
2986 // Endianness (little like Intel or big like SPARC) for image
2987 // formats which support endian-specific options.
2988 void Magick::Image::endian ( const Magick::EndianType endian_ )
2991 options()->endian( endian_ );
2992 image()->endian = endian_;
2994 Magick::EndianType Magick::Image::endian ( void ) const
2996 return constImage()->endian;
2999 // EXIF profile (BLOB)
3000 void Magick::Image::exifProfile( const Magick::Blob &exifProfile_ )
3003 if ( exifProfile_.data() != 0 )
3005 StringInfo * exif_profile = AcquireStringInfo( exifProfile_.length() );
3006 SetStringInfoDatum(exif_profile ,(unsigned char *) exifProfile_.data());
3007 (void) SetImageProfile( image(), "exif", exif_profile);
3008 exif_profile =DestroyStringInfo( exif_profile );
3011 Magick::Blob Magick::Image::exifProfile( void ) const
3013 const StringInfo * exif_profile = GetImageProfile( constImage(), "exif" );
3014 if ( exif_profile == (StringInfo *) NULL)
3015 return Blob( 0, 0 );
3016 return Blob(GetStringInfoDatum(exif_profile),GetStringInfoLength(exif_profile));
3020 void Magick::Image::fileName ( const std::string &fileName_ )
3024 fileName_.copy( image()->filename,
3025 sizeof(image()->filename) - 1 );
3026 image()->filename[ fileName_.length() ] = 0; // Null terminate
3028 options()->fileName( fileName_ );
3031 std::string Magick::Image::fileName ( void ) const
3033 return constOptions()->fileName( );
3037 off_t Magick::Image::fileSize ( void ) const
3039 return (off_t) GetBlobSize( constImage() );
3042 // Color to use when drawing inside an object
3043 void Magick::Image::fillColor ( const Magick::Color &fillColor_ )
3046 options()->fillColor(fillColor_);
3048 Magick::Color Magick::Image::fillColor ( void ) const
3050 return constOptions()->fillColor();
3053 // Rule to use when filling drawn objects
3054 void Magick::Image::fillRule ( const Magick::FillRule &fillRule_ )
3057 options()->fillRule(fillRule_);
3059 Magick::FillRule Magick::Image::fillRule ( void ) const
3061 return constOptions()->fillRule();
3064 // Pattern to use while filling drawn objects.
3065 void Magick::Image::fillPattern ( const Image &fillPattern_ )
3068 if(fillPattern_.isValid())
3069 options()->fillPattern( fillPattern_.constImage() );
3071 options()->fillPattern( static_cast<MagickCore::Image*>(NULL) );
3073 Magick::Image Magick::Image::fillPattern ( void ) const
3075 // FIXME: This is inordinately innefficient
3078 const MagickCore::Image* tmpTexture = constOptions()->fillPattern( );
3082 ExceptionInfo exceptionInfo;
3083 GetExceptionInfo( &exceptionInfo );
3084 MagickCore::Image* image =
3085 CloneImage( tmpTexture,
3088 MagickTrue, // orphan
3090 texture.replaceImage( image );
3091 throwException( exceptionInfo );
3092 (void) DestroyExceptionInfo( &exceptionInfo );
3097 // Filter used by zoom
3098 void Magick::Image::filterType ( const Magick::FilterTypes filterType_ )
3101 image()->filter = filterType_;
3103 Magick::FilterTypes Magick::Image::filterType ( void ) const
3105 return constImage()->filter;
3109 void Magick::Image::font ( const std::string &font_ )
3112 options()->font( font_ );
3114 std::string Magick::Image::font ( void ) const
3116 return constOptions()->font( );
3120 void Magick::Image::fontPointsize ( const double pointSize_ )
3123 options()->fontPointsize( pointSize_ );
3125 double Magick::Image::fontPointsize ( void ) const
3127 return constOptions()->fontPointsize( );
3130 // Font type metrics
3131 void Magick::Image::fontTypeMetrics( const std::string &text_,
3132 TypeMetric *metrics )
3134 DrawInfo *drawInfo = options()->drawInfo();
3135 drawInfo->text = const_cast<char *>(text_.c_str());
3136 ExceptionInfo exceptionInfo;
3137 GetExceptionInfo( &exceptionInfo );
3138 GetTypeMetrics( image(), drawInfo, &(metrics->_typeMetric), &exceptionInfo );
3140 throwException( exceptionInfo );
3141 (void) DestroyExceptionInfo( &exceptionInfo );
3144 // Image format string
3145 std::string Magick::Image::format ( void ) const
3147 ExceptionInfo exceptionInfo;
3148 GetExceptionInfo( &exceptionInfo );
3149 const MagickInfo * magick_info
3150 = GetMagickInfo( constImage()->magick, &exceptionInfo);
3151 throwException( exceptionInfo );
3152 (void) DestroyExceptionInfo( &exceptionInfo );
3154 if (( magick_info != 0 ) &&
3155 ( *magick_info->description != '\0' ))
3156 return std::string(magick_info->description);
3158 throwExceptionExplicit( CorruptImageWarning,
3159 "Unrecognized image magick type" );
3160 return std::string();
3164 double Magick::Image::gamma ( void ) const
3166 return constImage()->gamma;
3169 Magick::Geometry Magick::Image::geometry ( void ) const
3171 if ( constImage()->geometry )
3173 return Geometry(constImage()->geometry);
3176 throwExceptionExplicit( OptionWarning,
3177 "Image does not contain a geometry");
3182 void Magick::Image::gifDisposeMethod ( const size_t disposeMethod_ )
3185 image()->dispose = (DisposeType) disposeMethod_;
3187 size_t Magick::Image::gifDisposeMethod ( void ) const
3189 // FIXME: It would be better to return an enumeration
3190 return constImage()->dispose;
3193 // ICC ICM color profile (BLOB)
3194 void Magick::Image::iccColorProfile( const Magick::Blob &colorProfile_ )
3196 profile("icm",colorProfile_);
3198 Magick::Blob Magick::Image::iccColorProfile( void ) const
3200 const StringInfo * color_profile = GetImageProfile( constImage(), "icc" );
3201 if ( color_profile == (StringInfo *) NULL)
3202 return Blob( 0, 0 );
3203 return Blob( GetStringInfoDatum(color_profile), GetStringInfoLength(color_profile) );
3206 void Magick::Image::interlaceType ( const Magick::InterlaceType interlace_ )
3209 image()->interlace = interlace_;
3210 options()->interlaceType ( interlace_ );
3212 Magick::InterlaceType Magick::Image::interlaceType ( void ) const
3214 return constImage()->interlace;
3217 // IPTC profile (BLOB)
3218 void Magick::Image::iptcProfile( const Magick::Blob &iptcProfile_ )
3221 if ( iptcProfile_.data() != 0 )
3223 StringInfo * iptc_profile = AcquireStringInfo( iptcProfile_.length() );
3224 SetStringInfoDatum(iptc_profile ,(unsigned char *) iptcProfile_.data());
3225 (void) SetImageProfile( image(), "iptc", iptc_profile);
3226 iptc_profile =DestroyStringInfo( iptc_profile );
3229 Magick::Blob Magick::Image::iptcProfile( void ) const
3231 const StringInfo * iptc_profile = GetImageProfile( constImage(), "iptc" );
3232 if ( iptc_profile == (StringInfo *) NULL)
3233 return Blob( 0, 0 );
3234 return Blob( GetStringInfoDatum(iptc_profile), GetStringInfoLength(iptc_profile));
3237 // Does object contain valid image?
3238 void Magick::Image::isValid ( const bool isValid_ )
3243 _imgRef = new ImageRef;
3245 else if ( !isValid() )
3247 // Construct with single-pixel black image to make
3248 // image valid. This is an obvious hack.
3249 size( Geometry(1,1) );
3250 read( "xc:#000000" );
3254 bool Magick::Image::isValid ( void ) const
3256 if ( rows() && columns() )
3263 void Magick::Image::label ( const std::string &label_ )
3266 SetImageProperty ( image(), "Label", NULL );
3267 if ( label_.length() > 0 )
3268 SetImageProperty ( image(), "Label", label_.c_str() );
3269 throwImageException();
3271 std::string Magick::Image::label ( void ) const
3273 const char *value = GetImageProperty( constImage(), "Label" );
3276 return std::string( value );
3278 return std::string();
3281 void Magick::Image::magick ( const std::string &magick_ )
3285 magick_.copy( image()->magick,
3286 sizeof(image()->magick) - 1 );
3287 image()->magick[ magick_.length() ] = 0;
3289 options()->magick( magick_ );
3291 std::string Magick::Image::magick ( void ) const
3293 if ( *(constImage()->magick) != '\0' )
3294 return std::string(constImage()->magick);
3296 return constOptions()->magick( );
3299 void Magick::Image::matte ( const bool matteFlag_ )
3303 // If matte channel is requested, but image doesn't already have a
3304 // matte channel, then create an opaque matte channel. Likewise, if
3305 // the image already has a matte channel but a matte channel is not
3306 // desired, then set the matte channel to opaque.
3307 if ((matteFlag_ && !constImage()->matte) ||
3308 (constImage()->matte && !matteFlag_))
3309 SetImageOpacity(image(),OpaqueAlpha);
3311 image()->matte = (MagickBooleanType) matteFlag_;
3313 bool Magick::Image::matte ( void ) const
3315 if ( constImage()->matte )
3321 void Magick::Image::matteColor ( const Color &matteColor_ )
3325 if ( matteColor_.isValid() )
3327 image()->matte_color = matteColor_;
3328 options()->matteColor( matteColor_ );
3332 // Set to default matte color
3333 Color tmpColor( "#BDBDBD" );
3334 image()->matte_color = tmpColor;
3335 options()->matteColor( tmpColor );
3338 Magick::Color Magick::Image::matteColor ( void ) const
3340 return Color( constImage()->matte_color.red,
3341 constImage()->matte_color.green,
3342 constImage()->matte_color.blue );
3345 double Magick::Image::meanErrorPerPixel ( void ) const
3347 return(constImage()->error.mean_error_per_pixel);
3350 // Image modulus depth (minimum number of bits required to support
3351 // red/green/blue components without loss of accuracy)
3352 void Magick::Image::modulusDepth ( const size_t depth_ )
3355 SetImageDepth( image(), depth_ );
3356 options()->depth( depth_ );
3358 size_t Magick::Image::modulusDepth ( void ) const
3360 ExceptionInfo exceptionInfo;
3361 GetExceptionInfo( &exceptionInfo );
3362 size_t depth=GetImageDepth( constImage(), &exceptionInfo );
3363 throwException( exceptionInfo );
3364 (void) DestroyExceptionInfo( &exceptionInfo );
3368 void Magick::Image::monochrome ( const bool monochromeFlag_ )
3371 options()->monochrome( monochromeFlag_ );
3373 bool Magick::Image::monochrome ( void ) const
3375 return constOptions()->monochrome( );
3378 Magick::Geometry Magick::Image::montageGeometry ( void ) const
3380 if ( constImage()->montage )
3381 return Magick::Geometry(constImage()->montage);
3383 throwExceptionExplicit( CorruptImageWarning,
3384 "Image does not contain a montage" );
3386 return Magick::Geometry();
3389 double Magick::Image::normalizedMaxError ( void ) const
3391 return(constImage()->error.normalized_maximum_error);
3394 double Magick::Image::normalizedMeanError ( void ) const
3396 return constImage()->error.normalized_mean_error;
3399 // Image orientation
3400 void Magick::Image::orientation ( const Magick::OrientationType orientation_ )
3403 image()->orientation = orientation_;
3405 Magick::OrientationType Magick::Image::orientation ( void ) const
3407 return constImage()->orientation;
3410 void Magick::Image::penColor ( const Color &penColor_ )
3413 options()->fillColor(penColor_);
3414 options()->strokeColor(penColor_);
3416 Magick::Color Magick::Image::penColor ( void ) const
3418 return constOptions()->fillColor();
3421 void Magick::Image::penTexture ( const Image &penTexture_ )
3424 if(penTexture_.isValid())
3425 options()->fillPattern( penTexture_.constImage() );
3427 options()->fillPattern( static_cast<MagickCore::Image*>(NULL) );
3430 Magick::Image Magick::Image::penTexture ( void ) const
3432 // FIXME: This is inordinately innefficient
3435 const MagickCore::Image* tmpTexture = constOptions()->fillPattern( );
3439 ExceptionInfo exceptionInfo;
3440 GetExceptionInfo( &exceptionInfo );
3441 MagickCore::Image* image =
3442 CloneImage( tmpTexture,
3445 MagickTrue, // orphan
3447 texture.replaceImage( image );
3448 throwException( exceptionInfo );
3449 (void) DestroyExceptionInfo( &exceptionInfo );
3454 // Set the color of a pixel.
3455 void Magick::Image::pixelColor ( const ssize_t x_, const ssize_t y_,
3456 const Color &color_ )
3458 // Test arguments to ensure they are within the image.
3459 if ( y_ > (ssize_t) rows() || x_ > (ssize_t) columns() )
3460 throwExceptionExplicit( OptionError,
3461 "Access outside of image boundary" );
3465 // Set image to DirectClass
3466 classType( DirectClass );
3469 Pixels pixels(*this);
3471 Quantum *pixel = pixels.get(x_, y_, 1, 1 );
3472 PixelPacket packet = color_;
3473 MagickCore::SetPixelPacket(constImage(),&packet,pixel);
3474 // Tell ImageMagick that pixels have been updated
3480 // Get the color of a pixel
3481 Magick::Color Magick::Image::pixelColor ( const ssize_t x_,
3482 const ssize_t y_ ) const
3484 ClassType storage_class;
3485 storage_class = classType();
3487 const Quantum* pixel = getConstPixels( x_, y_, 1, 1 );
3491 MagickCore::GetPixelPacket(constImage(),pixel,&packet);
3492 return Color( packet );
3495 return Color(); // invalid
3498 // Preferred size and location of an image canvas.
3499 void Magick::Image::page ( const Magick::Geometry &pageSize_ )
3502 options()->page( pageSize_ );
3503 image()->page = pageSize_;
3505 Magick::Geometry Magick::Image::page ( void ) const
3507 return Geometry( constImage()->page.width,
3508 constImage()->page.height,
3509 AbsoluteValue(constImage()->page.x),
3510 AbsoluteValue(constImage()->page.y),
3511 constImage()->page.x < 0 ? true : false,
3512 constImage()->page.y < 0 ? true : false);
3515 // Add a named profile to an image or remove a named profile by
3516 // passing an empty Blob (use default Blob constructor).
3518 // "*", "8BIM", "ICM", "IPTC", or a generic profile name.
3519 void Magick::Image::profile( const std::string name_,
3520 const Magick::Blob &profile_ )
3523 ssize_t result = ProfileImage( image(), name_.c_str(),
3524 (unsigned char *)profile_.data(),
3525 profile_.length(), MagickTrue);
3528 throwImageException();
3531 // Retrieve a named profile from the image.
3533 // "8BIM", "8BIMTEXT", "APP1", "APP1JPEG", "ICC", "ICM", & "IPTC" or
3534 // an existing generic profile name.
3535 Magick::Blob Magick::Image::profile( const std::string name_ ) const
3537 const MagickCore::Image* image = constImage();
3539 const StringInfo * profile = GetImageProfile( image, name_.c_str() );
3541 if ( profile != (StringInfo *) NULL)
3542 return Blob( (void*) GetStringInfoDatum(profile), GetStringInfoLength(profile));
3545 Image temp_image = *this;
3546 temp_image.write( &blob, name_ );
3550 void Magick::Image::quality ( const size_t quality_ )
3553 image()->quality = quality_;
3554 options()->quality( quality_ );
3556 size_t Magick::Image::quality ( void ) const
3558 return constImage()->quality;
3561 void Magick::Image::quantizeColors ( const size_t colors_ )
3564 options()->quantizeColors( colors_ );
3566 size_t Magick::Image::quantizeColors ( void ) const
3568 return constOptions()->quantizeColors( );
3571 void Magick::Image::quantizeColorSpace
3572 ( const Magick::ColorspaceType colorSpace_ )
3575 options()->quantizeColorSpace( colorSpace_ );
3577 Magick::ColorspaceType Magick::Image::quantizeColorSpace ( void ) const
3579 return constOptions()->quantizeColorSpace( );
3582 void Magick::Image::quantizeDither ( const bool ditherFlag_ )
3585 options()->quantizeDither( ditherFlag_ );
3587 bool Magick::Image::quantizeDither ( void ) const
3589 return constOptions()->quantizeDither( );
3592 void Magick::Image::quantizeTreeDepth ( const size_t treeDepth_ )
3595 options()->quantizeTreeDepth( treeDepth_ );
3597 size_t Magick::Image::quantizeTreeDepth ( void ) const
3599 return constOptions()->quantizeTreeDepth( );
3602 void Magick::Image::renderingIntent
3603 ( const Magick::RenderingIntent renderingIntent_ )
3606 image()->rendering_intent = renderingIntent_;
3608 Magick::RenderingIntent Magick::Image::renderingIntent ( void ) const
3610 return static_cast<Magick::RenderingIntent>(constImage()->rendering_intent);
3613 void Magick::Image::resolutionUnits
3614 ( const Magick::ResolutionType resolutionUnits_ )
3617 image()->units = resolutionUnits_;
3618 options()->resolutionUnits( resolutionUnits_ );
3620 Magick::ResolutionType Magick::Image::resolutionUnits ( void ) const
3622 return constOptions()->resolutionUnits( );
3625 void Magick::Image::scene ( const size_t scene_ )
3628 image()->scene = scene_;
3630 size_t Magick::Image::scene ( void ) const
3632 return constImage()->scene;
3635 std::string Magick::Image::signature ( const bool force_ ) const
3637 Lock( &_imgRef->_mutexLock );
3639 // Re-calculate image signature if necessary
3640 ExceptionInfo exceptionInfo;
3641 GetExceptionInfo( &exceptionInfo );
3643 !GetImageProperty(constImage(), "Signature") ||
3644 constImage()->taint )
3646 SignatureImage( const_cast<MagickCore::Image *>(constImage()), &exceptionInfo );
3649 throwException( exceptionInfo );
3650 (void) DestroyExceptionInfo( &exceptionInfo );
3651 const char *property = GetImageProperty(constImage(), "Signature");
3653 return std::string( property );
3656 void Magick::Image::size ( const Geometry &geometry_ )
3659 options()->size( geometry_ );
3660 image()->rows = geometry_.height();
3661 image()->columns = geometry_.width();
3663 Magick::Geometry Magick::Image::size ( void ) const
3665 return Magick::Geometry( constImage()->columns, constImage()->rows );
3669 void Magick::Image::splice( const Geometry &geometry_ )
3671 RectangleInfo spliceInfo = geometry_;
3672 ExceptionInfo exceptionInfo;
3673 GetExceptionInfo( &exceptionInfo );
3674 MagickCore::Image* newImage =
3675 SpliceImage( image(), &spliceInfo, &exceptionInfo);
3676 replaceImage( newImage );
3677 throwException( exceptionInfo );
3678 (void) DestroyExceptionInfo( &exceptionInfo );
3681 // Obtain image statistics. Statistics are normalized to the range of
3682 // 0.0 to 1.0 and are output to the specified ImageStatistics
3684 void Magick::Image::statistics ( ImageStatistics *statistics )
3690 ExceptionInfo exceptionInfo;
3691 GetExceptionInfo( &exceptionInfo );
3693 ChannelType channel_mask = SetPixelChannelMask( image(), RedChannel);
3694 (void) GetImageRange( image(),&minimum,&maximum,&exceptionInfo);
3695 statistics->red.minimum=minimum;
3696 statistics->red.maximum=maximum;
3697 (void) GetImageMean( image(),&statistics->red.mean,
3698 &statistics->red.standard_deviation,&exceptionInfo);
3699 (void) GetImageKurtosis( image(),&statistics->red.kurtosis,
3700 &statistics->red.skewness,&exceptionInfo);
3701 (void) SetPixelChannelMap( image(), channel_mask );
3703 channel_mask = SetPixelChannelMask( image(), GreenChannel);
3704 (void) GetImageRange( image(),&minimum,&maximum,&exceptionInfo);
3705 statistics->green.minimum=minimum;
3706 statistics->green.maximum=maximum;
3707 (void) GetImageMean( image(),&statistics->green.mean,
3708 &statistics->green.standard_deviation,&exceptionInfo);
3709 (void) GetImageKurtosis( image(),&statistics->green.kurtosis,
3710 &statistics->green.skewness,&exceptionInfo);
3711 (void) SetPixelChannelMap( image(), channel_mask );
3713 channel_mask = SetPixelChannelMask( image(), GreenChannel);
3714 (void) GetImageRange( image(),&minimum,&maximum,&exceptionInfo);
3715 statistics->blue.minimum=minimum;
3716 statistics->blue.maximum=maximum;
3717 (void) GetImageMean( image(),&statistics->blue.mean,
3718 &statistics->blue.standard_deviation,&exceptionInfo);
3719 (void) GetImageKurtosis( image(),&statistics->blue.kurtosis,
3720 &statistics->blue.skewness,&exceptionInfo);
3721 (void) SetPixelChannelMap( image(), channel_mask );
3723 channel_mask = SetPixelChannelMask( image(), AlphaChannel);
3724 (void) GetImageRange( image(),&minimum,&maximum,&exceptionInfo);
3725 statistics->alpha.minimum=minimum;
3726 statistics->alpha.maximum=maximum;
3727 (void) GetImageMean( image(),&statistics->alpha.mean,
3728 &statistics->alpha.standard_deviation,&exceptionInfo);
3729 (void) GetImageKurtosis( image(),&statistics->alpha.kurtosis,
3730 &statistics->alpha.skewness,&exceptionInfo);
3731 (void) SetPixelChannelMap( image(), channel_mask );
3733 throwException( exceptionInfo );
3734 (void) DestroyExceptionInfo( &exceptionInfo );
3737 // Strip strips an image of all profiles and comments.
3738 void Magick::Image::strip ( void )
3741 StripImage( image() );
3742 throwImageException();
3745 // enabled/disable stroke anti-aliasing
3746 void Magick::Image::strokeAntiAlias ( const bool flag_ )
3749 options()->strokeAntiAlias(flag_);
3751 bool Magick::Image::strokeAntiAlias ( void ) const
3753 return constOptions()->strokeAntiAlias();
3756 // Color to use when drawing object outlines
3757 void Magick::Image::strokeColor ( const Magick::Color &strokeColor_ )
3760 options()->strokeColor(strokeColor_);
3762 Magick::Color Magick::Image::strokeColor ( void ) const
3764 return constOptions()->strokeColor();
3767 // dash pattern for drawing vector objects (default one)
3768 void Magick::Image::strokeDashArray ( const double* strokeDashArray_ )
3771 options()->strokeDashArray( strokeDashArray_ );
3774 const double* Magick::Image::strokeDashArray ( void ) const
3776 return constOptions()->strokeDashArray( );
3779 // dash offset for drawing vector objects (default one)
3780 void Magick::Image::strokeDashOffset ( const double strokeDashOffset_ )
3783 options()->strokeDashOffset( strokeDashOffset_ );
3786 double Magick::Image::strokeDashOffset ( void ) const
3788 return constOptions()->strokeDashOffset( );
3791 // Specify the shape to be used at the end of open subpaths when they
3792 // are stroked. Values of LineCap are UndefinedCap, ButtCap, RoundCap,
3794 void Magick::Image::strokeLineCap ( const Magick::LineCap lineCap_ )
3797 options()->strokeLineCap( lineCap_ );
3799 Magick::LineCap Magick::Image::strokeLineCap ( void ) const
3801 return constOptions()->strokeLineCap( );
3804 // Specify the shape to be used at the corners of paths (or other
3805 // vector shapes) when they are stroked. Values of LineJoin are
3806 // UndefinedJoin, MiterJoin, RoundJoin, and BevelJoin.
3807 void Magick::Image::strokeLineJoin ( const Magick::LineJoin lineJoin_ )
3810 options()->strokeLineJoin( lineJoin_ );
3812 Magick::LineJoin Magick::Image::strokeLineJoin ( void ) const
3814 return constOptions()->strokeLineJoin( );
3817 // Specify miter limit. When two line segments meet at a sharp angle
3818 // and miter joins have been specified for 'lineJoin', it is possible
3819 // for the miter to extend far beyond the thickness of the line
3820 // stroking the path. The miterLimit' imposes a limit on the ratio of
3821 // the miter length to the 'lineWidth'. The default value of this
3823 void Magick::Image::strokeMiterLimit ( const size_t strokeMiterLimit_ )
3826 options()->strokeMiterLimit( strokeMiterLimit_ );
3828 size_t Magick::Image::strokeMiterLimit ( void ) const
3830 return constOptions()->strokeMiterLimit( );
3833 // Pattern to use while stroking drawn objects.
3834 void Magick::Image::strokePattern ( const Image &strokePattern_ )
3837 if(strokePattern_.isValid())
3838 options()->strokePattern( strokePattern_.constImage() );
3840 options()->strokePattern( static_cast<MagickCore::Image*>(NULL) );
3842 Magick::Image Magick::Image::strokePattern ( void ) const
3844 // FIXME: This is inordinately innefficient
3847 const MagickCore::Image* tmpTexture = constOptions()->strokePattern( );
3851 ExceptionInfo exceptionInfo;
3852 GetExceptionInfo( &exceptionInfo );
3853 MagickCore::Image* image =
3854 CloneImage( tmpTexture,
3857 MagickTrue, // orphan
3859 throwException( exceptionInfo );
3860 (void) DestroyExceptionInfo( &exceptionInfo );
3861 texture.replaceImage( image );
3866 // Stroke width for drawing lines, circles, ellipses, etc.
3867 void Magick::Image::strokeWidth ( const double strokeWidth_ )
3870 options()->strokeWidth( strokeWidth_ );
3872 double Magick::Image::strokeWidth ( void ) const
3874 return constOptions()->strokeWidth( );
3877 void Magick::Image::subImage ( const size_t subImage_ )
3880 options()->subImage( subImage_ );
3882 size_t Magick::Image::subImage ( void ) const
3884 return constOptions()->subImage( );
3887 void Magick::Image::subRange ( const size_t subRange_ )
3890 options()->subRange( subRange_ );
3892 size_t Magick::Image::subRange ( void ) const
3894 return constOptions()->subRange( );
3897 // Annotation text encoding (e.g. "UTF-16")
3898 void Magick::Image::textEncoding ( const std::string &encoding_ )
3901 options()->textEncoding( encoding_ );
3903 std::string Magick::Image::textEncoding ( void ) const
3905 return constOptions()->textEncoding( );
3908 size_t Magick::Image::totalColors ( void )
3910 ExceptionInfo exceptionInfo;
3911 GetExceptionInfo( &exceptionInfo );
3912 size_t colors = GetNumberColors( image(), 0, &exceptionInfo);
3913 throwException( exceptionInfo );
3914 (void) DestroyExceptionInfo( &exceptionInfo );
3918 // Origin of coordinate system to use when annotating with text or drawing
3919 void Magick::Image::transformOrigin ( const double x_, const double y_ )
3922 options()->transformOrigin( x_, y_ );
3925 // Rotation to use when annotating with text or drawing
3926 void Magick::Image::transformRotation ( const double angle_ )
3929 options()->transformRotation( angle_ );
3932 // Reset transformation parameters to default
3933 void Magick::Image::transformReset ( void )
3936 options()->transformReset();
3939 // Scale to use when annotating with text or drawing
3940 void Magick::Image::transformScale ( const double sx_, const double sy_ )
3943 options()->transformScale( sx_, sy_ );
3946 // Skew to use in X axis when annotating with text or drawing
3947 void Magick::Image::transformSkewX ( const double skewx_ )
3950 options()->transformSkewX( skewx_ );
3953 // Skew to use in Y axis when annotating with text or drawing
3954 void Magick::Image::transformSkewY ( const double skewy_ )
3957 options()->transformSkewY( skewy_ );
3960 // Image representation type
3961 Magick::ImageType Magick::Image::type ( void ) const
3964 ExceptionInfo exceptionInfo;
3965 GetExceptionInfo( &exceptionInfo );
3966 ImageType image_type = constOptions()->type();
3967 if ( image_type == UndefinedType )
3968 image_type= GetImageType( constImage(), &exceptionInfo);
3969 throwException( exceptionInfo );
3970 (void) DestroyExceptionInfo( &exceptionInfo );
3973 void Magick::Image::type ( const Magick::ImageType type_)
3975 ExceptionInfo exceptionInfo;
3976 GetExceptionInfo( &exceptionInfo );
3978 options()->type( type_ );
3979 SetImageType( image(), type_, &exceptionInfo );
3980 throwException( exceptionInfo );
3981 (void) DestroyExceptionInfo( &exceptionInfo );
3984 void Magick::Image::verbose ( const bool verboseFlag_ )
3987 options()->verbose( verboseFlag_ );
3989 bool Magick::Image::verbose ( void ) const
3991 return constOptions()->verbose( );
3994 void Magick::Image::view ( const std::string &view_ )
3997 options()->view( view_ );
3999 std::string Magick::Image::view ( void ) const
4001 return constOptions()->view( );
4004 // Virtual pixel method
4005 void Magick::Image::virtualPixelMethod ( const VirtualPixelMethod virtual_pixel_method_ )
4008 SetImageVirtualPixelMethod( image(), virtual_pixel_method_ );
4009 options()->virtualPixelMethod( virtual_pixel_method_ );
4011 Magick::VirtualPixelMethod Magick::Image::virtualPixelMethod ( void ) const
4013 return GetImageVirtualPixelMethod( constImage() );
4016 void Magick::Image::x11Display ( const std::string &display_ )
4019 options()->x11Display( display_ );
4021 std::string Magick::Image::x11Display ( void ) const
4023 return constOptions()->x11Display( );
4026 double Magick::Image::xResolution ( void ) const
4028 return constImage()->x_resolution;
4030 double Magick::Image::yResolution ( void ) const
4032 return constImage()->y_resolution;
4036 Magick::Image::Image( const Image & image_ )
4037 : _imgRef(image_._imgRef)
4039 Lock( &_imgRef->_mutexLock );
4041 // Increase reference count
4042 ++_imgRef->_refCount;
4045 // Assignment operator
4046 Magick::Image& Magick::Image::operator=( const Magick::Image &image_ )
4048 if( this != &image_ )
4051 Lock( &image_._imgRef->_mutexLock );
4052 ++image_._imgRef->_refCount;
4055 bool doDelete = false;
4057 Lock( &_imgRef->_mutexLock );
4058 if ( --_imgRef->_refCount == 0 )
4064 // Delete old image reference with associated image and options.
4068 // Use new image reference
4069 _imgRef = image_._imgRef;
4075 //////////////////////////////////////////////////////////////////////
4077 // Low-level Pixel Access Routines
4079 // Also see the Pixels class, which provides support for multiple
4080 // cache views. The low-level pixel access routines in the Image
4081 // class are provided in order to support backward compatability.
4083 //////////////////////////////////////////////////////////////////////
4085 // Transfers read-only pixels from the image to the pixel cache as
4086 // defined by the specified region
4087 const Magick::Quantum* Magick::Image::getConstPixels
4088 ( const ssize_t x_, const ssize_t y_,
4089 const size_t columns_,
4090 const size_t rows_ ) const
4092 ExceptionInfo exceptionInfo;
4093 GetExceptionInfo( &exceptionInfo );
4094 const Quantum* p = (*GetVirtualPixels)( constImage(),
4098 throwException( exceptionInfo );
4099 (void) DestroyExceptionInfo( &exceptionInfo );
4103 // Obtain read-only pixel associated pixels channels
4104 const void* Magick::Image::getConstMetacontent ( void ) const
4106 const void* result = GetVirtualMetacontent( constImage() );
4109 throwImageException();
4114 // Obtain image pixel associated pixels channels
4115 void* Magick::Image::getMetacontent ( void )
4117 void* result = GetAuthenticMetacontent( image() );
4120 throwImageException();
4125 // Transfers pixels from the image to the pixel cache as defined
4126 // by the specified region. Modified pixels may be subsequently
4127 // transferred back to the image via syncPixels.
4128 Magick::Quantum* Magick::Image::getPixels ( const ssize_t x_, const ssize_t y_,
4129 const size_t columns_,
4130 const size_t rows_ )
4133 ExceptionInfo exceptionInfo;
4134 GetExceptionInfo( &exceptionInfo );
4135 Quantum* result = (*GetAuthenticPixels)( image(),
4137 columns_, rows_, &exceptionInfo );
4138 throwException( exceptionInfo );
4139 (void) DestroyExceptionInfo( &exceptionInfo );
4144 // Allocates a pixel cache region to store image pixels as defined
4145 // by the region rectangle. This area is subsequently transferred
4146 // from the pixel cache to the image via syncPixels.
4147 Magick::Quantum* Magick::Image::setPixels ( const ssize_t x_, const ssize_t y_,
4148 const size_t columns_,
4149 const size_t rows_ )
4152 ExceptionInfo exceptionInfo;
4153 GetExceptionInfo( &exceptionInfo );
4154 Quantum* result = (*QueueAuthenticPixels)( image(),
4156 columns_, rows_, &exceptionInfo );
4157 throwException( exceptionInfo );
4158 (void) DestroyExceptionInfo( &exceptionInfo );
4163 // Transfers the image cache pixels to the image.
4164 void Magick::Image::syncPixels ( void )
4166 ExceptionInfo exceptionInfo;
4167 GetExceptionInfo( &exceptionInfo );
4168 (*SyncAuthenticPixels)( image(), &exceptionInfo );
4169 throwException( exceptionInfo );
4170 (void) DestroyExceptionInfo( &exceptionInfo );
4173 // Transfers one or more pixel components from a buffer or file
4174 // into the image pixel cache of an image.
4175 // Used to support image decoders.
4176 void Magick::Image::readPixels ( const Magick::QuantumType quantum_,
4177 const unsigned char *source_ )
4182 quantum_info=AcquireQuantumInfo(imageInfo(),image());
4183 ExceptionInfo exceptionInfo;
4184 GetExceptionInfo( &exceptionInfo );
4185 ImportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
4186 quantum_,source_, &exceptionInfo);
4187 throwException( exceptionInfo );
4188 (void) DestroyExceptionInfo( &exceptionInfo );
4189 quantum_info=DestroyQuantumInfo(quantum_info);
4192 // Transfers one or more pixel components from the image pixel
4193 // cache to a buffer or file.
4194 // Used to support image encoders.
4195 void Magick::Image::writePixels ( const Magick::QuantumType quantum_,
4196 unsigned char *destination_ )
4201 quantum_info=AcquireQuantumInfo(imageInfo(),image());
4202 ExceptionInfo exceptionInfo;
4203 GetExceptionInfo( &exceptionInfo );
4204 ExportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
4205 quantum_,destination_, &exceptionInfo);
4206 quantum_info=DestroyQuantumInfo(quantum_info);
4207 throwException( exceptionInfo );
4208 (void) DestroyExceptionInfo( &exceptionInfo );
4211 /////////////////////////////////////////////////////////////////////
4213 // No end-user methods beyond this point
4215 /////////////////////////////////////////////////////////////////////
4219 // Construct using existing image and default options
4221 Magick::Image::Image ( MagickCore::Image* image_ )
4222 : _imgRef(new ImageRef( image_))
4226 // Get Magick::Options*
4227 Magick::Options* Magick::Image::options( void )
4229 return _imgRef->options();
4231 const Magick::Options* Magick::Image::constOptions( void ) const
4233 return _imgRef->options();
4236 // Get MagickCore::Image*
4237 MagickCore::Image*& Magick::Image::image( void )
4239 return _imgRef->image();
4241 const MagickCore::Image* Magick::Image::constImage( void ) const
4243 return _imgRef->image();
4247 MagickCore::ImageInfo* Magick::Image::imageInfo( void )
4249 return _imgRef->options()->imageInfo();
4251 const MagickCore::ImageInfo * Magick::Image::constImageInfo( void ) const
4253 return _imgRef->options()->imageInfo();
4256 // Get QuantizeInfo *
4257 MagickCore::QuantizeInfo* Magick::Image::quantizeInfo( void )
4259 return _imgRef->options()->quantizeInfo();
4261 const MagickCore::QuantizeInfo * Magick::Image::constQuantizeInfo( void ) const
4263 return _imgRef->options()->quantizeInfo();
4267 // Replace current image
4269 MagickCore::Image * Magick::Image::replaceImage
4270 ( MagickCore::Image* replacement_ )
4272 MagickCore::Image* image;
4275 image = replacement_;
4278 ExceptionInfo exceptionInfo;
4279 GetExceptionInfo( &exceptionInfo );
4280 image = AcquireImage(constImageInfo(), &exceptionInfo);
4281 throwException( exceptionInfo );
4282 (void) DestroyExceptionInfo( &exceptionInfo );
4286 Lock( &_imgRef->_mutexLock );
4288 if ( _imgRef->_refCount == 1 )
4290 // We own the image, just replace it, and de-register
4292 _imgRef->image(image);
4296 // We don't own the image, dereference and replace with copy
4297 --_imgRef->_refCount;
4298 _imgRef = new ImageRef( image, constOptions() );
4302 return _imgRef->_image;
4306 // Prepare to modify image or image options
4307 // Replace current image and options with copy if reference count > 1
4309 void Magick::Image::modifyImage( void )
4312 Lock( &_imgRef->_mutexLock );
4313 if ( _imgRef->_refCount == 1 )
4315 // De-register image and return
4321 ExceptionInfo exceptionInfo;
4322 GetExceptionInfo( &exceptionInfo );
4323 replaceImage( CloneImage( image(),
4326 MagickTrue, // orphan
4328 throwException( exceptionInfo );
4329 (void) DestroyExceptionInfo( &exceptionInfo );
4334 // Test for an ImageMagick reported error and throw exception if one
4335 // has been reported. Secretly resets image->exception back to default
4336 // state even though this method is const.
4338 void Magick::Image::throwImageException( void ) const
4340 // Throw C++ exception while resetting Image exception to default state
4341 throwException( const_cast<MagickCore::Image*>(constImage())->exception );
4344 // Register image with image registry or obtain registration id
4345 ssize_t Magick::Image::registerId( void )
4347 Lock( &_imgRef->_mutexLock );
4348 if( _imgRef->id() < 0 )
4350 char id[MaxTextExtent];
4351 ExceptionInfo exceptionInfo;
4352 GetExceptionInfo( &exceptionInfo );
4353 _imgRef->id(_imgRef->id()+1);
4354 sprintf(id,"%.20g\n",(double) _imgRef->id());
4355 SetImageRegistry(ImageRegistryType, id, image(), &exceptionInfo);
4356 throwException( exceptionInfo );
4357 (void) DestroyExceptionInfo( &exceptionInfo );
4359 return _imgRef->id();
4362 // Unregister image from image registry
4363 void Magick::Image::unregisterId( void )
4370 // Create a local wrapper around MagickCoreTerminus
4375 void MagickPlusPlusDestroyMagick(void);
4379 void Magick::MagickPlusPlusDestroyMagick(void)
4381 if (magick_initialized)
4383 magick_initialized=false;
4384 MagickCore::MagickCoreTerminus();
4388 // C library initialization routine
4389 void MagickPPExport Magick::InitializeMagick(const char *path_)
4391 MagickCore::MagickCoreGenesis(path_,MagickFalse);
4392 if (!magick_initialized)
4393 magick_initialized=true;
4397 // Cleanup class to ensure that ImageMagick singletons are destroyed
4398 // so as to avoid any resemblence to a memory leak (which seems to
4407 MagickCleanUp( void );
4408 ~MagickCleanUp( void );
4411 // The destructor for this object is invoked when the destructors for
4412 // static objects in this translation unit are invoked.
4413 static MagickCleanUp magickCleanUpGuard;
4416 Magick::MagickCleanUp::MagickCleanUp ( void )
4418 // Don't even think about invoking InitializeMagick here!
4421 Magick::MagickCleanUp::~MagickCleanUp ( void )
4423 MagickPlusPlusDestroyMagick();