11#define MAGICKCORE_IMPLEMENTATION 1
12#define MAGICK_PLUSPLUS_IMPLEMENTATION 1
14#include "Magick++/Include.h"
21#include "Magick++/Image.h"
22#include "Magick++/Functions.h"
23#include "Magick++/Pixels.h"
24#include "Magick++/Options.h"
25#include "Magick++/ImageRef.h"
29#define AbsoluteValue(x) ((x) < 0 ? -(x) : (x))
30#define MagickPI 3.14159265358979323846264338327950288419716939937510
31#define DegreesToRadians(x) (MagickPI*(x)/180.0)
32#define ThrowImageException ThrowPPException(quiet())
34MagickPPExport
const char *Magick::borderGeometryDefault=
"6x6+0+0";
35MagickPPExport
const char *Magick::frameGeometryDefault=
"25x25+6+6";
36MagickPPExport
const char *Magick::raiseGeometryDefault=
"6x6+0+0";
38MagickPPExport
int Magick::operator == (
const Magick::Image &left_,
42 return((left_.rows() == right_.rows()) &&
43 (left_.columns() == right_.columns()) &&
44 (left_.signature() == right_.signature()));
47MagickPPExport
int Magick::operator != (
const Magick::Image &left_,
50 return(!(left_ == right_));
53MagickPPExport
int Magick::operator > (
const Magick::Image &left_,
56 return(!(left_ < right_) && (left_ != right_));
59MagickPPExport
int Magick::operator < (
const Magick::Image &left_,
63 return((left_.rows() * left_.columns()) <
64 (right_.rows() * right_.columns()));
67MagickPPExport
int Magick::operator >= (
const Magick::Image &left_,
70 return((left_ > right_) || (left_ == right_));
73MagickPPExport
int Magick::operator <= (
const Magick::Image &left_,
76 return((left_ < right_) || ( left_ == right_));
79Magick::Image::Image(
void)
80 : _imgRef(new ImageRef)
84Magick::Image::Image(
const Blob &blob_)
85 : _imgRef(new ImageRef)
102Magick::Image::Image(
const Blob &blob_,
const Geometry &size_)
103 : _imgRef(new ImageRef)
120Magick::Image::Image(
const Blob &blob_,
const Geometry &size_,
122 : _imgRef(new ImageRef)
128 read(blob_,size_,depth_);
139Magick::Image::Image(
const Blob &blob_,
const Geometry &size_,
140 const size_t depth_,
const std::string &magick_)
141 : _imgRef(new ImageRef)
147 read(blob_,size_,depth_,magick_);
158Magick::Image::Image(
const Blob &blob_,
const Geometry &size_,
159 const std::string &magick_)
160 : _imgRef(new ImageRef)
166 read(blob_,size_,magick_);
177Magick::Image::Image(
const Geometry &size_,
const Color &color_)
178 : _imgRef(new ImageRef)
181 std::string imageSpec(
"xc:");
202Magick::Image::Image(
const Image &image_)
203 : _imgRef(image_._imgRef)
208Magick::Image::Image(
const Image &image_,
const Geometry &geometry_)
209 : _imgRef(new ImageRef)
221 image=CloneImage(image_.constImage(),geometry_.width(),geometry_.height(),
222 MagickTrue,exceptionInfo);
224 _imgRef->options(
new Options(*image_.constOptions()));
227 (void) CopyImagePixels(image,image_.constImage(),&geometry,&offset,
232Magick::Image::Image(
const size_t width_,
const size_t height_,
233 const std::string &map_,
const StorageType type_,
const void *pixels_)
234 : _imgRef(new ImageRef)
239 read(width_,height_,map_.c_str(),type_,pixels_);
250Magick::Image::Image(
const std::string &imageSpec_)
251 : _imgRef(new ImageRef)
268Magick::Image::~Image()
272 if (_imgRef->decrease() == 0)
286 image_._imgRef->increase();
287 if (_imgRef->decrease() == 0)
291 _imgRef=image_._imgRef;
296void Magick::Image::adjoin(
const bool flag_)
299 options()->adjoin(flag_);
302bool Magick::Image::adjoin(
void)
const
304 return(constOptions()->adjoin());
307void Magick::Image::alpha(
const bool alphaFlag_)
316 if (
bool(alphaFlag_) !=
bool(constImage()->alpha_trait))
317 SetImageAlpha(image(),OpaqueAlpha,exceptionInfo);
320 image()->alpha_trait=alphaFlag_ ? BlendPixelTrait : UndefinedPixelTrait;
323bool Magick::Image::alpha(
void)
const
325 if (constImage()->alpha_trait == BlendPixelTrait)
331void Magick::Image::matteColor(
const Color &matteColor_)
335 if (matteColor_.isValid())
337 image()->matte_color=matteColor_;
338 options()->matteColor(matteColor_);
343 Color tmpColor(
"#BDBDBD");
344 image()->matte_color=tmpColor;
345 options()->matteColor(tmpColor);
351 return(Color(constImage()->matte_color));
354void Magick::Image::animationDelay(
const size_t delay_)
357 image()->delay=delay_;
360size_t Magick::Image::animationDelay(
void)
const
362 return(constImage()->delay);
365void Magick::Image::animationIterations(
const size_t iterations_)
368 image()->iterations=iterations_;
371size_t Magick::Image::animationIterations(
void)
const
373 return(constImage()->iterations);
376void Magick::Image::backgroundColor(
const Color &backgroundColor_)
380 if (backgroundColor_.isValid())
381 image()->background_color=backgroundColor_;
383 image()->background_color=Color();
385 options()->backgroundColor(backgroundColor_);
390 return(constOptions()->backgroundColor());
393void Magick::Image::backgroundTexture(
const std::string &backgroundTexture_)
396 options()->backgroundTexture(backgroundTexture_);
399std::string Magick::Image::backgroundTexture(
void)
const
401 return(constOptions()->backgroundTexture());
404size_t Magick::Image::baseColumns(
void)
const
406 return(constImage()->magick_columns);
409std::string Magick::Image::baseFilename(
void)
const
411 return(std::string(constImage()->magick_filename));
414size_t Magick::Image::baseRows(
void)
const
416 return(constImage()->magick_rows);
419void Magick::Image::blackPointCompensation(
const bool flag_)
421 image()->black_point_compensation=(MagickBooleanType) flag_;
424bool Magick::Image::blackPointCompensation(
void)
const
426 return(
static_cast<bool>(constImage()->black_point_compensation));
429void Magick::Image::borderColor(
const Color &borderColor_)
433 if (borderColor_.isValid())
434 image()->border_color=borderColor_;
436 image()->border_color=Color();
438 options()->borderColor(borderColor_);
443 return(constOptions()->borderColor());
452 bbox=GetImageBoundingBox(constImage(),exceptionInfo);
454 return(Geometry(bbox));
457void Magick::Image::boxColor(
const Color &boxColor_)
460 options()->boxColor(boxColor_);
465 return(constOptions()->boxColor());
468void Magick::Image::channelDepth(
const ChannelType channel_,
473 GetAndSetPPChannelMask(channel_);
474 SetImageDepth(image(),depth_,exceptionInfo);
475 RestorePPChannelMask;
479size_t Magick::Image::channelDepth(
const ChannelType channel_)
485 GetAndSetPPChannelMask(channel_);
486 channel_depth=GetImageDepth(constImage(),exceptionInfo);
487 RestorePPChannelMask;
489 return(channel_depth);
492size_t Magick::Image::channels()
const
494 return(constImage()->number_channels);
497void Magick::Image::classType(
const ClassType class_)
499 if (classType() == PseudoClass && class_ == DirectClass)
505 SyncImage(image(),exceptionInfo);
507 image()->colormap=(PixelInfo *)RelinquishMagickMemory(image()->colormap);
508 image()->storage_class=
static_cast<MagickCore::ClassType
>(DirectClass);
512 if (classType() == DirectClass && class_ == PseudoClass)
516 quantizeColors(MaxColormapSize);
518 image()->storage_class=
static_cast<MagickCore::ClassType
>(PseudoClass);
522Magick::ClassType Magick::Image::classType(
void)
const
524 return static_cast<Magick::ClassType
>(constImage()->storage_class);
527void Magick::Image::colorFuzz(
const double fuzz_)
531 options()->colorFuzz(fuzz_);
534double Magick::Image::colorFuzz(
void)
const
536 return(constOptions()->colorFuzz());
539void Magick::Image::colorMapSize(
const size_t entries_)
541 if (entries_ >MaxColormapSize)
542 throwExceptionExplicit(MagickCore::OptionError,
543 "Colormap entries must not exceed MaxColormapSize");
547 (void) AcquireImageColormap(image(),entries_,exceptionInfo);
551size_t Magick::Image::colorMapSize(
void)
const
553 if (!constImage()->colormap)
554 throwExceptionExplicit(MagickCore::OptionError,
555 "Image does not contain a colormap");
557 return(constImage()->colors);
560void Magick::Image::colorSpace(
const ColorspaceType colorSpace_)
562 if (image()->colorspace == colorSpace_)
567 TransformImageColorspace(image(),colorSpace_,exceptionInfo);
571Magick::ColorspaceType Magick::Image::colorSpace(
void)
const
573 return (constImage()->colorspace);
576void Magick::Image::colorSpaceType(
const ColorspaceType colorSpace_)
580 SetImageColorspace(image(),colorSpace_,exceptionInfo);
582 options()->colorspaceType(colorSpace_);
585Magick::ColorspaceType Magick::Image::colorSpaceType(
void)
const
587 return(constOptions()->colorspaceType());
590size_t Magick::Image::columns(
void)
const
592 return(constImage()->columns);
595void Magick::Image::comment(
const std::string &comment_)
599 SetImageProperty(image(),
"Comment",NULL,exceptionInfo);
600 if (comment_.length() > 0)
601 SetImageProperty(image(),
"Comment",comment_.c_str(),exceptionInfo);
605std::string Magick::Image::comment(
void)
const
611 value=GetImageProperty(constImage(),
"Comment",exceptionInfo);
615 return(std::string(value));
617 return(std::string());
620void Magick::Image::compose(
const CompositeOperator compose_)
622 image()->compose=compose_;
625Magick::CompositeOperator Magick::Image::compose(
void)
const
627 return(constImage()->compose);
630void Magick::Image::compressType(
const CompressionType compressType_)
633 image()->compression=compressType_;
634 options()->compressType(compressType_);
637Magick::CompressionType Magick::Image::compressType(
void)
const
639 return(constImage()->compression);
642void Magick::Image::debug(
const bool flag_)
645 options()->debug(flag_);
648bool Magick::Image::debug(
void)
const
650 return(constOptions()->debug());
653void Magick::Image::density(
const Point &density_)
656 options()->density(density_);
657 if (density_.isValid())
659 image()->resolution.x=density_.x();
660 if (density_.y() != 0.0)
661 image()->resolution.y=density_.y();
663 image()->resolution.y=density_.x();
668 image()->resolution.x=0.0;
669 image()->resolution.y=0.0;
681 if (constImage()->resolution.x > 0.0)
682 x_resolution=constImage()->resolution.x;
684 if (constImage()->resolution.y > 0.0)
685 y_resolution=constImage()->resolution.y;
687 return(Point(x_resolution,y_resolution));
690 return(constOptions()->density());
693void Magick::Image::depth(
const size_t depth_)
696 image()->depth=depth_;
697 options()->depth(depth_);
700size_t Magick::Image::depth(
void)
const
702 return(constImage()->depth);
705std::string Magick::Image::directory(
void)
const
707 if (constImage()->directory)
708 return(std::string(constImage()->directory));
711 throwExceptionExplicit(MagickCore::CorruptImageWarning,
712 "Image does not contain a directory");
714 return(std::string());
717void Magick::Image::endian(
const Magick::EndianType endian_)
720 options()->endian(endian_);
721 image()->endian=endian_;
724Magick::EndianType Magick::Image::endian(
void)
const
726 return(constImage()->endian);
729void Magick::Image::exifProfile(
const Magick::Blob &exifProfile_)
733 if (exifProfile_.data() != 0)
738 exif_profile=AcquireStringInfo(exifProfile_.length());
739 SetStringInfoDatum(exif_profile,(
unsigned char *) exifProfile_.data());
741 (void) SetImageProfile(image(),
"exif",exif_profile,exceptionInfo);
742 exif_profile=DestroyStringInfo(exif_profile);
752 exif_profile=GetImageProfile(constImage(),
"exif");
753 if (exif_profile == (StringInfo *) NULL)
755 return(Blob(GetStringInfoDatum(exif_profile),
756 GetStringInfoLength(exif_profile)));
759void Magick::Image::fileName(
const std::string &fileName_)
766 max_length=
sizeof(image()->filename)-1;
767 fileName_.copy(image()->filename,(size_t) max_length);
768 if ((ssize_t) fileName_.length() > max_length)
769 image()->filename[max_length]=0;
771 image()->filename[fileName_.length()]=0;
773 options()->fileName(fileName_);
776std::string Magick::Image::fileName(
void)
const
778 return(constOptions()->fileName());
781MagickCore::MagickSizeType Magick::Image::fileSize(
void)
const
783 return(GetBlobSize(constImage()));
786void Magick::Image::fillColor(
const Magick::Color &fillColor_)
789 options()->fillColor(fillColor_);
794 return(constOptions()->fillColor());
797void Magick::Image::fillRule(
const Magick::FillRule &fillRule_)
800 options()->fillRule(fillRule_);
803Magick::FillRule Magick::Image::fillRule(
void)
const
805 return constOptions()->fillRule();
808void Magick::Image::fillPattern(
const Image &fillPattern_)
811 if (fillPattern_.isValid())
812 options()->fillPattern(fillPattern_.constImage());
814 options()->fillPattern(
static_cast<MagickCore::Image*
>(NULL));
820 const MagickCore::Image
826 tmpTexture=constOptions()->fillPattern();
834 image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
835 texture.replaceImage(image);
841void Magick::Image::filterType(
const Magick::FilterType filterType_)
844 image()->filter=filterType_;
847Magick::FilterType Magick::Image::filterType(
void)
const
849 return(constImage()->filter);
852void Magick::Image::font(
const std::string &font_)
855 options()->font(font_);
858std::string Magick::Image::font(
void)
const
860 return(constOptions()->font());
863void Magick::Image::fontFamily(
const std::string &family_)
866 options()->fontFamily(family_);
869std::string Magick::Image::fontFamily(
void)
const
871 return(constOptions()->fontFamily());
874void Magick::Image::fontPointsize(
const double pointSize_)
877 options()->fontPointsize(pointSize_);
880double Magick::Image::fontPointsize(
void)
const
882 return(constOptions()->fontPointsize());
885void Magick::Image::fontStyle(
const StyleType pointSize_)
888 options()->fontStyle(pointSize_);
891Magick::StyleType Magick::Image::fontStyle(
void)
const
893 return(constOptions()->fontStyle());
896void Magick::Image::fontWeight(
const size_t weight_)
899 options()->fontWeight(weight_);
902size_t Magick::Image::fontWeight(
void)
const
904 return(constOptions()->fontWeight());
907std::string Magick::Image::format(
void)
const
913 magick_info=GetMagickInfo(constImage()->magick,exceptionInfo);
916 if ((magick_info != 0) && (*magick_info->description !=
'\0'))
917 return(std::string(magick_info->description));
920 throwExceptionExplicit(MagickCore::CorruptImageWarning,
921 "Unrecognized image magick type");
923 return(std::string());
926std::string Magick::Image::formatExpression(
const std::string expression)
936 text=InterpretImageProperties(imageInfo(),image(),expression.c_str(),
938 if (text != (
char *) NULL)
940 text_string=std::string(text);
941 text=DestroyString(text);
947double Magick::Image::gamma(
void)
const
949 return(constImage()->gamma);
954 if (constImage()->geometry)
955 return Geometry(constImage()->geometry);
958 throwExceptionExplicit(MagickCore::OptionWarning,
959 "Image does not contain a geometry");
964void Magick::Image::gifDisposeMethod(
965 const MagickCore::DisposeType disposeMethod_)
968 image()->dispose=disposeMethod_;
971MagickCore::DisposeType Magick::Image::gifDisposeMethod(
void)
const
973 return(constImage()->dispose);
976bool Magick::Image::hasChannel(
const PixelChannel channel)
const
978 if (GetPixelChannelTraits(constImage(),channel) == UndefinedPixelTrait)
981 if (channel == GreenPixelChannel || channel == BluePixelChannel)
982 return (GetPixelChannelOffset(constImage(),channel) == (ssize_t)channel);
987void Magick::Image::highlightColor(
const Color color_)
993 artifact(
"compare:highlight-color",value);
996void Magick::Image::iccColorProfile(
const Magick::Blob &colorProfile_)
998 profile(
"icc",colorProfile_);
1006 color_profile=GetImageProfile(constImage(),
"icc");
1007 if (color_profile == (StringInfo *) NULL)
1009 return(Blob(GetStringInfoDatum(color_profile),GetStringInfoLength(
1013void Magick::Image::interlaceType(
const Magick::InterlaceType interlace_)
1016 image()->interlace=interlace_;
1017 options()->interlaceType(interlace_);
1020Magick::InterlaceType Magick::Image::interlaceType(
void)
const
1022 return(constImage()->interlace);
1025void Magick::Image::interpolate(
const PixelInterpolateMethod interpolate_)
1028 image()->interpolate=interpolate_;
1031Magick::PixelInterpolateMethod Magick::Image::interpolate(
void)
const
1033 return constImage()->interpolate;
1036void Magick::Image::iptcProfile(
const Magick::Blob &iptcProfile_)
1039 if (iptcProfile_.data() != 0)
1044 iptc_profile=AcquireStringInfo(iptcProfile_.length());
1045 SetStringInfoDatum(iptc_profile,(
unsigned char *) iptcProfile_.data());
1047 (void) SetImageProfile(image(),
"iptc",iptc_profile,exceptionInfo);
1048 iptc_profile=DestroyStringInfo(iptc_profile);
1049 ThrowImageException;
1058 iptc_profile=GetImageProfile(constImage(),
"iptc");
1059 if (iptc_profile == (StringInfo *) NULL)
1061 return(Blob(GetStringInfoDatum(iptc_profile),GetStringInfoLength(
1065bool Magick::Image::isOpaque(
void)
const
1071 result=IsImageOpaque(constImage(),exceptionInfo);
1072 ThrowImageException;
1073 return(result != MagickFalse ?
true : false);
1076void Magick::Image::isValid(
const bool isValid_)
1081 _imgRef=
new ImageRef;
1083 else if (!isValid())
1087 size(Geometry(1,1));
1092bool Magick::Image::isValid(
void)
const
1094 return rows() && columns();
1097void Magick::Image::label(
const std::string &label_)
1101 (void) SetImageProperty(image(),
"Label",NULL,exceptionInfo);
1102 if (label_.length() > 0)
1103 (
void) SetImageProperty(image(),
"Label",label_.c_str(),exceptionInfo);
1104 ThrowImageException;
1107std::string Magick::Image::label(
void)
const
1113 value=GetImageProperty(constImage(),
"Label",exceptionInfo);
1114 ThrowImageException;
1117 return(std::string(value));
1119 return(std::string());
1122void Magick::Image::lowlightColor(
const Color color_)
1128 artifact(
"compare:lowlight-color",value);
1131void Magick::Image::magick(
const std::string &magick_)
1138 length=
sizeof(image()->magick)-1;
1139 if (magick_.length() < length)
1140 length=magick_.length();
1142 if (!magick_.empty())
1143 magick_.copy(image()->magick,length);
1144 image()->magick[length]=0;
1146 options()->magick(magick_);
1149std::string Magick::Image::magick(
void)
const
1151 if (*(constImage()->magick) !=
'\0')
1152 return(std::string(constImage()->magick));
1154 return(constOptions()->magick());
1157void Magick::Image::masklightColor(
const Color color_)
1163 artifact(
"compare:masklight-color",value);
1166double Magick::Image::meanErrorPerPixel(
void)
const
1168 return(constImage()->error.mean_error_per_pixel);
1171void Magick::Image::modulusDepth(
const size_t depth_)
1175 SetImageDepth(image(),depth_,exceptionInfo);
1176 ThrowImageException;
1177 options()->depth(depth_);
1180size_t Magick::Image::modulusDepth(
void)
const
1186 depth=GetImageDepth(constImage(),exceptionInfo);
1187 ThrowImageException;
1191void Magick::Image::monochrome(
const bool monochromeFlag_)
1194 options()->monochrome(monochromeFlag_);
1197bool Magick::Image::monochrome(
void)
const
1199 return(constOptions()->monochrome());
1204 if (constImage()->montage)
1208 throwExceptionExplicit(MagickCore::CorruptImageWarning,
1209 "Image does not contain a montage");
1214double Magick::Image::normalizedMaxError(
void)
const
1216 return(constImage()->error.normalized_maximum_error);
1219double Magick::Image::normalizedMeanError(
void)
const
1221 return(constImage()->error.normalized_mean_error);
1224void Magick::Image::orientation(
const Magick::OrientationType orientation_)
1227 image()->orientation=orientation_;
1230Magick::OrientationType Magick::Image::orientation(
void)
const
1232 return(constImage()->orientation);
1238 options()->page(pageSize_);
1239 image()->page=pageSize_;
1244 return(Geometry(constImage()->page.width,constImage()->page.height,
1245 constImage()->page.x,constImage()->page.y));
1248void Magick::Image::quality(
const size_t quality_)
1251 image()->quality=quality_;
1252 options()->quality(quality_);
1255size_t Magick::Image::quality(
void)
const
1257 return(constImage()->quality);
1260void Magick::Image::quantizeColors(
const size_t colors_)
1263 options()->quantizeColors(colors_);
1266size_t Magick::Image::quantizeColors(
void)
const
1268 return(constOptions()->quantizeColors());
1271void Magick::Image::quantizeColorSpace(
1272 const Magick::ColorspaceType colorSpace_)
1275 options()->quantizeColorSpace(colorSpace_);
1278Magick::ColorspaceType Magick::Image::quantizeColorSpace(
void)
const
1280 return(constOptions()->quantizeColorSpace());
1283void Magick::Image::quantizeDither(
const bool ditherFlag_)
1286 options()->quantizeDither(ditherFlag_);
1289bool Magick::Image::quantizeDither(
void)
const
1291 return(constOptions()->quantizeDither());
1294void Magick::Image::quantizeDitherMethod(
const DitherMethod ditherMethod_)
1297 options()->quantizeDitherMethod(ditherMethod_);
1300MagickCore::DitherMethod Magick::Image::quantizeDitherMethod(
void)
const
1302 return(constOptions()->quantizeDitherMethod());
1305void Magick::Image::quantizeTreeDepth(
const size_t treeDepth_)
1308 options()->quantizeTreeDepth(treeDepth_);
1311size_t Magick::Image::quantizeTreeDepth()
const
1313 return(constOptions()->quantizeTreeDepth());
1316void Magick::Image::quiet(
const bool quiet_)
1319 options()->quiet(quiet_);
1322bool Magick::Image::quiet(
void)
const
1324 return(constOptions()->quiet());
1327void Magick::Image::renderingIntent(
1328 const Magick::RenderingIntent renderingIntent_)
1331 image()->rendering_intent=renderingIntent_;
1334Magick::RenderingIntent Magick::Image::renderingIntent(
void)
const
1336 return(
static_cast<Magick::RenderingIntent
>(constImage()->rendering_intent));
1339void Magick::Image::resolutionUnits(
1340 const Magick::ResolutionType resolutionUnits_)
1343 image()->units=resolutionUnits_;
1344 options()->resolutionUnits(resolutionUnits_);
1347Magick::ResolutionType Magick::Image::resolutionUnits(
void)
const
1349 return(
static_cast<Magick::ResolutionType
>(constImage()->units));
1352size_t Magick::Image::rows(
void)
const
1354 return(constImage()->rows);
1357void Magick::Image::samplingFactor(
const std::string &samplingFactor_)
1360 options()->samplingFactor(samplingFactor_);
1363std::string Magick::Image::samplingFactor(
void)
const
1365 return(constOptions()->samplingFactor());
1368void Magick::Image::scene(
const size_t scene_)
1371 image()->scene=scene_;
1374size_t Magick::Image::scene(
void)
const
1376 return(constImage()->scene);
1379void Magick::Image::size(
const Geometry &geometry_)
1382 options()->size(geometry_);
1383 image()->rows=geometry_.height();
1384 image()->columns=geometry_.width();
1392void Magick::Image::strokeAntiAlias(
const bool flag_)
1395 options()->strokeAntiAlias(flag_);
1398bool Magick::Image::strokeAntiAlias(
void)
const
1400 return(constOptions()->strokeAntiAlias());
1403void Magick::Image::strokeColor(
const Magick::Color &strokeColor_)
1409 options()->strokeColor(strokeColor_);
1411 artifact(
"stroke",value);
1416 return(constOptions()->strokeColor());
1419void Magick::Image::strokeDashArray(
const double *strokeDashArray_)
1422 options()->strokeDashArray(strokeDashArray_);
1425const double* Magick::Image::strokeDashArray(
void)
const
1427 return(constOptions()->strokeDashArray());
1430void Magick::Image::strokeDashOffset(
const double strokeDashOffset_)
1433 options()->strokeDashOffset(strokeDashOffset_);
1436double Magick::Image::strokeDashOffset(
void)
const
1438 return(constOptions()->strokeDashOffset());
1441void Magick::Image::strokeLineCap(
const Magick::LineCap lineCap_)
1444 options()->strokeLineCap(lineCap_);
1447Magick::LineCap Magick::Image::strokeLineCap(
void)
const
1449 return(constOptions()->strokeLineCap());
1452void Magick::Image::strokeLineJoin(
const Magick::LineJoin lineJoin_)
1455 options()->strokeLineJoin(lineJoin_);
1458Magick::LineJoin Magick::Image::strokeLineJoin(
void)
const
1460 return(constOptions()->strokeLineJoin());
1463void Magick::Image::strokeMiterLimit(
const size_t strokeMiterLimit_)
1466 options()->strokeMiterLimit(strokeMiterLimit_);
1469size_t Magick::Image::strokeMiterLimit(
void)
const
1471 return(constOptions()->strokeMiterLimit());
1474void Magick::Image::strokePattern(
const Image &strokePattern_)
1477 if(strokePattern_.isValid())
1478 options()->strokePattern(strokePattern_.constImage());
1480 options()->strokePattern(
static_cast<MagickCore::Image*
>(NULL));
1486 const MagickCore::Image
1492 tmpTexture=constOptions()->strokePattern();
1500 image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
1501 texture.replaceImage(image);
1502 ThrowImageException;
1507void Magick::Image::strokeWidth(
const double strokeWidth_)
1510 value[MagickPathExtent];
1513 options()->strokeWidth(strokeWidth_);
1514 FormatLocaleString(value,MagickPathExtent,
"%.20g",strokeWidth_);
1515 (void) SetImageArtifact(image(),
"strokewidth",value);
1518double Magick::Image::strokeWidth(
void)
const
1520 return(constOptions()->strokeWidth());
1523void Magick::Image::subImage(
const size_t subImage_)
1526 options()->subImage(subImage_);
1529size_t Magick::Image::subImage(
void)
const
1531 return(constOptions()->subImage());
1534void Magick::Image::subRange(
const size_t subRange_)
1537 options()->subRange(subRange_);
1540size_t Magick::Image::subRange(
void)
const
1542 return(constOptions()->subRange());
1545void Magick::Image::textAntiAlias(
const bool flag_)
1548 options()->textAntiAlias(flag_);
1551bool Magick::Image::textAntiAlias(
void)
const
1553 return(constOptions()->textAntiAlias());
1556void Magick::Image::textDirection(DirectionType direction_)
1559 options()->textDirection(direction_);
1562Magick::DirectionType Magick::Image::textDirection(
void)
const
1564 return(constOptions()->textDirection());
1567void Magick::Image::textEncoding(
const std::string &encoding_)
1570 options()->textEncoding(encoding_);
1573std::string Magick::Image::textEncoding(
void)
const
1575 return(constOptions()->textEncoding());
1578void Magick::Image::textGravity(GravityType gravity_)
1581 options()->textGravity(gravity_);
1584Magick::GravityType Magick::Image::textGravity(
void)
const
1586 return(constOptions()->textGravity());
1589void Magick::Image::textInterlineSpacing(
double spacing_)
1592 options()->textInterlineSpacing(spacing_);
1595double Magick::Image::textInterlineSpacing(
void)
const
1597 return(constOptions()->textInterlineSpacing());
1600void Magick::Image::textInterwordSpacing(
double spacing_)
1603 options()->textInterwordSpacing(spacing_);
1606double Magick::Image::textInterwordSpacing(
void)
const
1608 return(constOptions()->textInterwordSpacing());
1611void Magick::Image::textKerning(
double kerning_)
1614 options()->textKerning(kerning_);
1617double Magick::Image::textKerning(
void)
const
1619 return(constOptions()->textKerning());
1622void Magick::Image::textUnderColor(
const Color &underColor_)
1625 options()->textUnderColor(underColor_);
1630 return(constOptions()->textUnderColor());
1633size_t Magick::Image::totalColors(
void)
const
1639 colors=GetNumberColors(constImage(),(FILE *) NULL,exceptionInfo);
1640 ThrowImageException;
1644void Magick::Image::transformRotation(
const double angle_)
1647 options()->transformRotation(angle_);
1650void Magick::Image::transformSkewX(
const double skewx_)
1653 options()->transformSkewX(skewx_);
1656void Magick::Image::transformSkewY(
const double skewy_)
1659 options()->transformSkewY(skewy_);
1662Magick::ImageType Magick::Image::type(
void)
const
1664 if (constOptions()->type() != UndefinedType)
1665 return(constOptions()->type());
1666 return(GetImageType(constImage()));
1669void Magick::Image::type(
const Magick::ImageType type_)
1672 options()->type(type_);
1674 SetImageType(image(),type_,exceptionInfo);
1675 ThrowImageException;
1678void Magick::Image::verbose(
const bool verboseFlag_)
1681 options()->verbose(verboseFlag_);
1684bool Magick::Image::verbose(
void)
const
1686 return(constOptions()->verbose());
1689void Magick::Image::virtualPixelMethod(
1690 const VirtualPixelMethod virtualPixelMethod_)
1694 SetImageVirtualPixelMethod(image(),virtualPixelMethod_,exceptionInfo);
1695 ThrowImageException;
1698Magick::VirtualPixelMethod Magick::Image::virtualPixelMethod(
void)
const
1700 return(GetImageVirtualPixelMethod(constImage()));
1703void Magick::Image::x11Display(
const std::string &display_)
1706 options()->x11Display(display_);
1709std::string Magick::Image::x11Display(
void)
const
1711 return(constOptions()->x11Display());
1714double Magick::Image::xResolution(
void)
const
1716 return(constImage()->resolution.x);
1719double Magick::Image::yResolution(
void)
const
1721 return(constImage()->resolution.y);
1724void Magick::Image::adaptiveBlur(
const double radius_,
const double sigma_)
1730 newImage=AdaptiveBlurImage(constImage(),radius_,sigma_,exceptionInfo);
1731 replaceImage(newImage);
1732 ThrowImageException;
1735void Magick::Image::adaptiveResize(
const Geometry &geometry_)
1748 ParseMetaGeometry(
static_cast<std::string
>(geometry_).c_str(),&x,&y,&width,
1752 newImage=AdaptiveResizeImage(constImage(),width,height,exceptionInfo);
1753 replaceImage(newImage);
1754 ThrowImageException;
1757void Magick::Image::adaptiveSharpen(
const double radius_,
const double sigma_)
1763 newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,exceptionInfo);
1764 replaceImage(newImage);
1765 ThrowImageException;
1768void Magick::Image::adaptiveSharpenChannel(
const ChannelType channel_,
1769 const double radius_,
const double sigma_ )
1775 GetAndSetPPChannelMask(channel_);
1776 newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,exceptionInfo);
1777 RestorePPChannelMask;
1778 replaceImage(newImage);
1779 ThrowImageException;
1782void Magick::Image::adaptiveThreshold(
const size_t width_,
const size_t height_,
1790 newImage=AdaptiveThresholdImage(constImage(),width_,height_,bias_,
1792 replaceImage(newImage);
1793 ThrowImageException;
1796void Magick::Image::addNoise(
const NoiseType noiseType_,
const double attenuate_)
1802 newImage=AddNoiseImage(constImage(),noiseType_,attenuate_,exceptionInfo);
1803 replaceImage(newImage);
1804 ThrowImageException;
1807void Magick::Image::addNoiseChannel(
const ChannelType channel_,
1808 const NoiseType noiseType_,
const double attenuate_)
1814 GetAndSetPPChannelMask(channel_);
1815 newImage=AddNoiseImage(constImage(),noiseType_,attenuate_,exceptionInfo);
1816 RestorePPChannelMask;
1817 replaceImage(newImage);
1818 ThrowImageException;
1821void Magick::Image::affineTransform(
const DrawableAffine &affine_)
1829 _affine.sx=affine_.sx();
1830 _affine.sy=affine_.sy();
1831 _affine.rx=affine_.rx();
1832 _affine.ry=affine_.ry();
1833 _affine.tx=affine_.tx();
1834 _affine.ty=affine_.ty();
1837 newImage=AffineTransformImage(constImage(),&_affine,exceptionInfo);
1838 replaceImage(newImage);
1839 ThrowImageException;
1842void Magick::Image::alpha(
const unsigned int alpha_)
1846 SetImageAlpha(image(),alpha_,exceptionInfo);
1847 ThrowImageException;
1850void Magick::Image::alphaChannel(AlphaChannelOption alphaOption_)
1854 SetImageAlphaChannel(image(),alphaOption_,exceptionInfo);
1855 ThrowImageException;
1858void Magick::Image::annotate(
const std::string &text_,
1859 const Geometry &location_)
1861 annotate(text_,location_,NorthWestGravity,0.0);
1864void Magick::Image::annotate(
const std::string &text_,
1865 const Geometry &boundingArea_,
const GravityType gravity_)
1867 annotate(text_,boundingArea_,gravity_,0.0);
1870void Magick::Image::annotate(
const std::string &text_,
1871 const Geometry &boundingArea_,
const GravityType gravity_,
1872 const double degrees_)
1878 boundingArea[MagickPathExtent];
1885 drawInfo=options()->drawInfo();
1886 drawInfo->text=DestroyString(drawInfo->text);
1887 drawInfo->text=
const_cast<char *
>(text_.c_str());
1888 drawInfo->geometry=DestroyString(drawInfo->geometry);
1890 if (boundingArea_.isValid())
1892 if (boundingArea_.width() == 0 || boundingArea_.height() == 0)
1894 FormatLocaleString(boundingArea,MagickPathExtent,
"%+.20g%+.20g",
1895 (
double) boundingArea_.xOff(),(
double) boundingArea_.yOff());
1899 (void) CopyMagickString(boundingArea,
1900 std::string(boundingArea_).c_str(), MagickPathExtent);
1902 drawInfo->geometry=boundingArea;
1905 drawInfo->gravity=gravity_;
1907 oaffine=drawInfo->affine;
1908 if (degrees_ != 0.0)
1921 current=drawInfo->affine;
1922 affine.sx=cos(DegreesToRadians(fmod(degrees_,360.0)));
1923 affine.rx=sin(DegreesToRadians(fmod(degrees_,360.0)));
1924 affine.ry=(-sin(DegreesToRadians(fmod(degrees_,360.0))));
1925 affine.sy=cos(DegreesToRadians(fmod(degrees_,360.0)));
1927 drawInfo->affine.sx=current.sx*affine.sx+current.ry*affine.rx;
1928 drawInfo->affine.rx=current.rx*affine.sx+current.sy*affine.rx;
1929 drawInfo->affine.ry=current.sx*affine.ry+current.ry*affine.sy;
1930 drawInfo->affine.sy=current.rx*affine.ry+current.sy*affine.sy;
1931 drawInfo->affine.tx=current.sx*affine.tx+current.ry*affine.ty
1936 AnnotateImage(image(),drawInfo,exceptionInfo);
1939 drawInfo->affine=oaffine;
1940 drawInfo->text=(
char *) NULL;
1941 drawInfo->geometry=(
char *) NULL;
1943 ThrowImageException;
1946void Magick::Image::annotate(
const std::string &text_,
1947 const GravityType gravity_)
1954 drawInfo=options()->drawInfo();
1955 drawInfo->text=DestroyString(drawInfo->text);
1956 drawInfo->text=
const_cast<char *
>(text_.c_str());
1957 drawInfo->gravity=gravity_;
1960 AnnotateImage(image(),drawInfo,exceptionInfo);
1962 drawInfo->gravity=NorthWestGravity;
1963 drawInfo->text=(
char *) NULL;
1965 ThrowImageException;
1968void Magick::Image::artifact(
const std::string &name_,
const std::string &value_)
1971 (void) SetImageArtifact(image(),name_.c_str(),value_.c_str());
1974std::string Magick::Image::artifact(
const std::string &name_)
const
1979 value=GetImageArtifact(constImage(),name_.c_str());
1981 return(std::string(value));
1982 return(std::string());
1985void Magick::Image::attribute(
const std::string name_,
const char *value_)
1989 SetImageProperty(image(),name_.c_str(),value_,exceptionInfo);
1990 ThrowImageException;
1993void Magick::Image::attribute(
const std::string name_,
const std::string value_)
1997 SetImageProperty(image(),name_.c_str(),value_.c_str(),exceptionInfo);
1998 ThrowImageException;
2001std::string Magick::Image::attribute(
const std::string name_)
const
2007 value=GetImageProperty(constImage(),name_.c_str(),exceptionInfo);
2008 ThrowImageException;
2011 return(std::string(value));
2013 return(std::string());
2016void Magick::Image::autoGamma(
void)
2020 (void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
2021 (void) AutoGammaImage(image(),exceptionInfo);
2022 ThrowImageException;
2025void Magick::Image::autoGammaChannel(
const ChannelType channel_)
2029 GetAndSetPPChannelMask(channel_);
2030 (void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
2031 (void) AutoGammaImage(image(),exceptionInfo);
2032 RestorePPChannelMask;
2033 ThrowImageException;
2036void Magick::Image::autoLevel(
void)
2040 (void) AutoLevelImage(image(),exceptionInfo);
2041 ThrowImageException;
2044void Magick::Image::autoLevelChannel(
const ChannelType channel_)
2048 GetAndSetPPChannelMask(channel_);
2049 (void) AutoLevelImage(image(),exceptionInfo);
2050 RestorePPChannelMask;
2051 ThrowImageException;
2054void Magick::Image::autoOrient(
void)
2059 if (image()->orientation == UndefinedOrientation ||
2060 image()->orientation == TopLeftOrientation)
2064 newImage=AutoOrientImage(constImage(),image()->orientation,exceptionInfo);
2065 replaceImage(newImage);
2066 ThrowImageException;
2069void Magick::Image::autoThreshold(
const AutoThresholdMethod method_)
2073 AutoThresholdImage(image(),method_, exceptionInfo);
2074 ThrowImageException;
2077void Magick::Image::blackThreshold(
const std::string &threshold_)
2081 BlackThresholdImage(image(),threshold_.c_str(),exceptionInfo);
2082 ThrowImageException;
2085void Magick::Image::blackThresholdChannel(
const ChannelType channel_,
2086 const std::string &threshold_)
2090 GetAndSetPPChannelMask(channel_);
2091 BlackThresholdImage(image(),threshold_.c_str(),exceptionInfo);
2092 RestorePPChannelMask;
2093 ThrowImageException;
2096void Magick::Image::blueShift(
const double factor_)
2102 newImage=BlueShiftImage(constImage(),factor_,exceptionInfo);
2103 replaceImage(newImage);
2104 ThrowImageException;
2107void Magick::Image::blur(
const double radius_,
const double sigma_)
2113 newImage=BlurImage(constImage(),radius_,sigma_,exceptionInfo);
2114 replaceImage(newImage);
2115 ThrowImageException;
2118void Magick::Image::blurChannel(
const ChannelType channel_,
2119 const double radius_,
const double sigma_)
2125 GetAndSetPPChannelMask(channel_);
2126 newImage=BlurImage(constImage(),radius_,sigma_,exceptionInfo);
2127 RestorePPChannelMask;
2128 replaceImage(newImage);
2129 ThrowImageException;
2132void Magick::Image::border(
const Geometry &geometry_)
2138 borderInfo=geometry_;
2141 newImage=BorderImage(constImage(),&borderInfo,image()->compose,
2143 replaceImage(newImage);
2144 ThrowImageException;
2147void Magick::Image::brightnessContrast(
const double brightness_,
2148 const double contrast_)
2152 BrightnessContrastImage(image(),brightness_,contrast_,exceptionInfo);
2153 ThrowImageException;
2156void Magick::Image::brightnessContrastChannel(
const ChannelType channel_,
2157 const double brightness_,
const double contrast_)
2161 GetAndSetPPChannelMask(channel_);
2162 BrightnessContrastImage(image(),brightness_,contrast_,exceptionInfo);
2163 RestorePPChannelMask;
2164 ThrowImageException;
2167void Magick::Image::cannyEdge(
const double radius_,
const double sigma_,
2168 const double lowerPercent_,
const double upperPercent_)
2175 newImage=CannyEdgeImage(constImage(),radius_,sigma_,lowerPercent_,
2176 upperPercent_,exceptionInfo);
2177 replaceImage(newImage);
2178 ThrowImageException;
2181void Magick::Image::cdl(
const std::string &cdl_)
2185 (void) ColorDecisionListImage(image(),cdl_.c_str(),exceptionInfo);
2186 ThrowImageException;
2189void Magick::Image::channel(
const ChannelType channel_)
2195 newImage=SeparateImage(constImage(),channel_,exceptionInfo);
2196 replaceImage(newImage);
2197 ThrowImageException;
2200void Magick::Image::charcoal(
const double radius_,
const double sigma_)
2206 newImage=CharcoalImage(image(),radius_,sigma_,exceptionInfo);
2207 replaceImage(newImage);
2208 ThrowImageException;
2211void Magick::Image::charcoalChannel(
const ChannelType channel_,
2212 const double radius_,
const double sigma_)
2218 GetAndSetPPChannelMask(channel_);
2219 newImage=CharcoalImage(image(),radius_,sigma_,exceptionInfo);
2220 RestorePPChannelMask;
2221 replaceImage(newImage);
2222 ThrowImageException;
2225void Magick::Image::chop(
const Geometry &geometry_)
2234 newImage=ChopImage(image(),&chopInfo,exceptionInfo);
2235 replaceImage(newImage);
2236 ThrowImageException;
2239void Magick::Image::chromaBluePrimary(
const double x_,
const double y_,
2243 image()->chromaticity.blue_primary.x=x_;
2244 image()->chromaticity.blue_primary.y=y_;
2245 image()->chromaticity.blue_primary.z=z_;
2248void Magick::Image::chromaBluePrimary(
double *x_,
double *y_,
double *z_)
const
2250 *x_=constImage()->chromaticity.blue_primary.x;
2251 *y_=constImage()->chromaticity.blue_primary.y;
2252 *z_=constImage()->chromaticity.blue_primary.z;
2255void Magick::Image::chromaGreenPrimary(
const double x_,
const double y_,
2259 image()->chromaticity.green_primary.x=x_;
2260 image()->chromaticity.green_primary.y=y_;
2261 image()->chromaticity.green_primary.z=z_;
2264void Magick::Image::chromaGreenPrimary(
double *x_,
double *y_,
double *z_)
const
2266 *x_=constImage()->chromaticity.green_primary.x;
2267 *y_=constImage()->chromaticity.green_primary.y;
2268 *z_=constImage()->chromaticity.green_primary.z;
2271void Magick::Image::chromaRedPrimary(
const double x_,
const double y_,
2275 image()->chromaticity.red_primary.x=x_;
2276 image()->chromaticity.red_primary.y=y_;
2277 image()->chromaticity.red_primary.z=z_;
2280void Magick::Image::chromaRedPrimary(
double *x_,
double *y_,
double *z_)
const
2282 *x_=constImage()->chromaticity.red_primary.x;
2283 *y_=constImage()->chromaticity.red_primary.y;
2284 *z_=constImage()->chromaticity.red_primary.z;
2287void Magick::Image::chromaWhitePoint(
const double x_,
const double y_,
2291 image()->chromaticity.white_point.x=x_;
2292 image()->chromaticity.white_point.y=y_;
2293 image()->chromaticity.white_point.z=z_;
2296void Magick::Image::chromaWhitePoint(
double *x_,
double *y_,
double *z_)
const
2298 *x_=constImage()->chromaticity.white_point.x;
2299 *y_=constImage()->chromaticity.white_point.y;
2300 *z_=constImage()->chromaticity.white_point.z;
2303void Magick::Image::clamp(
void)
2307 ClampImage(image(),exceptionInfo);
2308 ThrowImageException;
2311void Magick::Image::clampChannel(
const ChannelType channel_)
2315 GetAndSetPPChannelMask(channel_);
2316 ClampImage(image(),exceptionInfo);
2317 RestorePPChannelMask;
2318 ThrowImageException;
2321void Magick::Image::clip(
void)
2325 ClipImage(image(),exceptionInfo);
2326 ThrowImageException;
2329void Magick::Image::clipPath(
const std::string pathname_,
const bool inside_)
2333 ClipImagePath(image(),pathname_.c_str(),(MagickBooleanType) inside_,
2335 ThrowImageException;
2338void Magick::Image::clut(
const Image &clutImage_,
2339 const PixelInterpolateMethod method)
2343 ClutImage(image(),clutImage_.constImage(),method,exceptionInfo);
2344 ThrowImageException;
2347void Magick::Image::clutChannel(
const ChannelType channel_,
2348 const Image &clutImage_,
const PixelInterpolateMethod method)
2352 GetAndSetPPChannelMask(channel_);
2353 ClutImage(image(),clutImage_.constImage(),method,exceptionInfo);
2354 RestorePPChannelMask;
2355 ThrowImageException;
2358void Magick::Image::colorize(
const unsigned int alpha_,
const Color &penColor_)
2360 colorize(alpha_,alpha_,alpha_,penColor_);
2363void Magick::Image::colorize(
const unsigned int alphaRed_,
2364 const unsigned int alphaGreen_,
const unsigned int alphaBlue_,
2365 const Color &penColor_)
2368 blend[MagickPathExtent];
2376 if (!penColor_.isValid())
2377 throwExceptionExplicit(MagickCore::OptionError,
2378 "Pen color argument is invalid");
2380 FormatLocaleString(blend,MagickPathExtent,
"%u/%u/%u",alphaRed_,alphaGreen_,
2383 target=
static_cast<PixelInfo
>(penColor_);
2385 newImage=ColorizeImage(image(),blend,&target,exceptionInfo);
2386 replaceImage(newImage);
2387 ThrowImageException;
2390void Magick::Image::colorMap(
const size_t index_,
const Color &color_)
2397 if (index_ > (MaxColormapSize-1))
2398 throwExceptionExplicit(MagickCore::OptionError,
2399 "Colormap index must be less than MaxColormapSize");
2401 if (!color_.isValid())
2402 throwExceptionExplicit(MagickCore::OptionError,
2403 "Color argument is invalid");
2408 if (colorMapSize() < (index_+1))
2409 colorMapSize(index_+1);
2412 (imageptr->colormap)[index_]=color_;
2415Magick::Color Magick::Image::colorMap(
const size_t index_)
const
2417 if (!constImage()->colormap)
2419 throwExceptionExplicit(MagickCore::OptionError,
2420 "Image does not contain a colormap");
2424 if (index_ > constImage()->colors-1)
2425 throwExceptionExplicit(MagickCore::OptionError,
"Index out of range");
2430void Magick::Image::colorMatrix(
const size_t order_,
2431 const double *color_matrix_)
2437 kernel_info=AcquireKernelInfo((
const char *) NULL,exceptionInfo);
2438 if (kernel_info != (KernelInfo *) NULL)
2440 kernel_info->width=order_;
2441 kernel_info->height=order_;
2442 kernel_info->values=(MagickRealType *) AcquireAlignedMemory(order_,
2443 order_*
sizeof(*kernel_info->values));
2444 if (kernel_info->values != (MagickRealType *) NULL)
2449 for (ssize_t i=0; i < (ssize_t) (order_*order_); i++)
2450 kernel_info->values[i]=color_matrix_[i];
2451 newImage=ColorMatrixImage(image(),kernel_info,exceptionInfo);
2452 replaceImage(newImage);
2454 kernel_info=DestroyKernelInfo(kernel_info);
2456 ThrowImageException;
2459bool Magick::Image::compare(
const Image &reference_)
const
2468 status=
static_cast<bool>(IsImagesEqual(constImage(),ref.constImage(),
2470 ThrowImageException;
2474double Magick::Image::compare(
const Image &reference_,
const MetricType metric_)
2480 GetImageDistortion(image(),reference_.constImage(),metric_,&distortion,
2482 ThrowImageException;
2486double Magick::Image::compareChannel(
const ChannelType channel_,
2487 const Image &reference_,
const MetricType metric_)
2493 GetAndSetPPChannelMask(channel_);
2494 GetImageDistortion(image(),reference_.constImage(),metric_,&distortion,
2496 RestorePPChannelMask;
2497 ThrowImageException;
2501Magick::Image Magick::Image::compare(
const Image &reference_,
2502 const MetricType metric_,
double *distortion)
2508 newImage=CompareImages(image(),reference_.constImage(),metric_,distortion,
2510 ThrowImageException;
2511 if (newImage == (MagickCore::Image *) NULL)
2517Magick::Image Magick::Image::compareChannel(
const ChannelType channel_,
2518 const Image &reference_,
const MetricType metric_,
double *distortion)
2524 GetAndSetPPChannelMask(channel_);
2525 newImage=CompareImages(image(),reference_.constImage(),metric_,distortion,
2527 RestorePPChannelMask;
2528 ThrowImageException;
2529 if (newImage == (MagickCore::Image *) NULL)
2535void Magick::Image::composite(
const Image &compositeImage_,
2536 const Geometry &offset_,
const CompositeOperator compose_)
2546 ParseMetaGeometry(
static_cast<std::string
>(offset_).c_str(),&x,&y,&width,
2551 CompositeImage(image(),compositeImage_.constImage(),compose_,MagickTrue,
2553 ThrowImageException;
2556void Magick::Image::composite(
const Image &compositeImage_,
2557 const GravityType gravity_,
const CompositeOperator compose_)
2563 SetGeometry(compositeImage_.constImage(),&geometry);
2564 GravityAdjustGeometry(columns(),rows(),gravity_,&geometry);
2567 CompositeImage(image(),compositeImage_.constImage(),compose_,MagickTrue,
2568 geometry.x,geometry.y,exceptionInfo);
2569 ThrowImageException;
2572void Magick::Image::composite(
const Image &compositeImage_,
2573 const ssize_t xOffset_,
const ssize_t yOffset_,
2574 const CompositeOperator compose_)
2580 CompositeImage(image(),compositeImage_.constImage(),compose_,MagickTrue,
2581 xOffset_,yOffset_,exceptionInfo);
2582 ThrowImageException;
2585void Magick::Image::connectedComponents(
const size_t connectivity_)
2591 newImage=ConnectedComponentsImage(constImage(),connectivity_,
2592 (CCObjectInfo **) NULL,exceptionInfo);
2593 replaceImage(newImage);
2594 ThrowImageException;
2597void Magick::Image::contrast(
const bool sharpen_)
2601 ContrastImage(image(),(MagickBooleanType) sharpen_,exceptionInfo);
2602 ThrowImageException;
2605void Magick::Image::contrastStretch(
const double blackPoint_,
2606 const double whitePoint_)
2610 ContrastStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
2611 ThrowImageException;
2614void Magick::Image::contrastStretchChannel(
const ChannelType channel_,
2615 const double blackPoint_,
const double whitePoint_)
2619 GetAndSetPPChannelMask(channel_);
2620 ContrastStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
2621 RestorePPChannelMask;
2622 ThrowImageException;
2625void Magick::Image::convolve(
const size_t order_,
const double *kernel_)
2631 kernel_info=AcquireKernelInfo((
const char *) NULL,exceptionInfo);
2632 kernel_info->width=order_;
2633 kernel_info->height=order_;
2634 kernel_info->x=(ssize_t) (order_-1)/2;
2635 kernel_info->y=(ssize_t) (order_-1)/2;
2636 kernel_info->values=(MagickRealType *) AcquireAlignedMemory(order_,
2637 order_*
sizeof(*kernel_info->values));
2638 if (kernel_info->values != (MagickRealType *) NULL)
2643 for (ssize_t i=0; i < (ssize_t) (order_*order_); i++)
2644 kernel_info->values[i]=kernel_[i];
2645 newImage=ConvolveImage(image(),kernel_info,exceptionInfo);
2646 replaceImage(newImage);
2648 kernel_info=DestroyKernelInfo(kernel_info);
2649 ThrowImageException;
2652void Magick::Image::copyPixels(
const Image &source_,
const Geometry &geometry_,
2653 const Offset &offset_)
2662 (void) CopyImagePixels(image(),source_.constImage(),&geometry,&offset,
2664 ThrowImageException;
2667void Magick::Image::crop(
const Geometry &geometry_)
2676 newImage=CropImage(constImage(),&cropInfo,exceptionInfo);
2677 replaceImage(newImage);
2678 ThrowImageException;
2681void Magick::Image::cycleColormap(
const ssize_t amount_)
2685 CycleColormapImage(image(),amount_,exceptionInfo);
2686 ThrowImageException;
2689void Magick::Image::decipher(
const std::string &passphrase_)
2693 DecipherImage(image(),passphrase_.c_str(),exceptionInfo);
2694 ThrowImageException;
2697void Magick::Image::defineSet(
const std::string &magick_,
2698 const std::string &key_,
bool flag_)
2704 definition=magick_ +
":" + key_;
2706 (void) SetImageOption(imageInfo(),definition.c_str(),
"");
2708 DeleteImageOption(imageInfo(),definition.c_str());
2711bool Magick::Image::defineSet(
const std::string &magick_,
2712 const std::string &key_ )
const
2720 key=magick_ +
":" + key_;
2721 option=GetImageOption(constImageInfo(),key.c_str());
2727void Magick::Image::defineValue(
const std::string &magick_,
2728 const std::string &key_,
const std::string &value_)
2735 format=magick_ +
":" + key_;
2737 (void) SetImageOption(imageInfo(),format.c_str(),option.c_str());
2740std::string Magick::Image::defineValue(
const std::string &magick_,
2741 const std::string &key_)
const
2749 definition=magick_ +
":" + key_;
2750 option=GetImageOption(constImageInfo(),definition.c_str());
2752 return(std::string(option));
2753 return(std::string());
2756void Magick::Image::deskew(
const double threshold_)
2762 newImage=DeskewImage(constImage(),threshold_,exceptionInfo);
2763 replaceImage(newImage);
2764 ThrowImageException;
2767void Magick::Image::despeckle(
void)
2773 newImage=DespeckleImage(constImage(),exceptionInfo);
2774 replaceImage(newImage);
2775 ThrowImageException;
2778void Magick::Image::display(
void)
2781 DisplayImages(imageInfo(),image(),exceptionInfo);
2782 ThrowImageException;
2785void Magick::Image::distort(
const DistortMethod method_,
2786 const size_t numberArguments_,
const double *arguments_,
const bool bestfit_)
2792 newImage=DistortImage(constImage(), method_,numberArguments_,arguments_,
2793 bestfit_ ==
true ? MagickTrue : MagickFalse,exceptionInfo);
2794 replaceImage(newImage);
2795 ThrowImageException;
2805 wand=AcquireDrawingWand(options()->drawInfo(),image());
2809 drawable_.operator()(wand);
2813 ClonePPDrawException(wand);
2814 wand=DestroyDrawingWand(wand);
2815 ThrowPPDrawException(quiet());
2819void Magick::Image::draw(
const std::vector<Magick::Drawable> &drawable_)
2826 wand= AcquireDrawingWand(options()->drawInfo(),image());
2830 for (std::vector<Magick::Drawable>::const_iterator p = drawable_.begin();
2831 p != drawable_.end(); p++ )
2833 p->operator()(wand);
2834 if (DrawGetExceptionType(wand) != MagickCore::UndefinedException)
2838 if (DrawGetExceptionType(wand) == MagickCore::UndefinedException)
2841 ClonePPDrawException(wand);
2842 wand=DestroyDrawingWand(wand);
2843 ThrowPPDrawException(quiet());
2847void Magick::Image::edge(
const double radius_)
2853 newImage=EdgeImage(constImage(),radius_,exceptionInfo);
2854 replaceImage(newImage);
2855 ThrowImageException;
2858void Magick::Image::emboss(
const double radius_,
const double sigma_)
2864 newImage=EmbossImage(constImage(),radius_,sigma_,exceptionInfo);
2865 replaceImage(newImage);
2866 ThrowImageException;
2869void Magick::Image::encipher(
const std::string &passphrase_)
2873 EncipherImage(image(),passphrase_.c_str(),exceptionInfo);
2874 ThrowImageException;
2877void Magick::Image::enhance(
void)
2883 newImage=EnhanceImage(constImage(),exceptionInfo);
2884 replaceImage(newImage);
2885 ThrowImageException;
2888void Magick::Image::equalize(
void)
2892 EqualizeImage(image(),exceptionInfo);
2893 ThrowImageException;
2896void Magick::Image::erase(
void)
2900 (void) SetImageBackgroundColor(image(),exceptionInfo);
2901 ThrowImageException;
2904void Magick::Image::evaluate(
const ChannelType channel_,
2905 const MagickEvaluateOperator operator_,
double rvalue_)
2908 GetAndSetPPChannelMask(channel_);
2909 EvaluateImage(image(),operator_,rvalue_,exceptionInfo);
2910 RestorePPChannelMask;
2911 ThrowImageException;
2914void Magick::Image::evaluate(
const ChannelType channel_,
2915 const MagickFunction function_,
const size_t number_parameters_,
2916 const double *parameters_)
2919 GetAndSetPPChannelMask(channel_);
2920 FunctionImage(image(),function_,number_parameters_,parameters_,
2922 RestorePPChannelMask;
2923 ThrowImageException;
2926void Magick::Image::evaluate(
const ChannelType channel_,
const ssize_t x_,
2927 const ssize_t y_,
const size_t columns_,
const size_t rows_,
2928 const MagickEvaluateOperator operator_,
const double rvalue_)
2936 geometry.width = columns_;
2937 geometry.height = rows_;
2942 cropImage=CropImage(image(),&geometry,exceptionInfo);
2943 GetAndSetPPChannelMask(channel_);
2944 EvaluateImage(cropImage,operator_,rvalue_,exceptionInfo);
2945 RestorePPChannelMask;
2946 (void) CompositeImage(image(),cropImage,image()->alpha_trait ==
2947 BlendPixelTrait ? OverCompositeOp : CopyCompositeOp,MagickFalse,
2948 geometry.x,geometry.y,exceptionInfo );
2949 cropImage=DestroyImageList(cropImage);
2950 ThrowImageException;
2953void Magick::Image::extent(
const Geometry &geometry_ )
2959 extentInfo=geometry_;
2962 extentInfo.x=geometry_.xOff();
2963 extentInfo.y=geometry_.yOff();
2965 newImage=ExtentImage(image(),&extentInfo,exceptionInfo);
2966 replaceImage(newImage);
2967 ThrowImageException;
2970void Magick::Image::extent(
const Geometry &geometry_,
2971 const Color &backgroundColor_)
2973 backgroundColor(backgroundColor_);
2977void Magick::Image::extent(
const Geometry &geometry_,
2978 const Color &backgroundColor_,
const GravityType gravity_)
2980 backgroundColor(backgroundColor_);
2981 extent(geometry_,gravity_);
2984void Magick::Image::extent(
const Geometry &geometry_,
2985 const GravityType gravity_)
2990 SetGeometry(image(),&geometry);
2991 geometry.width=geometry_.width();
2992 geometry.height=geometry_.height();
2993 GravityAdjustGeometry(image()->columns,image()->rows,gravity_,&geometry);
2997void Magick::Image::flip(
void)
3003 newImage=FlipImage(constImage(),exceptionInfo);
3004 replaceImage(newImage);
3005 ThrowImageException;
3008void Magick::Image::floodFillAlpha(
const ssize_t x_,
const ssize_t y_,
3009 const unsigned int alpha_,
const bool invert_)
3016 target=
static_cast<PixelInfo
>(pixelColor(x_,y_));
3017 target.alpha=alpha_;
3019 GetAndSetPPChannelMask(AlphaChannel);
3020 FloodfillPaintImage(image(),options()->drawInfo(),&target,x_,y_,
3021 (MagickBooleanType)invert_,exceptionInfo);
3022 RestorePPChannelMask;
3023 ThrowImageException;
3026void Magick::Image::floodFillAlpha(
const ssize_t x_,
const ssize_t y_,
3027 const unsigned int alpha_,
const Color &target_,
const bool invert_)
3034 target=
static_cast<PixelInfo
>(target_);
3035 target.alpha=alpha_;
3037 GetAndSetPPChannelMask(AlphaChannel);
3038 FloodfillPaintImage(image(),options()->drawInfo(),&target,x_,y_,
3039 (MagickBooleanType)invert_,exceptionInfo);
3040 RestorePPChannelMask;
3041 ThrowImageException;
3044void Magick::Image::floodFillColor(
const Geometry &point_,
3047 floodFillColor(point_.xOff(),point_.yOff(),fillColor_,invert_);
3050void Magick::Image::floodFillColor(
const ssize_t x_,
const ssize_t y_,
3058 pixel=
static_cast<PixelInfo
>(pixelColor(x_,y_));
3059 floodFill(x_,y_,(
Magick::Image *)NULL,fillColor_,&pixel,invert_);
3062void Magick::Image::floodFillColor(
const Geometry &point_,
3066 floodFillColor(point_.xOff(),point_.yOff(),fillColor_,borderColor_,invert_);
3069void Magick::Image::floodFillColor(
const ssize_t x_,
const ssize_t y_,
3078 pixel=
static_cast<PixelInfo
>(borderColor_);
3079 floodFill(x_,y_,(
Magick::Image *)NULL,fillColor_,&pixel,invert_);
3085 floodFillTexture(point_.xOff(),point_.yOff(),texture_,invert_);
3088void Magick::Image::floodFillTexture(
const ssize_t x_,
const ssize_t y_,
3096 pixel=
static_cast<PixelInfo
>(pixelColor(x_,y_));
3104 floodFillTexture(point_.xOff(),point_.yOff(),texture_,borderColor_,invert_);
3107void Magick::Image::floodFillTexture(
const ssize_t x_,
const ssize_t y_,
3116 pixel=
static_cast<PixelInfo
>(borderColor_);
3120void Magick::Image::flop(
void)
3126 newImage=FlopImage(constImage(),exceptionInfo);
3127 replaceImage(newImage);
3128 ThrowImageException;
3131void Magick::Image::fontTypeMetrics(
const std::string &text_,
3132 TypeMetric *metrics)
3137 drawInfo=options()->drawInfo();
3138 drawInfo->text=DestroyString(drawInfo->text);
3139 drawInfo->text=
const_cast<char *
>(text_.c_str());
3141 GetTypeMetrics(image(),drawInfo,&(metrics->_typeMetric),exceptionInfo);
3142 drawInfo->text=(
char *) NULL;
3143 ThrowImageException;
3146void Magick::Image::fontTypeMetricsMultiline(
const std::string &text_,
3147 TypeMetric *metrics)
3152 drawInfo=options()->drawInfo();
3153 drawInfo->text=DestroyString(drawInfo->text);
3154 drawInfo->text=
const_cast<char *
>(text_.c_str());
3156 (void) GetMultilineTypeMetrics(image(),drawInfo,&(metrics->_typeMetric),
3158 drawInfo->text=(
char *) NULL;
3159 ThrowImageException;
3162void Magick::Image::frame(
const Geometry &geometry_)
3170 info.x=
static_cast<ssize_t
>(geometry_.width());
3171 info.y=
static_cast<ssize_t
>(geometry_.height());
3172 info.width=columns() + (
static_cast<size_t>(info.x) << 1);
3173 info.height=rows() + (
static_cast<size_t>(info.y) << 1);
3174 info.outer_bevel=geometry_.xOff();
3175 info.inner_bevel=geometry_.yOff();
3178 newImage=FrameImage(constImage(),&info,image()->compose,exceptionInfo);
3179 replaceImage(newImage);
3180 ThrowImageException;
3183void Magick::Image::frame(
const size_t width_,
const size_t height_,
3184 const ssize_t innerBevel_,
const ssize_t outerBevel_)
3192 info.x=
static_cast<ssize_t
>(width_);
3193 info.y=
static_cast<ssize_t
>(height_);
3194 info.width=columns() + (
static_cast<size_t>(info.x) << 1);
3195 info.height=rows() + (
static_cast<size_t>(info.y) << 1);
3196 info.outer_bevel=
static_cast<ssize_t
>(outerBevel_);
3197 info.inner_bevel=
static_cast<ssize_t
>(innerBevel_);
3200 newImage=FrameImage(constImage(),&info,image()->compose,exceptionInfo);
3201 replaceImage(newImage);
3202 ThrowImageException;
3205void Magick::Image::fx(
const std::string expression_)
3211 newImage=FxImage(constImage(),expression_.c_str(),exceptionInfo);
3212 replaceImage(newImage);
3213 ThrowImageException;
3216void Magick::Image::fx(
const std::string expression_,
3217 const Magick::ChannelType channel_)
3223 GetAndSetPPChannelMask(channel_);
3224 newImage=FxImage(constImage(),expression_.c_str(),exceptionInfo);
3225 RestorePPChannelMask;
3226 replaceImage(newImage);
3227 ThrowImageException;
3230void Magick::Image::gamma(
const double gamma_)
3234 GammaImage(image(),gamma_,exceptionInfo);
3235 ThrowImageException;
3238void Magick::Image::gamma(
const double gammaRed_,
const double gammaGreen_,
3239 const double gammaBlue_)
3243 GetAndSetPPChannelMask(RedChannel);
3244 (void) GammaImage(image(),gammaRed_,exceptionInfo);
3245 SetPPChannelMask(GreenChannel);
3246 (void) GammaImage(image(),gammaGreen_,exceptionInfo);
3247 SetPPChannelMask(BlueChannel);
3248 (void) GammaImage(image(),gammaBlue_,exceptionInfo);
3249 RestorePPChannelMask;
3250 ThrowImageException;
3253void Magick::Image::gaussianBlur(
const double radius_,
const double sigma_)
3259 newImage=GaussianBlurImage(constImage(),radius_,sigma_,exceptionInfo);
3260 replaceImage(newImage);
3261 ThrowImageException;
3264void Magick::Image::gaussianBlurChannel(
const ChannelType channel_,
3265 const double radius_,
const double sigma_)
3271 GetAndSetPPChannelMask(channel_);
3272 newImage=GaussianBlurImage(constImage(),radius_,sigma_,exceptionInfo);
3273 RestorePPChannelMask;
3274 replaceImage(newImage);
3275 ThrowImageException;
3278const Magick::Quantum *Magick::Image::getConstPixels(
const ssize_t x_,
3279 const ssize_t y_,
const size_t columns_,
const size_t rows_)
const
3285 p=GetVirtualPixels(constImage(),x_, y_,columns_, rows_,exceptionInfo);
3286 ThrowImageException;
3290const void *Magick::Image::getConstMetacontent(
void)
const
3295 result=GetVirtualMetacontent(constImage());
3298 throwExceptionExplicit(MagickCore::OptionError,
3299 "Unable to retrieve meta content.");
3304void *Magick::Image::getMetacontent(
void )
3309 result=GetAuthenticMetacontent(image());
3312 throwExceptionExplicit(MagickCore::OptionError,
3313 "Unable to retrieve meta content.");
3318Magick::Quantum *Magick::Image::getPixels(
const ssize_t x_,
const ssize_t y_,
3319 const size_t columns_,
const size_t rows_)
3326 result=GetAuthenticPixels(image(),x_, y_,columns_,rows_,exceptionInfo);
3327 ThrowImageException;
3332void Magick::Image::grayscale(
const PixelIntensityMethod method_)
3336 (void) GrayscaleImage(image(),method_,exceptionInfo);
3337 ThrowImageException;
3340void Magick::Image::haldClut(
const Image &clutImage_)
3344 (void) HaldClutImage(image(),clutImage_.constImage(),exceptionInfo);
3345 ThrowImageException;
3348void Magick::Image::houghLine(
const size_t width_,
const size_t height_,
3349 const size_t threshold_)
3355 newImage=HoughLineImage(constImage(),width_,height_,threshold_,
3357 replaceImage(newImage);
3358 ThrowImageException;
3361Magick::ImageType Magick::Image::identifyType(
void)
const
3367 image_type=IdentifyImageType(constImage(),exceptionInfo);
3368 ThrowImageException;
3372void Magick::Image::implode(
const double factor_)
3378 newImage=ImplodeImage(constImage(),factor_,image()->interpolate,
3380 replaceImage(newImage);
3381 ThrowImageException;
3384void Magick::Image::inverseFourierTransform(
const Image &phase_)
3386 inverseFourierTransform(phase_,
true);
3389void Magick::Image::inverseFourierTransform(
const Image &phase_,
3390 const bool magnitude_)
3396 newImage=InverseFourierTransformImage(constImage(),phase_.constImage(),
3397 magnitude_ ==
true ? MagickTrue : MagickFalse,exceptionInfo);
3398 replaceImage(newImage);
3399 ThrowImageException;
3402void Magick::Image::kuwahara(
const double radius_,
const double sigma_)
3408 newImage=KuwaharaImage(constImage(),radius_,sigma_,exceptionInfo);
3409 replaceImage(newImage);
3410 ThrowImageException;
3413void Magick::Image::kuwaharaChannel(
const ChannelType channel_,
3414 const double radius_,
const double sigma_)
3420 GetAndSetPPChannelMask(channel_);
3421 newImage=KuwaharaImage(constImage(),radius_,sigma_,exceptionInfo);
3422 replaceImage(newImage);
3423 RestorePPChannelMask;
3424 ThrowImageException;
3427void Magick::Image::level(
const double blackPoint_,
const double whitePoint_,
3428 const double gamma_)
3432 (void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
3433 ThrowImageException;
3436void Magick::Image::levelChannel(
const ChannelType channel_,
3437 const double blackPoint_,
const double whitePoint_,
const double gamma_)
3441 GetAndSetPPChannelMask(channel_);
3442 (void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
3443 RestorePPChannelMask;
3444 ThrowImageException;
3447void Magick::Image::levelColors(
const Color &blackColor_,
3448 const Color &whiteColor_,
const bool invert_)
3456 black=
static_cast<PixelInfo
>(blackColor_);
3457 white=
static_cast<PixelInfo
>(whiteColor_);
3459 (void) LevelImageColors(image(),&black,&white,invert_ ==
true ?
3460 MagickTrue : MagickFalse,exceptionInfo);
3461 ThrowImageException;
3464void Magick::Image::levelColorsChannel(
const ChannelType channel_,
3465 const Color &blackColor_,
const Color &whiteColor_,
const bool invert_)
3473 black=
static_cast<PixelInfo
>(blackColor_);
3474 white=
static_cast<PixelInfo
>(whiteColor_);
3476 GetAndSetPPChannelMask(channel_);
3477 (void) LevelImageColors(image(),&black,&white,invert_ ==
true ?
3478 MagickTrue : MagickFalse,exceptionInfo);
3479 RestorePPChannelMask;
3480 ThrowImageException;
3483void Magick::Image::levelize(
const double blackPoint_,
const double whitePoint_,
3484 const double gamma_)
3488 (void) LevelizeImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
3489 ThrowImageException;
3492void Magick::Image::levelizeChannel(
const ChannelType channel_,
3493 const double blackPoint_,
const double whitePoint_,
const double gamma_)
3497 GetAndSetPPChannelMask(channel_);
3498 (void) LevelizeImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
3499 RestorePPChannelMask;
3500 ThrowImageException;
3503void Magick::Image::linearStretch(
const double blackPoint_,
3504 const double whitePoint_)
3508 LinearStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
3509 ThrowImageException;
3512void Magick::Image::liquidRescale(
const Geometry &geometry_)
3525 ParseMetaGeometry(
static_cast<std::string
>(geometry_).c_str(),&x,&y,&width,
3529 newImage=LiquidRescaleImage(image(),width,height,x,y,exceptionInfo);
3530 replaceImage(newImage);
3531 ThrowImageException;
3534void Magick::Image::localContrast(
const double radius_,
const double strength_)
3540 newImage=LocalContrastImage(constImage(),radius_,strength_,exceptionInfo);
3541 replaceImage(newImage);
3542 ThrowImageException;
3545void Magick::Image::localContrastChannel(
const ChannelType channel_,
3546 const double radius_,
const double strength_)
3552 GetAndSetPPChannelMask(channel_);
3553 newImage=LocalContrastImage(constImage(),radius_,strength_,exceptionInfo);
3554 RestorePPChannelMask;
3555 replaceImage(newImage);
3556 ThrowImageException;
3559void Magick::Image::magnify(
void)
3565 newImage=MagnifyImage(constImage(),exceptionInfo);
3566 replaceImage(newImage);
3567 ThrowImageException;
3570void Magick::Image::map(
const Image &mapImage_,
const bool dither_)
3574 options()->quantizeDither(dither_);
3575 RemapImage(options()->quantizeInfo(),image(),mapImage_.constImage(),
3577 ThrowImageException;
3580void Magick::Image::meanShift(
const size_t width_,
const size_t height_,
3581 const double color_distance_)
3587 newImage=MeanShiftImage(constImage(),width_,height_,color_distance_,
3589 replaceImage(newImage);
3590 ThrowImageException;
3593void Magick::Image::medianFilter(
const double radius_)
3599 newImage=StatisticImage(image(),MedianStatistic,(
size_t) radius_,
3600 (
size_t) radius_,exceptionInfo);
3601 replaceImage(newImage);
3602 ThrowImageException;
3605void Magick::Image::minify(
void)
3611 newImage=MinifyImage(constImage(),exceptionInfo);
3612 replaceImage(newImage);
3613 ThrowImageException;
3616void Magick::Image::modulate(
const double brightness_,
const double saturation_,
3620 modulate[MagickPathExtent + 1];
3622 FormatLocaleString(modulate,MagickPathExtent,
"%3.6f,%3.6f,%3.6f",brightness_,
3627 ModulateImage(image(),modulate,exceptionInfo);
3628 ThrowImageException;
3633 return(ImageMoments(*
this));
3636void Magick::Image::morphology(
const MorphologyMethod method_,
3637 const std::string kernel_,
const ssize_t iterations_)
3646 kernel=AcquireKernelInfo(kernel_.c_str(),exceptionInfo);
3647 if (kernel == (KernelInfo *) NULL)
3648 throwExceptionExplicit(MagickCore::OptionError,
"Unable to parse kernel.");
3649 newImage=MorphologyImage(constImage(),method_,iterations_,kernel,
3651 replaceImage(newImage);
3652 kernel=DestroyKernelInfo(kernel);
3653 ThrowImageException;
3656void Magick::Image::morphology(
const MorphologyMethod method_,
3657 const KernelInfoType kernel_,
const std::string arguments_,
3658 const ssize_t iterations_)
3666 option=CommandOptionToMnemonic(MagickKernelOptions,kernel_);
3667 if (option == (
const char *)NULL)
3669 throwExceptionExplicit(MagickCore::OptionError,
3670 "Unable to determine kernel type.");
3673 kernel=std::string(option);
3674 if (!arguments_.empty())
3675 kernel+=
":"+arguments_;
3677 morphology(method_,kernel,iterations_);
3680void Magick::Image::morphologyChannel(
const ChannelType channel_,
3681 const MorphologyMethod method_,
const std::string kernel_,
3682 const ssize_t iterations_)
3692 kernel=AcquireKernelInfo(kernel_.c_str(),exceptionInfo);
3693 if (kernel == (KernelInfo *)NULL)
3695 throwExceptionExplicit(MagickCore::OptionError,
3696 "Unable to parse kernel.");
3699 GetAndSetPPChannelMask(channel_);
3700 newImage=MorphologyImage(constImage(),method_,iterations_,kernel,
3702 RestorePPChannelMask;
3703 replaceImage(newImage);
3704 kernel=DestroyKernelInfo(kernel);
3705 ThrowImageException;
3708void Magick::Image::morphologyChannel(
const ChannelType channel_,
3709 const MorphologyMethod method_,
const KernelInfoType kernel_,
3710 const std::string arguments_,
const ssize_t iterations_)
3718 option=CommandOptionToMnemonic(MagickKernelOptions,kernel_);
3719 if (option == (
const char *)NULL)
3721 throwExceptionExplicit(MagickCore::OptionError,
3722 "Unable to determine kernel type.");
3726 kernel=std::string(option);
3727 if (!arguments_.empty())
3728 kernel+=
":"+arguments_;
3730 morphologyChannel(channel_,method_,kernel,iterations_);
3733void Magick::Image::motionBlur(
const double radius_,
const double sigma_,
3734 const double angle_)
3740 newImage=MotionBlurImage(constImage(),radius_,sigma_,angle_,exceptionInfo);
3741 replaceImage(newImage);
3742 ThrowImageException;
3745void Magick::Image::negate(
const bool grayscale_)
3749 NegateImage(image(),(MagickBooleanType) grayscale_,exceptionInfo);
3750 ThrowImageException;
3753void Magick::Image::negateChannel(
const ChannelType channel_,
3754 const bool grayscale_)
3758 GetAndSetPPChannelMask(channel_);
3759 NegateImage(image(),(MagickBooleanType) grayscale_,exceptionInfo);
3760 RestorePPChannelMask;
3761 ThrowImageException;
3764void Magick::Image::normalize(
void)
3768 NormalizeImage(image(),exceptionInfo);
3769 ThrowImageException;
3772void Magick::Image::oilPaint(
const double radius_,
const double sigma_)
3778 newImage=OilPaintImage(constImage(),radius_,sigma_,exceptionInfo);
3779 replaceImage(newImage);
3780 ThrowImageException;
3783void Magick::Image::opaque(
const Color &opaqueColor_,
const Color &penColor_,
3794 if (!opaqueColor_.isValid())
3795 throwExceptionExplicit(MagickCore::OptionError,
3796 "Opaque color argument is invalid");
3798 if (!penColor_.isValid())
3799 throwExceptionExplicit(MagickCore::OptionError,
3800 "Pen color argument is invalid");
3803 opaqueColor=opaqueColor_;
3807 (void) QueryColorCompliance(opaqueColor.c_str(),AllCompliance,&opaque,
3809 (void) QueryColorCompliance(penColor.c_str(),AllCompliance,&pen,
3811 OpaquePaintImage(image(),&opaque,&pen,invert_ ? MagickTrue : MagickFalse,
3813 ThrowImageException;
3816void Magick::Image::orderedDither(std::string thresholdMap_)
3820 (void) OrderedDitherImage(image(),thresholdMap_.c_str(),exceptionInfo);
3821 ThrowImageException;
3824void Magick::Image::orderedDitherChannel(
const ChannelType channel_,
3825 std::string thresholdMap_)
3829 GetAndSetPPChannelMask(channel_);
3830 (void)OrderedDitherImage(image(),thresholdMap_.c_str(),exceptionInfo);
3831 RestorePPChannelMask;
3832 ThrowImageException;
3835void Magick::Image::perceptible(
const double epsilon_)
3839 PerceptibleImage(image(),epsilon_,exceptionInfo);
3840 ThrowImageException;
3843void Magick::Image::perceptibleChannel(
const ChannelType channel_,
3844 const double epsilon_)
3848 GetAndSetPPChannelMask(channel_);
3849 PerceptibleImage(image(),epsilon_,exceptionInfo);
3850 RestorePPChannelMask;
3851 ThrowImageException;
3856 return(ImagePerceptualHash(*
this));
3859void Magick::Image::ping(
const std::string &imageSpec_)
3865 options()->fileName(imageSpec_);
3866 newImage=PingImage(imageInfo(),exceptionInfo);
3867 read(newImage,exceptionInfo);
3870void Magick::Image::ping(
const Blob& blob_)
3876 newImage=PingBlob(imageInfo(),blob_.data(),blob_.length(),exceptionInfo);
3877 read(newImage,exceptionInfo);
3880void Magick::Image::pixelColor(
const ssize_t x_,
const ssize_t y_,
3881 const Color &color_)
3890 if (y_ > (ssize_t) rows() || x_ > (ssize_t) columns())
3891 throwExceptionExplicit(MagickCore::OptionError,
3892 "Access outside of image boundary");
3897 classType(DirectClass );
3900 Pixels pixels(*
this);
3902 pixel=pixels.get(x_, y_, 1, 1 );
3904 MagickCore::SetPixelViaPixelInfo(constImage(),&packet,pixel);
3910 const ssize_t y_)
const
3915 pixel=getConstPixels(x_,y_,1,1);
3921 MagickCore::GetPixelInfoPixel(constImage(),pixel,&packet);
3922 return(Color(packet));
3928void Magick::Image::polaroid(
const std::string &caption_,
const double angle_,
3929 const PixelInterpolateMethod method_)
3935 newImage=PolaroidImage(constImage(),options()->drawInfo(),caption_.c_str(),
3936 angle_,method_,exceptionInfo);
3937 replaceImage(newImage);
3938 ThrowImageException;
3941void Magick::Image::posterize(
const size_t levels_,
const DitherMethod method_)
3945 PosterizeImage(image(),levels_,method_,exceptionInfo);
3946 ThrowImageException;
3949void Magick::Image::posterizeChannel(
const ChannelType channel_,
3950 const size_t levels_,
const DitherMethod method_)
3954 GetAndSetPPChannelMask(channel_);
3955 PosterizeImage(image(),levels_,method_,exceptionInfo);
3956 RestorePPChannelMask;
3957 ThrowImageException;
3960void Magick::Image::process(std::string name_,
const ssize_t argc,
3966 (void) InvokeDynamicImageFilter(name_.c_str(),&image(),argc,argv,
3968 ThrowImageException;
3971void Magick::Image::profile(
const std::string name_,
3976 (void) ProfileImage(image(),name_.c_str(),(
unsigned char *)profile_.data(),
3977 profile_.length(),exceptionInfo);
3978 ThrowImageException;
3981Magick::Blob Magick::Image::profile(
const std::string name_)
const
3986 profile=GetImageProfile(constImage(),name_.c_str());
3988 if (profile == (StringInfo *) NULL)
3990 return(Blob((
void*) GetStringInfoDatum(profile),GetStringInfoLength(
3994void Magick::Image::quantize(
const bool measureError_)
3999 options()->quantizeInfo()->measure_error=MagickTrue;
4001 options()->quantizeInfo()->measure_error=MagickFalse;
4004 QuantizeImage(options()->quantizeInfo(),image(),exceptionInfo);
4005 ThrowImageException;
4008void Magick::Image::raise(
const Geometry &geometry_,
const bool raisedFlag_)
4011 raiseInfo=geometry_;
4015 RaiseImage(image(),&raiseInfo,raisedFlag_ ==
true ? MagickTrue : MagickFalse,
4017 ThrowImageException;
4020void Magick::Image::randomThreshold(
const double low_,
const double high_)
4023 (void) RandomThresholdImage(image(),low_,high_,exceptionInfo);
4024 ThrowImageException;
4027void Magick::Image::randomThresholdChannel(
const ChannelType channel_,
4028 const double low_,
const double high_)
4032 GetAndSetPPChannelMask(channel_);
4033 (void) RandomThresholdImage(image(),low_,high_,exceptionInfo);
4034 RestorePPChannelMask;
4035 ThrowImageException;
4038void Magick::Image::read(
const Blob &blob_)
4044 newImage=BlobToImage(imageInfo(),
static_cast<const void *
>(blob_.data()),
4045 blob_.length(),exceptionInfo);
4046 read(newImage,exceptionInfo);
4049void Magick::Image::read(
const Blob &blob_,
const Geometry &size_)
4055void Magick::Image::read(
const Blob &blob_,
const Geometry &size_,
4056 const size_t depth_)
4063void Magick::Image::read(
const Blob &blob_,
const Geometry &size_,
4064 const size_t depth_,
const std::string &magick_)
4070 fileName(magick_ +
':');
4074void Magick::Image::read(
const Blob &blob_,
const Geometry &size_,
4075 const std::string &magick_)
4080 fileName(magick_ +
':');
4084void Magick::Image::read(
const Geometry &size_,
const std::string &imageSpec_)
4090void Magick::Image::read(
const size_t width_,
const size_t height_,
4091 const std::string &map_,
const StorageType type_,
const void *pixels_)
4097 newImage=ConstituteImage(width_,height_,map_.c_str(),type_, pixels_,
4099 replaceImage(newImage);
4100 ThrowImageException;
4103void Magick::Image::read(
const std::string &imageSpec_)
4109 options()->fileName(imageSpec_);
4110 newImage=ReadImage(imageInfo(),exceptionInfo);
4111 read(newImage,exceptionInfo);
4116 mask(mask_,ReadPixelMask);
4121 return(mask(ReadPixelMask));
4124void Magick::Image::readPixels(
const Magick::QuantumType quantum_,
4125 const unsigned char *source_)
4130 quantum_info=AcquireQuantumInfo(imageInfo(),image());
4132 ImportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
4133 quantum_,source_,exceptionInfo);
4134 quantum_info=DestroyQuantumInfo(quantum_info);
4135 ThrowImageException;
4138void Magick::Image::reduceNoise(
void)
4143void Magick::Image::reduceNoise(
const size_t order_)
4149 newImage=StatisticImage(constImage(),NonpeakStatistic,order_,
4150 order_,exceptionInfo);
4151 replaceImage(newImage);
4152 ThrowImageException;
4155void Magick::Image::repage()
4158 options()->page(Geometry());
4159 image()->page.width = 0;
4160 image()->page.height = 0;
4161 image()->page.x = 0;
4162 image()->page.y = 0;
4165void Magick::Image::resample(
const Point &density_)
4171 newImage=ResampleImage(constImage(),density_.x(),density_.y(),
4172 image()->filter,exceptionInfo);
4173 replaceImage(newImage);
4174 ThrowImageException;
4177void Magick::Image::resize(
const Geometry &geometry_)
4192 ParseMetaGeometry(
static_cast<std::string
>(geometry_).c_str(),&x,&y,&width,
4196 newImage=ResizeImage(constImage(),width,height,image()->filter,
4198 replaceImage(newImage);
4199 ThrowImageException;
4202void Magick::Image::roll(
const Geometry &roll_)
4208 newImage=RollImage(constImage(),roll_.xOff(),roll_.yOff(),exceptionInfo);
4209 replaceImage(newImage);
4210 ThrowImageException;
4213void Magick::Image::roll(
const ssize_t columns_,
const ssize_t rows_)
4219 newImage=RollImage(constImage(),columns_, rows_,exceptionInfo);
4220 replaceImage(newImage);
4221 ThrowImageException;
4224void Magick::Image::rotate(
const double degrees_)
4230 newImage=RotateImage(constImage(),degrees_,exceptionInfo);
4231 replaceImage(newImage);
4232 ThrowImageException;
4235void Magick::Image::rotationalBlur(
const double angle_)
4241 newImage=RotationalBlurImage(constImage(),angle_,exceptionInfo);
4242 replaceImage(newImage);
4243 ThrowImageException;
4246void Magick::Image::rotationalBlurChannel(
const ChannelType channel_,
4247 const double angle_)
4253 GetAndSetPPChannelMask(channel_);
4254 newImage=RotationalBlurImage(constImage(),angle_,exceptionInfo);
4255 RestorePPChannelMask;
4256 replaceImage(newImage);
4257 ThrowImageException;
4260void Magick::Image::sample(
const Geometry &geometry_)
4273 ParseMetaGeometry(
static_cast<std::string
>(geometry_).c_str(),&x,&y,&width,
4277 newImage=SampleImage(constImage(),width,height,exceptionInfo);
4278 replaceImage(newImage);
4279 ThrowImageException;
4282void Magick::Image::scale(
const Geometry &geometry_)
4295 ParseMetaGeometry(
static_cast<std::string
>(geometry_).c_str(),&x,&y,&width,
4299 newImage=ScaleImage(constImage(),width,height,exceptionInfo);
4300 replaceImage(newImage);
4301 ThrowImageException;
4304void Magick::Image::segment(
const double clusterThreshold_,
4305 const double smoothingThreshold_)
4309 SegmentImage(image(),options()->quantizeColorSpace(),
4310 (MagickBooleanType) options()->verbose(),clusterThreshold_,
4311 smoothingThreshold_,exceptionInfo);
4312 SyncImage(image(),exceptionInfo);
4313 ThrowImageException;
4316void Magick::Image::selectiveBlur(
const double radius_,
const double sigma_,
4317 const double threshold_)
4323 newImage=SelectiveBlurImage(constImage(),radius_,sigma_,threshold_,
4325 replaceImage(newImage);
4326 ThrowImageException;
4329void Magick::Image::selectiveBlurChannel(
const ChannelType channel_,
4330 const double radius_,
const double sigma_,
const double threshold_)
4336 GetAndSetPPChannelMask(channel_);
4337 newImage=SelectiveBlurImage(constImage(),radius_,sigma_,threshold_,
4339 RestorePPChannelMask;
4340 replaceImage(newImage);
4341 ThrowImageException;
4344Magick::Image Magick::Image::separate(
const ChannelType channel_)
const
4350 image=SeparateImage(constImage(),channel_,exceptionInfo);
4351 ThrowImageException;
4352 if (image == (MagickCore::Image *) NULL)
4358void Magick::Image::sepiaTone(
const double threshold_)
4364 newImage=SepiaToneImage(constImage(),threshold_,exceptionInfo);
4365 replaceImage(newImage);
4366 ThrowImageException;
4369bool Magick::Image::setColorMetric(
const Image &reference_)
4379 status=
static_cast<bool>(SetImageColorMetric(image(),ref.constImage(),
4381 ThrowImageException;
4385Magick::Quantum *Magick::Image::setPixels(
const ssize_t x_,
const ssize_t y_,
4386 const size_t columns_,
const size_t rows_)
4393 result=QueueAuthenticPixels(image(),x_,y_,columns_,rows_,exceptionInfo);
4394 ThrowImageException;
4398void Magick::Image::shade(
const double azimuth_,
const double elevation_,
4399 const bool colorShading_)
4405 newImage=ShadeImage(constImage(),colorShading_ ==
true ?
4406 MagickTrue : MagickFalse,azimuth_,elevation_,exceptionInfo);
4407 replaceImage(newImage);
4408 ThrowImageException;
4411void Magick::Image::shadow(
const double percent_opacity_,
const double sigma_,
4412 const ssize_t x_,
const ssize_t y_)
4418 newImage=ShadowImage(constImage(),percent_opacity_, sigma_,x_, y_,
4420 replaceImage(newImage);
4421 ThrowImageException;
4424void Magick::Image::sharpen(
const double radius_,
const double sigma_)
4430 newImage=SharpenImage(constImage(),radius_,sigma_,exceptionInfo);
4431 replaceImage(newImage);
4432 ThrowImageException;
4435void Magick::Image::sharpenChannel(
const ChannelType channel_,
4436 const double radius_,
const double sigma_)
4442 GetAndSetPPChannelMask(channel_);
4443 newImage=SharpenImage(constImage(),radius_,sigma_,exceptionInfo);
4444 RestorePPChannelMask;
4445 replaceImage(newImage);
4446 ThrowImageException;
4449void Magick::Image::shave(
const Geometry &geometry_)
4455 shaveInfo=geometry_;
4458 newImage=ShaveImage(constImage(),&shaveInfo,exceptionInfo);
4459 replaceImage(newImage);
4460 ThrowImageException;
4463void Magick::Image::shear(
const double xShearAngle_,
const double yShearAngle_)
4469 newImage=ShearImage(constImage(),xShearAngle_,yShearAngle_,exceptionInfo);
4470 replaceImage(newImage);
4471 ThrowImageException;
4474void Magick::Image::sigmoidalContrast(
const bool sharpen_,
4475 const double contrast,
const double midpoint)
4479 (void) SigmoidalContrastImage(image(),(MagickBooleanType) sharpen_,contrast,
4480 midpoint,exceptionInfo);
4481 ThrowImageException;
4484std::string Magick::Image::signature(
const bool force_)
const
4486 return(_imgRef->signature(force_));
4489void Magick::Image::sketch(
const double radius_,
const double sigma_,
4490 const double angle_)
4496 newImage=SketchImage(constImage(),radius_,sigma_,angle_,exceptionInfo);
4497 replaceImage(newImage);
4498 ThrowImageException;
4501void Magick::Image::solarize(
const double factor_)
4505 SolarizeImage(image(),factor_,exceptionInfo);
4506 ThrowImageException;
4509void Magick::Image::sparseColor(
const ChannelType channel_,
4510 const SparseColorMethod method_,
const size_t numberArguments_,
4511 const double *arguments_)
4517 GetAndSetPPChannelMask(channel_);
4518 newImage=SparseColorImage(constImage(),method_,numberArguments_,arguments_,
4520 RestorePPChannelMask;
4521 replaceImage(newImage);
4522 ThrowImageException;
4525void Magick::Image::splice(
const Geometry &geometry_)
4531 spliceInfo=geometry_;
4534 newImage=SpliceImage(constImage(),&spliceInfo,exceptionInfo);
4535 replaceImage(newImage);
4536 ThrowImageException;
4539void Magick::Image::splice(
const Geometry &geometry_,
4540 const Color &backgroundColor_)
4542 backgroundColor(backgroundColor_);
4546void Magick::Image::splice(
const Geometry &geometry_,
4547 const Color &backgroundColor_,
const GravityType gravity_)
4549 backgroundColor(backgroundColor_);
4550 image()->gravity=gravity_;
4554void Magick::Image::spread(
const double amount_)
4560 newImage=SpreadImage(constImage(),image()->interpolate,amount_,exceptionInfo);
4561 replaceImage(newImage);
4562 ThrowImageException;
4567 return(ImageStatistics(*
this));
4570void Magick::Image::stegano(
const Image &watermark_)
4576 newImage=SteganoImage(constImage(),watermark_.constImage(),exceptionInfo);
4577 replaceImage(newImage);
4578 ThrowImageException;
4581void Magick::Image::stereo(
const Image &rightImage_)
4587 newImage=StereoImage(constImage(),rightImage_.constImage(),exceptionInfo);
4588 replaceImage(newImage);
4589 ThrowImageException;
4592void Magick::Image::strip(
void)
4596 StripImage(image(),exceptionInfo);
4597 ThrowImageException;
4600Magick::Image Magick::Image::subImageSearch(
const Image &reference_,
4601 const MetricType metric_,Geometry *offset_,
double *similarityMetric_,
4602 const double similarityThreshold)
4611 newImage=SimilarityImage(image(),reference_.constImage(),metric_,
4612 similarityThreshold,&offset,similarityMetric_,exceptionInfo);
4613 ThrowImageException;
4614 if (offset_ != (Geometry *) NULL)
4616 if (newImage == (MagickCore::Image *) NULL)
4622void Magick::Image::swirl(
const double degrees_)
4628 newImage=SwirlImage(constImage(),degrees_,image()->interpolate,
4630 replaceImage(newImage);
4631 ThrowImageException;
4634void Magick::Image::syncPixels(
void)
4637 (void) SyncAuthenticPixels(image(),exceptionInfo);
4638 ThrowImageException;
4641void Magick::Image::texture(
const Image &texture_)
4645 TextureImage(image(),texture_.constImage(),exceptionInfo);
4646 ThrowImageException;
4649void Magick::Image::threshold(
const double threshold_)
4653 BilevelImage(image(),threshold_,exceptionInfo);
4654 ThrowImageException;
4657void Magick::Image::thumbnail(
const Geometry &geometry_)
4670 ParseMetaGeometry(
static_cast<std::string
>(geometry_).c_str(),&x,&y,&width,
4674 newImage=ThumbnailImage(constImage(),width,height,exceptionInfo);
4675 replaceImage(newImage);
4676 ThrowImageException;
4679void Magick::Image::tint(
const std::string opacity_)
4688 color=
static_cast<PixelInfo
>(constOptions()->fillColor());
4689 newImage=TintImage(constImage(),opacity_.c_str(),&color,exceptionInfo);
4690 replaceImage(newImage);
4691 ThrowImageException;
4694void Magick::Image::transformOrigin(
const double x_,
const double y_)
4697 options()->transformOrigin(x_,y_);
4700void Magick::Image::transformReset(
void)
4703 options()->transformReset();
4706void Magick::Image::transformScale(
const double sx_,
const double sy_)
4709 options()->transformScale(sx_,sy_);
4712void Magick::Image::transparent(
const Color &color_,
const bool inverse_)
4720 if (!color_.isValid())
4721 throwExceptionExplicit(MagickCore::OptionError,
4722 "Color argument is invalid");
4726 (void) QueryColorCompliance(color.c_str(),AllCompliance,&target,
4729 TransparentPaintImage(image(),&target,TransparentAlpha,
4730 inverse_ ==
true ? MagickTrue : MagickFalse,exceptionInfo);
4731 ThrowImageException;
4734void Magick::Image::transparentChroma(
const Color &colorLow_,
4735 const Color &colorHigh_)
4745 if (!colorLow_.isValid() || !colorHigh_.isValid())
4746 throwExceptionExplicit(MagickCore::OptionError,
4747 "Color argument is invalid");
4750 colorHigh=colorHigh_;
4753 (void) QueryColorCompliance(colorLow.c_str(),AllCompliance,&targetLow,
4755 (void) QueryColorCompliance(colorHigh.c_str(),AllCompliance,&targetHigh,
4758 TransparentPaintImageChroma(image(),&targetLow,&targetHigh,TransparentAlpha,
4759 MagickFalse,exceptionInfo);
4760 ThrowImageException;
4763void Magick::Image::transpose(
void)
4769 newImage=TransposeImage(constImage(),exceptionInfo);
4770 replaceImage(newImage);
4771 ThrowImageException;
4774void Magick::Image::transverse(
void)
4780 newImage=TransverseImage(constImage(),exceptionInfo);
4781 replaceImage(newImage);
4782 ThrowImageException;
4785void Magick::Image::trim(
void)
4791 newImage=TrimImage(constImage(),exceptionInfo);
4792 replaceImage(newImage);
4793 ThrowImageException;
4802 image=UniqueImageColors(constImage(),exceptionInfo);
4803 ThrowImageException;
4804 if (image == (MagickCore::Image *) NULL)
4810void Magick::Image::unsharpmask(
const double radius_,
const double sigma_,
4811 const double amount_,
const double threshold_)
4817 newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
4819 replaceImage(newImage);
4820 ThrowImageException;
4823void Magick::Image::unsharpmaskChannel(
const ChannelType channel_,
4824 const double radius_,
const double sigma_,
const double amount_,
4825 const double threshold_)
4831 GetAndSetPPChannelMask(channel_);
4832 newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
4834 RestorePPChannelMask;
4835 replaceImage(newImage);
4836 ThrowImageException;
4839void Magick::Image::vignette(
const double radius_,
const double sigma_,
4840 const ssize_t x_,
const ssize_t y_)
4846 newImage=VignetteImage(constImage(),radius_,sigma_,x_,y_,exceptionInfo);
4847 replaceImage(newImage);
4848 ThrowImageException;
4851void Magick::Image::wave(
const double amplitude_,
const double wavelength_)
4857 newImage=WaveImage(constImage(),amplitude_,wavelength_,image()->interpolate,
4859 replaceImage(newImage);
4860 ThrowImageException;
4863void Magick::Image::waveletDenoise(
const double threshold_,
4864 const double softness_)
4870 newImage=WaveletDenoiseImage(constImage(),threshold_,softness_,
4872 replaceImage(newImage);
4873 ThrowImageException;
4876void Magick::Image::whiteThreshold(
const std::string &threshold_)
4880 WhiteThresholdImage(image(),threshold_.c_str(),exceptionInfo);
4881 ThrowImageException;
4884void Magick::Image::whiteThresholdChannel(
const ChannelType channel_,
4885 const std::string &threshold_)
4889 GetAndSetPPChannelMask(channel_);
4890 WhiteThresholdImage(image(),threshold_.c_str(),exceptionInfo);
4891 RestorePPChannelMask;
4892 ThrowImageException;
4895void Magick::Image::write(Blob *blob_)
4905 data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
4907 blob_->updateNoCopy(data,length,Blob::MallocAllocator);
4909 data=RelinquishMagickMemory(data);
4910 ThrowImageException;
4913void Magick::Image::write(Blob *blob_,
const std::string &magick_)
4924 data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
4926 blob_->updateNoCopy(data,length,Blob::MallocAllocator);
4928 data=RelinquishMagickMemory(data);
4929 ThrowImageException;
4932void Magick::Image::write(Blob *blob_,
const std::string &magick_,
4933 const size_t depth_)
4945 data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
4947 blob_->updateNoCopy(data,length,Blob::MallocAllocator);
4949 data=RelinquishMagickMemory(data);
4950 ThrowImageException;
4953void Magick::Image::write(
const ssize_t x_,
const ssize_t y_,
4954 const size_t columns_,
const size_t rows_,
const std::string &map_,
4955 const StorageType type_,
void *pixels_)
4958 ExportImagePixels(image(),x_,y_,columns_,rows_,map_.c_str(),type_,pixels_,
4960 ThrowImageException;
4963void Magick::Image::write(
const std::string &imageSpec_)
4966 fileName(imageSpec_);
4968 WriteImage(constImageInfo(),image(),exceptionInfo);
4969 ThrowImageException;
4974 mask(mask_,WritePixelMask);
4979 return(mask(WritePixelMask));
4982void Magick::Image::writePixels(
const Magick::QuantumType quantum_,
4983 unsigned char *destination_)
4988 quantum_info=AcquireQuantumInfo(imageInfo(),image());
4990 ExportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
4991 quantum_,destination_, exceptionInfo);
4992 quantum_info=DestroyQuantumInfo(quantum_info);
4993 ThrowImageException;
4996void Magick::Image::zoom(
const Geometry &geometry_)
5009 ParseMetaGeometry(
static_cast<std::string
>(geometry_).c_str(),&x,&y,&width,
5013 newImage=ResizeImage(constImage(),width,height,image()->filter,exceptionInfo);
5014 replaceImage(newImage);
5015 ThrowImageException;
5018Magick::Image::Image(MagickCore::Image *image_)
5019 : _imgRef(new ImageRef(image_))
5023MagickCore::Image *&Magick::Image::image(
void)
5025 return(_imgRef->image());
5028const MagickCore::Image *Magick::Image::constImage(
void)
const
5030 return(_imgRef->image());
5033MagickCore::ImageInfo *Magick::Image::imageInfo(
void)
5035 return(_imgRef->options()->imageInfo());
5038const MagickCore::ImageInfo *Magick::Image::constImageInfo(
void)
const
5040 return(_imgRef->options()->imageInfo());
5045 return(_imgRef->options());
5050 return(_imgRef->options());
5053MagickCore::QuantizeInfo *Magick::Image::quantizeInfo(
void)
5055 return(_imgRef->options()->quantizeInfo());
5058const MagickCore::QuantizeInfo *Magick::Image::constQuantizeInfo(
void)
const
5060 return(_imgRef->options()->quantizeInfo());
5063void Magick::Image::modifyImage(
void)
5065 if (!_imgRef->isShared())
5069 replaceImage(CloneImage(image(),0,0,MagickTrue,exceptionInfo));
5070 ThrowImageException;
5073MagickCore::Image *Magick::Image::replaceImage(MagickCore::Image *replacement_)
5083 image=AcquireImage(constImageInfo(),exceptionInfo);
5084 ThrowImageException;
5087 _imgRef=ImageRef::replaceImage(_imgRef,image);
5091void Magick::Image::read(MagickCore::Image *image,
5092 MagickCore::ExceptionInfo *exceptionInfo)
5095 if (image != (MagickCore::Image *) NULL &&
5096 image->next != (MagickCore::Image *) NULL)
5103 image->next=(MagickCore::Image *) NULL;
5104 next->previous=(MagickCore::Image *) NULL;
5105 DestroyImageList(next);
5107 replaceImage(image);
5108 if (exceptionInfo->severity == MagickCore::UndefinedException &&
5109 image == (MagickCore::Image *) NULL)
5111 (void) MagickCore::DestroyExceptionInfo(exceptionInfo);
5113 throwExceptionExplicit(MagickCore::ImageWarning,
5114 "No image was loaded.");
5117 ThrowImageException;
5120void Magick::Image::floodFill(
const ssize_t x_,
const ssize_t y_,
5122 const MagickCore::PixelInfo *target_,
const bool invert_)
5131 fillColor=options()->fillColor();
5132 fillPattern=(MagickCore::Image *)NULL;
5133 if (options()->fillPattern() != (MagickCore::Image *)NULL)
5136 fillPattern=CloneImage(options()->fillPattern(),0,0,MagickTrue,
5138 ThrowImageException;
5143 options()->fillPattern((MagickCore::Image *)NULL);
5144 options()->fillColor(fill_);
5147 options()->fillPattern(fillPattern_->constImage());
5150 (void) FloodfillPaintImage(image(),options()->drawInfo(),
5151 target_,
static_cast<ssize_t
>(x_),
static_cast<ssize_t
>(y_),
5152 (MagickBooleanType) invert_,exceptionInfo);
5154 options()->fillColor(fillColor);
5155 options()->fillPattern(fillPattern);
5156 ThrowImageException;
5159void Magick::Image::mask(
const Magick::Image &mask_,
const PixelMask type)
5164 if (mask_.isValid())
5165 SetImageMask(image(),type,mask_.constImage(),exceptionInfo);
5167 SetImageMask(image(),type,(MagickCore::Image *) NULL,exceptionInfo);
5168 ThrowImageException;
5171Magick::Image Magick::Image::mask(
const PixelMask type)
const
5177 image = GetImageMask(constImage(),type,exceptionInfo);
5178 ThrowImageException;
5180 if (image == (MagickCore::Image *) NULL)