11 #define MAGICKCORE_IMPLEMENTATION  1    12 #define MAGICK_PLUSPLUS_IMPLEMENTATION 1    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())    42   return((left_.
rows() == right_.
rows()) &&
    50   return(!(left_ == right_));
    56   return(!(left_ < right_) && (left_ != right_));
    70   return((left_ > right_) || (left_ == right_));
    76   return((left_ < right_) || ( left_ == right_));
   128     read(blob_,size_,depth_);
   140   const size_t depth_,
const std::string &magick_)
   147     read(blob_,size_,depth_,magick_);
   159   const std::string &magick_)
   166     read(blob_,size_,magick_);
   181   std::string imageSpec(
"xc:");
   203   : _imgRef(image_._imgRef)
   222     MagickTrue,exceptionInfo);
   233   const std::string &map_,
const StorageType type_,
const void *pixels_)
   239     read(width_,height_,map_.c_str(),type_,pixels_);
   272     if (_imgRef->decrease() == 0)
   287       if (_imgRef->decrease() == 0)
   291       _imgRef=image_._imgRef;
   299   options()->adjoin(flag_);
   304   return(constOptions()->adjoin());
   316   if (
bool(alphaFlag_) != 
bool(constImage()->alpha_trait))
   317     SetImageAlpha(image(),OpaqueAlpha,exceptionInfo);
   320   image()->alpha_trait=alphaFlag_ ? BlendPixelTrait : UndefinedPixelTrait;
   325   if (constImage()->alpha_trait == BlendPixelTrait)
   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));
   357   image()->delay=delay_;
   362   return(constImage()->delay);
   368   image()->iterations=iterations_;
   373   return(constImage()->iterations);
   380   if (backgroundColor_.
isValid())
   381     image()->background_color=backgroundColor_;
   383     image()->background_color=
Color();
   385   options()->backgroundColor(backgroundColor_);
   390   return(constOptions()->backgroundColor());
   396   options()->backgroundTexture(backgroundTexture_);
   401   return(constOptions()->backgroundTexture());
   406   return(constImage()->magick_columns);
   411   return(std::string(constImage()->magick_filename));
   416   return(constImage()->magick_rows);
   421   image()->black_point_compensation=(MagickBooleanType) flag_;
   426   return(static_cast<bool>(constImage()->black_point_compensation));
   434     image()->border_color=borderColor_;
   436     image()->border_color=
Color();
   438   options()->borderColor(borderColor_);
   443   return(constOptions()->borderColor());
   452   bbox=GetImageBoundingBox(constImage(),exceptionInfo);
   460   options()->boxColor(boxColor_);
   465   return(constOptions()->boxColor());
   474   SetImageDepth(image(),depth_,exceptionInfo);
   486   channel_depth=GetImageDepth(constImage(),exceptionInfo);
   489   return(channel_depth);
   494   return(constImage()->number_channels);
   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);
   524   return static_cast<Magick::ClassType
>(constImage()->storage_class);
   531   options()->colorFuzz(fuzz_);
   536   return(constOptions()->colorFuzz());
   541   if (entries_ >MaxColormapSize)
   543       "Colormap entries must not exceed MaxColormapSize");
   547   (void) AcquireImageColormap(image(),entries_,exceptionInfo);
   553   if (!constImage()->colormap)
   555       "Image does not contain a colormap");
   557   return(constImage()->colors);
   562   if (image()->colorspace == colorSpace_)
   567   TransformImageColorspace(image(),colorSpace_,exceptionInfo);
   573   return (constImage()->colorspace);
   580   SetImageColorspace(image(),colorSpace_,exceptionInfo);
   582   options()->colorspaceType(colorSpace_);
   587   return(constOptions()->colorspaceType());
   592   return(constImage()->columns);
   599   SetImageProperty(image(),
"Comment",NULL,exceptionInfo);
   600   if (comment_.length() > 0)
   601     SetImageProperty(image(),
"Comment",comment_.c_str(),exceptionInfo);
   611   value=GetImageProperty(constImage(),
"Comment",exceptionInfo);
   615     return(std::string(value));
   617   return(std::string()); 
   622   image()->compose=compose_;
   627   return(constImage()->compose);
   633   image()->compression=compressType_;
   634   options()->compressType(compressType_);
   639   return(constImage()->compression);
   645   options()->debug(flag_);
   650   return(constOptions()->debug());
   656   options()->density(density_);
   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());
   696   image()->depth=depth_;
   697   options()->depth(depth_);
   702   return(constImage()->depth);
   707   if (constImage()->directory)
   708     return(std::string(constImage()->directory));
   712       "Image does not contain a directory");
   714   return(std::string());
   720   options()->endian(endian_);
   721   image()->endian=endian_;
   726   return(constImage()->endian);
   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)));
   766   max_length=
sizeof(image()->filename)-1;
   767   fileName_.copy(image()->filename,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_);
   778   return(constOptions()->fileName());
   783   return(GetBlobSize(constImage()));
   789   options()->fillColor(fillColor_);
   794   return(constOptions()->fillColor());
   800   options()->fillRule(fillRule_);
   805   return constOptions()->fillRule();
   812     options()->fillPattern(fillPattern_.
constImage());
   814     options()->fillPattern(static_cast<MagickCore::Image*>(NULL));
   834       image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
   844   image()->filter=filterType_;
   849   return(constImage()->filter);
   855   options()->font(font_);
   860   return(constOptions()->font());
   866   options()->fontFamily(family_);
   871   return(constOptions()->fontFamily());
   877   options()->fontPointsize(pointSize_);
   882   return(constOptions()->fontPointsize());
   888   options()->fontStyle(pointSize_);
   893   return(constOptions()->fontStyle());
   899   options()->fontWeight(weight_);
   904   return(constOptions()->fontWeight());
   913   magick_info=GetMagickInfo(constImage()->magick,exceptionInfo);
   916   if ((magick_info != 0) && (*magick_info->description != 
'\0'))
   917     return(std::string(magick_info->description));
   921       "Unrecognized image magick type");
   923   return(std::string());
   936   text=InterpretImageProperties(imageInfo(),image(),expression.c_str(),
   938   if (text != (
char *) NULL)
   940       text_string=std::string(text);
   941       text=DestroyString(text);
   949   return(constImage()->gamma);
   954   if (constImage()->geometry)
   955     return Geometry(constImage()->geometry);
   959       "Image does not contain a geometry");
   965   const MagickCore::DisposeType disposeMethod_)
   968   image()->dispose=disposeMethod_;
   973   return(constImage()->dispose);
   978   if (GetPixelChannelTraits(constImage(),channel) == UndefinedPixelTrait)
   981   if (channel == GreenPixelChannel || channel == BluePixelChannel)
   982     return (GetPixelChannelOffset(constImage(),channel) == (ssize_t)channel);
   993   artifact(
"compare:highlight-color",value);
   998   profile(
"icc",colorProfile_);
  1006   color_profile=GetImageProfile(constImage(),
"icc");
  1007   if (color_profile == (StringInfo *) NULL)
  1009   return(
Blob(GetStringInfoDatum(color_profile),GetStringInfoLength(
  1016   image()->interlace=interlace_;
  1017   options()->interlaceType(interlace_);
  1022   return(constImage()->interlace);
  1028   image()->interpolate=interpolate_;
  1033   return constImage()->interpolate;
  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);
  1058   iptc_profile=GetImageProfile(constImage(),
"iptc");
  1059   if (iptc_profile == (StringInfo *) NULL)
  1061   return(
Blob(GetStringInfoDatum(iptc_profile),GetStringInfoLength(
  1071   result=IsImageOpaque(constImage(),exceptionInfo);
  1073   return(result != MagickFalse ? 
true : 
false);
  1083   else if (!isValid())
  1094   return rows() && columns();
  1101   (void) SetImageProperty(image(),
"Label",NULL,exceptionInfo);
  1102   if (label_.length() > 0)
  1103     (
void) SetImageProperty(image(),
"Label",label_.c_str(),exceptionInfo);
  1113   value=GetImageProperty(constImage(),
"Label",exceptionInfo);
  1117     return(std::string(value));
  1119   return(std::string());
  1128   artifact(
"compare:lowlight-color",value);
  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_);
  1151   if (*(constImage()->magick) != 
'\0')
  1152     return(std::string(constImage()->magick));
  1154   return(constOptions()->magick());
  1163   artifact(
"compare:masklight-color",value);
  1168   return(constImage()->error.mean_error_per_pixel);
  1175   SetImageDepth(image(),depth_,exceptionInfo);
  1177   options()->depth(depth_);
  1186   depth=GetImageDepth(constImage(),exceptionInfo);
  1194   options()->monochrome(monochromeFlag_);
  1199   return(constOptions()->monochrome());
  1204   if (constImage()->montage)
  1209     "Image does not contain a montage");
  1216   return(constImage()->error.normalized_maximum_error);
  1221   return(constImage()->error.normalized_mean_error);
  1227   image()->orientation=orientation_;
  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));
  1251   image()->quality=quality_;
  1252   options()->quality(quality_);
  1257   return(constImage()->quality);
  1263   options()->quantizeColors(colors_);
  1268   return(constOptions()->quantizeColors());
  1272   const Magick::ColorspaceType colorSpace_)
  1275   options()->quantizeColorSpace(colorSpace_);
  1280   return(constOptions()->quantizeColorSpace());
  1286   options()->quantizeDither(ditherFlag_);
  1291   return(constOptions()->quantizeDither());
  1297   options()->quantizeDitherMethod(ditherMethod_);
  1302   return(constOptions()->quantizeDitherMethod());
  1308   options()->quantizeTreeDepth(treeDepth_);
  1313   return(constOptions()->quantizeTreeDepth());
  1319   options()->quiet(quiet_);
  1324   return(constOptions()->quiet());
  1328   const Magick::RenderingIntent renderingIntent_)
  1331   image()->rendering_intent=renderingIntent_;
  1336   return(static_cast<Magick::RenderingIntent>(constImage()->rendering_intent));
  1340   const Magick::ResolutionType resolutionUnits_)
  1343   image()->units=resolutionUnits_;
  1344   options()->resolutionUnits(resolutionUnits_);
  1349   return(static_cast<Magick::ResolutionType>(constImage()->units));
  1354   return(constImage()->rows);
  1360   options()->samplingFactor(samplingFactor_);
  1365   return(constOptions()->samplingFactor());
  1371   image()->scene=scene_;
  1376   return(constImage()->scene);
  1382   options()->size(geometry_);
  1383   image()->rows=geometry_.
height();
  1384   image()->columns=geometry_.
width();
  1395   options()->strokeAntiAlias(flag_);
  1400   return(constOptions()->strokeAntiAlias());
  1409   options()->strokeColor(strokeColor_);
  1411   artifact(
"stroke",value);
  1416   return(constOptions()->strokeColor());
  1422   options()->strokeDashArray(strokeDashArray_);
  1427   return(constOptions()->strokeDashArray());
  1433   options()->strokeDashOffset(strokeDashOffset_);
  1438   return(constOptions()->strokeDashOffset());
  1444   options()->strokeLineCap(lineCap_);
  1449   return(constOptions()->strokeLineCap());
  1455   options()->strokeLineJoin(lineJoin_);
  1460   return(constOptions()->strokeLineJoin());
  1466   options()->strokeMiterLimit(strokeMiterLimit_);
  1471   return(constOptions()->strokeMiterLimit());
  1478     options()->strokePattern(strokePattern_.
constImage());
  1480     options()->strokePattern(static_cast<MagickCore::Image*>(NULL));
  1500       image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
  1510     value[MagickPathExtent];
  1513   options()->strokeWidth(strokeWidth_);
  1514   FormatLocaleString(value,MagickPathExtent,
"%.20g",strokeWidth_);
  1515   (void) SetImageArtifact(image(),
"strokewidth",value);
  1520   return(constOptions()->strokeWidth());
  1526   options()->subImage(subImage_);
  1531   return(constOptions()->subImage());
  1537   options()->subRange(subRange_);
  1542   return(constOptions()->subRange());
  1548   options()->textAntiAlias(flag_);
  1553   return(constOptions()->textAntiAlias());
  1559   options()->textDirection(direction_);
  1564   return(constOptions()->textDirection());
  1570   options()->textEncoding(encoding_);
  1575   return(constOptions()->textEncoding());
  1581   options()->textGravity(gravity_);
  1586   return(constOptions()->textGravity());
  1592   options()->textInterlineSpacing(spacing_);
  1597   return(constOptions()->textInterlineSpacing());
  1603   options()->textInterwordSpacing(spacing_);
  1608   return(constOptions()->textInterwordSpacing());
  1614   options()->textKerning(kerning_);
  1619   return(constOptions()->textKerning());
  1625   options()->textUnderColor(underColor_);
  1630   return(constOptions()->textUnderColor());
  1639   colors=GetNumberColors(constImage(),(FILE *) NULL,exceptionInfo);
  1647   options()->transformRotation(angle_);
  1653   options()->transformSkewX(skewx_);
  1659   options()->transformSkewY(skewy_);
  1664   if (constOptions()->type() != UndefinedType)
  1665     return(constOptions()->type());
  1666   return(GetImageType(constImage()));
  1672   options()->type(type_);
  1674   SetImageType(image(),type_,exceptionInfo);
  1681   options()->verbose(verboseFlag_);
  1686   return(constOptions()->verbose());
  1690   const VirtualPixelMethod virtualPixelMethod_)
  1694   SetImageVirtualPixelMethod(image(),virtualPixelMethod_,exceptionInfo);
  1700   return(GetImageVirtualPixelMethod(constImage()));
  1706   options()->x11Display(display_);
  1711   return(constOptions()->x11Display());
  1716   return(constImage()->resolution.x);
  1721   return(constImage()->resolution.y);
  1730   newImage=AdaptiveBlurImage(constImage(),radius_,sigma_,exceptionInfo);
  1731   replaceImage(newImage);
  1748   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
  1752   newImage=AdaptiveResizeImage(constImage(),width,height,exceptionInfo);
  1753   replaceImage(newImage);
  1763   newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,exceptionInfo);
  1764   replaceImage(newImage);
  1769   const double radius_,
const double sigma_ )
  1776   newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,exceptionInfo);
  1778   replaceImage(newImage);
  1790   newImage=AdaptiveThresholdImage(constImage(),width_,height_,bias_,
  1792   replaceImage(newImage);
  1802   newImage=AddNoiseImage(constImage(),noiseType_,attenuate_,exceptionInfo);
  1803   replaceImage(newImage);
  1808   const NoiseType noiseType_,
const double attenuate_)
  1815   newImage=AddNoiseImage(constImage(),noiseType_,attenuate_,exceptionInfo);
  1817   replaceImage(newImage);
  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);
  1846   SetImageAlpha(image(),alpha_,exceptionInfo);
  1854   SetImageAlphaChannel(image(),alphaOption_,exceptionInfo);
  1861   annotate(text_,location_,NorthWestGravity,0.0);
  1865   const Geometry &boundingArea_,
const GravityType gravity_)
  1867   annotate(text_,boundingArea_,gravity_,0.0);
  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);
  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;
  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;
  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;
  1971   (void) SetImageArtifact(image(),name_.c_str(),value_.c_str());
  1979   value=GetImageArtifact(constImage(),name_.c_str());
  1981     return(std::string(value));
  1982   return(std::string());
  1989   SetImageProperty(image(),name_.c_str(),value_,exceptionInfo);
  1997   SetImageProperty(image(),name_.c_str(),value_.c_str(),exceptionInfo);
  2007   value=GetImageProperty(constImage(),name_.c_str(),exceptionInfo);
  2011     return(std::string(value));
  2013   return(std::string()); 
  2020   (void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
  2021   (void) AutoGammaImage(image(),exceptionInfo);
  2030   (void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
  2031   (void) AutoGammaImage(image(),exceptionInfo);
  2040   (void) AutoLevelImage(image(),exceptionInfo);
  2049   (void) AutoLevelImage(image(),exceptionInfo);
  2059   if (image()->orientation == UndefinedOrientation ||
  2060       image()->orientation == TopLeftOrientation)
  2064   newImage=AutoOrientImage(constImage(),image()->orientation,exceptionInfo);
  2065   replaceImage(newImage);
  2073   AutoThresholdImage(image(),method_, exceptionInfo);
  2081   BlackThresholdImage(image(),threshold_.c_str(),exceptionInfo);
  2086   const std::string &threshold_)
  2091   BlackThresholdImage(image(),threshold_.c_str(),exceptionInfo);
  2102   newImage=BlueShiftImage(constImage(),factor_,exceptionInfo);
  2103   replaceImage(newImage);
  2113   newImage=BlurImage(constImage(),radius_,sigma_,exceptionInfo);
  2114   replaceImage(newImage);
  2119   const double radius_,
const double sigma_)
  2126   newImage=BlurImage(constImage(),radius_,sigma_,exceptionInfo);
  2128   replaceImage(newImage);
  2138     borderInfo=geometry_;
  2141   newImage=BorderImage(constImage(),&borderInfo,image()->compose,
  2143   replaceImage(newImage);
  2148   const double contrast_)
  2152   BrightnessContrastImage(image(),brightness_,contrast_,exceptionInfo);
  2157   const double brightness_,
const double contrast_)
  2162   BrightnessContrastImage(image(),brightness_,contrast_,exceptionInfo);
  2168   const double lowerPercent_,
const double upperPercent_)
  2175   newImage=CannyEdgeImage(constImage(),radius_,sigma_,lowerPercent_,
  2176     upperPercent_,exceptionInfo);
  2177   replaceImage(newImage);
  2185   (void) ColorDecisionListImage(image(),cdl_.c_str(),exceptionInfo);
  2195   newImage=SeparateImage(image(),channel_,exceptionInfo);
  2196   replaceImage(newImage);
  2206   newImage=CharcoalImage(image(),radius_,sigma_,exceptionInfo);
  2207   replaceImage(newImage);
  2212   const double radius_,
const double sigma_)
  2219   newImage=CharcoalImage(image(),radius_,sigma_,exceptionInfo);
  2221   replaceImage(newImage);
  2234   newImage=ChopImage(image(),&chopInfo,exceptionInfo);
  2235   replaceImage(newImage);
  2243   image()->chromaticity.blue_primary.x=x_;
  2244   image()->chromaticity.blue_primary.y=y_;
  2245   image()->chromaticity.blue_primary.z=z_;
  2250   *x_=constImage()->chromaticity.blue_primary.x;
  2251   *y_=constImage()->chromaticity.blue_primary.y;
  2252   *z_=constImage()->chromaticity.blue_primary.z;
  2259   image()->chromaticity.green_primary.x=x_;
  2260   image()->chromaticity.green_primary.y=y_;
  2261   image()->chromaticity.green_primary.z=z_;
  2266   *x_=constImage()->chromaticity.green_primary.x;
  2267   *y_=constImage()->chromaticity.green_primary.y;
  2268   *z_=constImage()->chromaticity.green_primary.z;
  2275   image()->chromaticity.red_primary.x=x_;
  2276   image()->chromaticity.red_primary.y=y_;
  2277   image()->chromaticity.red_primary.z=z_;
  2282   *x_=constImage()->chromaticity.red_primary.x;
  2283   *y_=constImage()->chromaticity.red_primary.y;
  2284   *z_=constImage()->chromaticity.red_primary.z;
  2291   image()->chromaticity.white_point.x=x_;
  2292   image()->chromaticity.white_point.y=y_;
  2293   image()->chromaticity.white_point.z=z_;
  2298   *x_=constImage()->chromaticity.white_point.x;
  2299   *y_=constImage()->chromaticity.white_point.y;
  2300   *z_=constImage()->chromaticity.white_point.z;
  2307   ClampImage(image(),exceptionInfo);
  2316   ClampImage(image(),exceptionInfo);
  2325   ClipImage(image(),exceptionInfo);
  2333   ClipImagePath(image(),pathname_.c_str(),(MagickBooleanType) inside_,
  2339   const PixelInterpolateMethod method)
  2343   ClutImage(image(),clutImage_.
constImage(),method,exceptionInfo);
  2348   const Image &clutImage_,
const PixelInterpolateMethod method)
  2353   ClutImage(image(),clutImage_.
constImage(),method,exceptionInfo);
  2360   colorize(alpha_,alpha_,alpha_,penColor_);
  2364   const unsigned int alphaGreen_,
const unsigned int alphaBlue_,
  2365   const Color &penColor_)
  2368     blend[MagickPathExtent];
  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);
  2397   if (index_ > (MaxColormapSize-1))
  2399       "Colormap index must be less than MaxColormapSize");
  2403       "Color argument is invalid");
  2408   if (colorMapSize() < (index_+1))
  2409     colorMapSize(index_+1);
  2412   (imageptr->colormap)[index_]=color_;
  2417   if (!constImage()->colormap)
  2420         "Image does not contain a colormap");
  2424   if (index_ > constImage()->colors-1)
  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);
  2468   status=
static_cast<bool>(IsImagesEqual(constImage(),ref.
constImage(),
  2480   GetImageDistortion(image(),reference_.
constImage(),metric_,&distortion,
  2487   const Image &reference_,
const MetricType metric_)
  2494   GetImageDistortion(image(),reference_.
constImage(),metric_,&distortion,
  2502   const MetricType metric_,
double *distortion)
  2508   newImage=CompareImages(image(),reference_.
constImage(),metric_,distortion,
  2518   const Image &reference_,
const MetricType metric_,
double *distortion)
  2525   newImage=CompareImages(image(),reference_.
constImage(),metric_,distortion,
  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,
  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);
  2573   const ssize_t xOffset_,
const ssize_t yOffset_,
  2574   const CompositeOperator compose_)
  2580   CompositeImage(image(),compositeImage_.
constImage(),compose_,MagickTrue,
  2581     xOffset_,yOffset_,exceptionInfo);
  2591   newImage=ConnectedComponentsImage(constImage(),connectivity_,
  2592     (CCObjectInfo **) NULL,exceptionInfo);
  2593   replaceImage(newImage);
  2601   ContrastImage(image(),(MagickBooleanType) sharpen_,exceptionInfo);
  2606   const double whitePoint_)
  2610   ContrastStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
  2615   const double blackPoint_,
const double whitePoint_)
  2620   ContrastStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
  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);
  2662   (void) CopyImagePixels(image(),source_.
constImage(),&geometry,&offset,
  2676   newImage=CropImage(constImage(),&cropInfo,exceptionInfo);
  2677   replaceImage(newImage);
  2685   CycleColormapImage(image(),amount_,exceptionInfo);
  2693   DecipherImage(image(),passphrase_.c_str(),exceptionInfo);
  2698   const std::string &key_,
bool flag_)
  2704   definition=magick_ + 
":" + key_;
  2706     (void) SetImageOption(imageInfo(),definition.c_str(),
"");
  2708     DeleteImageOption(imageInfo(),definition.c_str());
  2712   const std::string &key_ )
 const  2720   key=magick_ + 
":" + key_;
  2721   option=GetImageOption(constImageInfo(),key.c_str());
  2728   const std::string &key_,
const std::string &value_)
  2735   format=magick_ + 
":" + key_;
  2737   (void) SetImageOption(imageInfo(),format.c_str(),option.c_str());
  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());
  2762   newImage=DeskewImage(constImage(),threshold_,exceptionInfo);
  2763   replaceImage(newImage);
  2773   newImage=DespeckleImage(constImage(),exceptionInfo);
  2774   replaceImage(newImage);
  2781   DisplayImages(imageInfo(),image(),exceptionInfo);
  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);
  2805   wand=AcquireDrawingWand(options()->drawInfo(),image());
  2809       drawable_.operator()(wand);
  2814       wand=DestroyDrawingWand(wand);
  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)
  2842       wand=DestroyDrawingWand(wand);
  2853   newImage=EdgeImage(constImage(),radius_,exceptionInfo);
  2854   replaceImage(newImage);
  2864   newImage=EmbossImage(constImage(),radius_,sigma_,exceptionInfo);
  2865   replaceImage(newImage);
  2873   EncipherImage(image(),passphrase_.c_str(),exceptionInfo);
  2883   newImage=EnhanceImage(constImage(),exceptionInfo);
  2884   replaceImage(newImage);
  2892   EqualizeImage(image(),exceptionInfo);
  2900   (void) SetImageBackgroundColor(image(),exceptionInfo);
  2905   const MagickEvaluateOperator operator_,
double rvalue_)
  2909   EvaluateImage(image(),operator_,rvalue_,exceptionInfo);
  2915   const MagickFunction function_,
const size_t number_parameters_,
  2916   const double *parameters_)
  2920   FunctionImage(image(),function_,number_parameters_,parameters_,
  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);
  2944   EvaluateImage(
cropImage,operator_,rvalue_,exceptionInfo);
  2946   (void) CompositeImage(image(),
cropImage,image()->alpha_trait == 
  2947     BlendPixelTrait ? OverCompositeOp : CopyCompositeOp,MagickFalse,
  2948     geometry.x,geometry.y,exceptionInfo );
  2959     extentInfo=geometry_;
  2962   extentInfo.x=geometry_.
xOff();
  2963   extentInfo.y=geometry_.
yOff();
  2965   newImage=ExtentImage(image(),&extentInfo,exceptionInfo);
  2966   replaceImage(newImage);
  2971   const Color &backgroundColor_)
  2973   backgroundColor(backgroundColor_);
  2978   const Color &backgroundColor_,
const GravityType gravity_)
  2980   backgroundColor(backgroundColor_);
  2981   extent(geometry_,gravity_);
  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);
  3003   newImage=FlipImage(constImage(),exceptionInfo);
  3004   replaceImage(newImage);
  3009   const unsigned int alpha_,
const bool invert_)
  3016   target=
static_cast<PixelInfo
>(pixelColor(x_,y_));
  3017   target.alpha=alpha_;
  3020   FloodfillPaintImage(image(),options()->drawInfo(),&target,x_,y_,
  3021     (MagickBooleanType)invert_,exceptionInfo);
  3027   const unsigned int alpha_,
const Color &target_,
const bool invert_)
  3034   target=
static_cast<PixelInfo
>(target_);
  3035   target.alpha=alpha_;
  3038   FloodfillPaintImage(image(),options()->drawInfo(),&target,x_,y_,
  3039     (MagickBooleanType)invert_,exceptionInfo);
  3047   floodFillColor(point_.
xOff(),point_.
yOff(),fillColor_,invert_);
  3058   pixel=
static_cast<PixelInfo
>(pixelColor(x_,y_));
  3059   floodFill(x_,y_,(
Magick::Image *)NULL,fillColor_,&pixel,invert_);
  3066   floodFillColor(point_.
xOff(),point_.
yOff(),fillColor_,borderColor_,invert_);
  3078   pixel=
static_cast<PixelInfo
>(borderColor_);
  3079   floodFill(x_,y_,(
Magick::Image *)NULL,fillColor_,&pixel,invert_);
  3085   floodFillTexture(point_.
xOff(),point_.
yOff(),texture_,invert_);
  3096   pixel=
static_cast<PixelInfo
>(pixelColor(x_,y_));
  3104   floodFillTexture(point_.
xOff(),point_.
yOff(),texture_,borderColor_,invert_);
  3116   pixel=
static_cast<PixelInfo
>(borderColor_);
  3126   newImage=FlopImage(constImage(),exceptionInfo);
  3127   replaceImage(newImage);
  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;
  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;
  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);
  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);
  3211   newImage=FxImage(constImage(),expression_.c_str(),exceptionInfo);
  3212   replaceImage(newImage);
  3217   const Magick::ChannelType channel_)
  3224   newImage=FxImage(constImage(),expression_.c_str(),exceptionInfo);
  3226   replaceImage(newImage);
  3234   GammaImage(image(),gamma_,exceptionInfo);
  3239   const double gammaBlue_)
  3244   (void) GammaImage(image(),gammaRed_,exceptionInfo);
  3246   (void) GammaImage(image(),gammaGreen_,exceptionInfo);
  3248   (void) GammaImage(image(),gammaBlue_,exceptionInfo);
  3259   newImage=GaussianBlurImage(constImage(),radius_,sigma_,exceptionInfo);
  3260   replaceImage(newImage);
  3265   const double radius_,
const double sigma_)
  3272   newImage=GaussianBlurImage(constImage(),radius_,sigma_,exceptionInfo);
  3274   replaceImage(newImage);
  3279   const ssize_t y_,
const size_t columns_,
const size_t rows_)
 const  3285   p=GetVirtualPixels(constImage(),x_, y_,columns_, rows_,exceptionInfo);
  3295   result=GetVirtualMetacontent(constImage());
  3299       "Unable to retrieve meta content.");
  3309   result=GetAuthenticMetacontent(image());
  3313       "Unable to retrieve meta content.");
  3319   const size_t columns_,
const size_t rows_)
  3326   result=GetAuthenticPixels(image(),x_, y_,columns_,rows_,exceptionInfo);
  3336   (void) GrayscaleImage(image(),method_,exceptionInfo);
  3344   (void) HaldClutImage(image(),clutImage_.
constImage(),exceptionInfo);
  3349   const size_t threshold_)
  3355   newImage=HoughLineImage(constImage(),width_,height_,threshold_,
  3357   replaceImage(newImage);
  3367   image_type=IdentifyImageType(constImage(),exceptionInfo);
  3378   newImage=ImplodeImage(constImage(),factor_,image()->interpolate,
  3380   replaceImage(newImage);
  3386   inverseFourierTransform(phase_,
true);
  3390   const bool magnitude_)
  3396   newImage=InverseFourierTransformImage(constImage(),phase_.
constImage(),
  3397     magnitude_ == 
true ? MagickTrue : MagickFalse,exceptionInfo);
  3398   replaceImage(newImage);
  3408   newImage=KuwaharaImage(constImage(),radius_,sigma_,exceptionInfo);
  3409   replaceImage(newImage);
  3414   const double radius_,
const double sigma_)
  3421   newImage=KuwaharaImage(constImage(),radius_,sigma_,exceptionInfo);
  3422   replaceImage(newImage);
  3428   const double gamma_)
  3432   (void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
  3437   const double blackPoint_,
const double whitePoint_,
const double gamma_)
  3442   (void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
  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);
  3465   const Color &blackColor_,
const Color &whiteColor_,
const bool invert_)
  3473   black=
static_cast<PixelInfo
>(blackColor_);
  3474   white=
static_cast<PixelInfo
>(whiteColor_);
  3477   (void) LevelImageColors(image(),&black,&white,invert_ == 
true ?
  3478     MagickTrue : MagickFalse,exceptionInfo);
  3484   const double gamma_)
  3488   (void) LevelizeImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
  3493   const double blackPoint_,
const double whitePoint_,
const double gamma_)
  3498   (void) LevelizeImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
  3504   const double whitePoint_)
  3508   LinearStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
  3525   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
  3529   newImage=LiquidRescaleImage(image(),width,height,x,y,exceptionInfo);
  3530   replaceImage(newImage);
  3540   newImage=LocalContrastImage(constImage(),radius_,strength_,exceptionInfo);
  3541   replaceImage(newImage);
  3546   const double radius_,
const double strength_)
  3553   newImage=LocalContrastImage(constImage(),radius_,strength_,exceptionInfo);
  3555   replaceImage(newImage);
  3565   newImage=MagnifyImage(constImage(),exceptionInfo);
  3566   replaceImage(newImage);
  3574   options()->quantizeDither(dither_);
  3575   RemapImage(options()->quantizeInfo(),image(),mapImage_.
constImage(),
  3581   const double color_distance_)
  3587   newImage=MeanShiftImage(constImage(),width_,height_,color_distance_,
  3589   replaceImage(newImage);
  3599   newImage=StatisticImage(image(),MedianStatistic,(
size_t) radius_,
  3600     (
size_t) radius_,exceptionInfo);
  3601   replaceImage(newImage);
  3611   newImage=MinifyImage(constImage(),exceptionInfo);
  3612   replaceImage(newImage);
  3620     modulate[MagickPathExtent + 1];
  3622   FormatLocaleString(modulate,MagickPathExtent,
"%3.6f,%3.6f,%3.6f",brightness_,
  3627   ModulateImage(image(),modulate,exceptionInfo);
  3637   const std::string kernel_,
const ssize_t iterations_)
  3646   kernel=AcquireKernelInfo(kernel_.c_str(),exceptionInfo);
  3647   if (kernel == (KernelInfo *) NULL)
  3649   newImage=MorphologyImage(constImage(),method_,iterations_,kernel,
  3651   replaceImage(newImage);
  3652   kernel=DestroyKernelInfo(kernel);
  3657   const KernelInfoType kernel_,
const std::string arguments_,
  3658   const ssize_t iterations_)
  3666   option=CommandOptionToMnemonic(MagickKernelOptions,kernel_);
  3667   if (option == (
const char *)NULL)
  3670         "Unable to determine kernel type.");
  3673   kernel=std::string(option);
  3674   if (!arguments_.empty())
  3675     kernel+=
":"+arguments_;
  3677   morphology(method_,kernel,iterations_);
  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)
  3696         "Unable to parse kernel.");
  3700   newImage=MorphologyImage(constImage(),method_,iterations_,kernel,
  3703   replaceImage(newImage);
  3704   kernel=DestroyKernelInfo(kernel);
  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)
  3722         "Unable to determine kernel type.");
  3726   kernel=std::string(option);
  3727   if (!arguments_.empty())
  3728     kernel+=
":"+arguments_;
  3730   morphologyChannel(channel_,method_,kernel,iterations_);
  3734   const double angle_)
  3740   newImage=MotionBlurImage(constImage(),radius_,sigma_,angle_,exceptionInfo);
  3741   replaceImage(newImage);
  3749   NegateImage(image(),(MagickBooleanType) grayscale_,exceptionInfo);
  3754   const bool grayscale_)
  3759   NegateImage(image(),(MagickBooleanType) grayscale_,exceptionInfo);
  3768   NormalizeImage(image(),exceptionInfo);
  3778   newImage=OilPaintImage(constImage(),radius_,sigma_,exceptionInfo);
  3779   replaceImage(newImage);
  3796       "Opaque color argument is invalid");
  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,
  3820   (void) OrderedDitherImage(image(),thresholdMap_.c_str(),exceptionInfo);
  3825   std::string thresholdMap_)
  3830   (void)OrderedDitherImage(image(),thresholdMap_.c_str(),exceptionInfo);
  3839   PerceptibleImage(image(),epsilon_,exceptionInfo);
  3844   const double epsilon_)
  3849   PerceptibleImage(image(),epsilon_,exceptionInfo);
  3865   options()->fileName(imageSpec_);
  3866   newImage=PingImage(imageInfo(),exceptionInfo);
  3867   read(newImage,exceptionInfo);
  3876   newImage=PingBlob(imageInfo(),blob_.
data(),blob_.
length(),exceptionInfo);
  3877   read(newImage,exceptionInfo);
  3881   const Color &color_)
  3890   if (y_ > (ssize_t) rows() || x_ > (ssize_t) columns())
  3892       "Access outside of image boundary");
  3897   classType(DirectClass );
  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));
  3929   const PixelInterpolateMethod method_)
  3935   newImage=PolaroidImage(constImage(),options()->drawInfo(),caption_.c_str(),
  3936     angle_,method_,exceptionInfo);
  3937   replaceImage(newImage);
  3945   PosterizeImage(image(),levels_,method_,exceptionInfo);
  3950   const size_t levels_,
const DitherMethod method_)
  3955   PosterizeImage(image(),levels_,method_,exceptionInfo);
  3966   (void) InvokeDynamicImageFilter(name_.c_str(),&image(),argc,argv,
  3976   (void) ProfileImage(image(),name_.c_str(),(
unsigned char *)profile_.
data(),
  3977     profile_.
length(),exceptionInfo);
  3986   profile=GetImageProfile(constImage(),name_.c_str());
  3988   if (profile == (StringInfo *) NULL)
  3990   return(
Blob((
void*) GetStringInfoDatum(profile),GetStringInfoLength(
  3999     options()->quantizeInfo()->measure_error=MagickTrue;
  4001     options()->quantizeInfo()->measure_error=MagickFalse;
  4004   QuantizeImage(options()->quantizeInfo(),image(),exceptionInfo);
  4011     raiseInfo=geometry_;
  4015   RaiseImage(image(),&raiseInfo,raisedFlag_ == 
true ? MagickTrue : MagickFalse,
  4023   (void) RandomThresholdImage(image(),low_,high_,exceptionInfo);
  4028   const double low_,
const double high_)
  4033   (void) RandomThresholdImage(image(),low_,high_,exceptionInfo);
  4044   newImage=BlobToImage(imageInfo(),static_cast<const void *>(blob_.
data()),
  4045     blob_.
length(),exceptionInfo);
  4046   read(newImage,exceptionInfo);
  4056   const size_t depth_)
  4064   const size_t depth_,
const std::string &magick_)
  4070   fileName(magick_ + 
':');
  4075   const std::string &magick_)
  4080   fileName(magick_ + 
':');
  4091   const std::string &map_,
const StorageType type_,
const void *pixels_)
  4097   newImage=ConstituteImage(width_,height_,map_.c_str(),type_, pixels_,
  4099   replaceImage(newImage);
  4109   options()->fileName(imageSpec_);
  4110   newImage=ReadImage(imageInfo(),exceptionInfo);
  4111   read(newImage,exceptionInfo);
  4116   mask(mask_,ReadPixelMask);
  4121   return(mask(ReadPixelMask));
  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);
  4149   newImage=StatisticImage(constImage(),NonpeakStatistic,order_,
  4150     order_,exceptionInfo);
  4151   replaceImage(newImage);
  4159   image()->page.width = 0;
  4160   image()->page.height = 0;
  4161   image()->page.x = 0;
  4162   image()->page.y = 0;
  4171   newImage=ResampleImage(constImage(),density_.
x(),density_.
y(),
  4172     image()->filter,exceptionInfo);
  4173   replaceImage(newImage);
  4192   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
  4196   newImage=ResizeImage(constImage(),width,height,image()->filter,
  4198   replaceImage(newImage);
  4208   newImage=RollImage(constImage(),roll_.
xOff(),roll_.
yOff(),exceptionInfo);
  4209   replaceImage(newImage);
  4219   newImage=RollImage(constImage(),static_cast<ssize_t>(columns_),
  4220     static_cast<ssize_t>(rows_),exceptionInfo);
  4221   replaceImage(newImage);
  4231   newImage=RotateImage(constImage(),degrees_,exceptionInfo);
  4232   replaceImage(newImage);
  4242   newImage=RotationalBlurImage(constImage(),angle_,exceptionInfo);
  4243   replaceImage(newImage);
  4248   const double angle_)
  4255   newImage=RotationalBlurImage(constImage(),angle_,exceptionInfo);
  4257   replaceImage(newImage);
  4274   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
  4278   newImage=SampleImage(constImage(),width,height,exceptionInfo);
  4279   replaceImage(newImage);
  4296   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
  4300   newImage=ScaleImage(constImage(),width,height,exceptionInfo);
  4301   replaceImage(newImage);
  4306   const double smoothingThreshold_)
  4310   SegmentImage(image(),options()->quantizeColorSpace(),
  4311     (MagickBooleanType) options()->verbose(),clusterThreshold_,
  4312     smoothingThreshold_,exceptionInfo);
  4313   SyncImage(image(),exceptionInfo);
  4318   const double threshold_)
  4324   newImage=SelectiveBlurImage(constImage(),radius_,sigma_,threshold_,
  4326   replaceImage(newImage);
  4331   const double radius_,
const double sigma_,
const double threshold_)
  4338   newImage=SelectiveBlurImage(constImage(),radius_,sigma_,threshold_,
  4341   replaceImage(newImage);
  4351   image=SeparateImage(constImage(),channel_,exceptionInfo);
  4365   newImage=SepiaToneImage(constImage(),threshold_,exceptionInfo);
  4366   replaceImage(newImage);
  4380   status=
static_cast<bool>(SetImageColorMetric(image(),ref.
constImage(),
  4387   const size_t columns_,
const size_t rows_)
  4394   result=QueueAuthenticPixels(image(),x_,y_,columns_,rows_,exceptionInfo);
  4400   const bool colorShading_)
  4406   newImage=ShadeImage(constImage(),colorShading_ == 
true ?
  4407     MagickTrue : MagickFalse,azimuth_,elevation_,exceptionInfo);
  4408   replaceImage(newImage);
  4413   const ssize_t x_,
const ssize_t y_)
  4419   newImage=ShadowImage(constImage(),percent_opacity_, sigma_,x_, y_,
  4421   replaceImage(newImage);
  4431   newImage=SharpenImage(constImage(),radius_,sigma_,exceptionInfo);
  4432   replaceImage(newImage);
  4437   const double radius_,
const double sigma_)
  4444   newImage=SharpenImage(constImage(),radius_,sigma_,exceptionInfo);
  4446   replaceImage(newImage);
  4456     shaveInfo=geometry_;
  4459   newImage=ShaveImage(constImage(),&shaveInfo,exceptionInfo);
  4460   replaceImage(newImage);
  4470   newImage=ShearImage(constImage(),xShearAngle_,yShearAngle_,exceptionInfo);
  4471   replaceImage(newImage);
  4476   const double contrast,
const double midpoint)
  4480   (void) SigmoidalContrastImage(image(),(MagickBooleanType) sharpen_,contrast,
  4481     midpoint,exceptionInfo);
  4487   return(_imgRef->signature(force_));
  4491   const double angle_)
  4497   newImage=SketchImage(constImage(),radius_,sigma_,angle_,exceptionInfo);
  4498   replaceImage(newImage);
  4506   SolarizeImage(image(),factor_,exceptionInfo);
  4511   const SparseColorMethod method_,
const size_t numberArguments_,
  4512   const double *arguments_)
  4519   newImage=SparseColorImage(constImage(),method_,numberArguments_,arguments_,
  4522   replaceImage(newImage);
  4532     spliceInfo=geometry_;
  4535   newImage=SpliceImage(constImage(),&spliceInfo,exceptionInfo);
  4536   replaceImage(newImage);
  4541   const Color &backgroundColor_)
  4543   backgroundColor(backgroundColor_);
  4548   const Color &backgroundColor_,
const GravityType gravity_)
  4550   backgroundColor(backgroundColor_);
  4551   image()->gravity=gravity_;
  4561   newImage=SpreadImage(constImage(),image()->interpolate,amount_,exceptionInfo);
  4562   replaceImage(newImage);
  4577   newImage=SteganoImage(constImage(),watermark_.
constImage(),exceptionInfo);
  4578   replaceImage(newImage);
  4588   newImage=StereoImage(constImage(),rightImage_.
constImage(),exceptionInfo);
  4589   replaceImage(newImage);
  4597   StripImage(image(),exceptionInfo);
  4602   const MetricType metric_,
Geometry *offset_,
double *similarityMetric_,
  4603   const double similarityThreshold)
  4612   newImage=SimilarityImage(image(),reference_.
constImage(),metric_,
  4613     similarityThreshold,&offset,similarityMetric_,exceptionInfo);
  4629   newImage=SwirlImage(constImage(),degrees_,image()->interpolate,
  4631   replaceImage(newImage);
  4638   (void) SyncAuthenticPixels(image(),exceptionInfo);
  4646   TextureImage(image(),texture_.
constImage(),exceptionInfo);
  4654   BilevelImage(image(),threshold_,exceptionInfo);
  4671   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
  4675   newImage=ThumbnailImage(constImage(),width,height,exceptionInfo);
  4676   replaceImage(newImage);
  4689   color=
static_cast<PixelInfo
>(constOptions()->fillColor());
  4690   newImage=TintImage(constImage(),opacity_.c_str(),&color,exceptionInfo);
  4691   replaceImage(newImage);
  4698   options()->transformOrigin(x_,y_);
  4704   options()->transformReset();
  4710   options()->transformScale(sx_,sy_);
  4723       "Color argument is invalid");
  4727   (void) QueryColorCompliance(color.c_str(),AllCompliance,&target,
  4730   TransparentPaintImage(image(),&target,TransparentAlpha,
  4731     inverse_ == 
true ? MagickTrue : MagickFalse,exceptionInfo);
  4736   const Color &colorHigh_)
  4748       "Color argument is invalid");
  4751   colorHigh=colorHigh_;
  4754   (void) QueryColorCompliance(colorLow.c_str(),AllCompliance,&targetLow,
  4756   (void) QueryColorCompliance(colorHigh.c_str(),AllCompliance,&targetHigh,
  4759   TransparentPaintImageChroma(image(),&targetLow,&targetHigh,TransparentAlpha,
  4760     MagickFalse,exceptionInfo);
  4770   newImage=TransposeImage(constImage(),exceptionInfo);
  4771   replaceImage(newImage);
  4781   newImage=TransverseImage(constImage(),exceptionInfo);
  4782   replaceImage(newImage);
  4792   newImage=TrimImage(constImage(),exceptionInfo);
  4793   replaceImage(newImage);
  4803   image=UniqueImageColors(constImage(),exceptionInfo);
  4812   const double amount_,
const double threshold_)
  4818   newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
  4820   replaceImage(newImage);
  4825   const double radius_,
const double sigma_,
const double amount_,
  4826   const double threshold_)
  4833   newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
  4836   replaceImage(newImage);
  4841   const ssize_t x_,
const ssize_t y_)
  4847   newImage=VignetteImage(constImage(),radius_,sigma_,x_,y_,exceptionInfo);
  4848   replaceImage(newImage);
  4858   newImage=WaveImage(constImage(),amplitude_,wavelength_,image()->interpolate,
  4860   replaceImage(newImage);
  4865   const double softness_)
  4871   newImage=WaveletDenoiseImage(constImage(),threshold_,softness_,
  4873   replaceImage(newImage);
  4881   WhiteThresholdImage(image(),threshold_.c_str(),exceptionInfo);
  4886   const std::string &threshold_)
  4891   WhiteThresholdImage(image(),threshold_.c_str(),exceptionInfo);
  4906   data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
  4910     data=RelinquishMagickMemory(data);
  4925   data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
  4929     data=RelinquishMagickMemory(data);
  4934   const size_t depth_)
  4946   data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
  4950     data=RelinquishMagickMemory(data);
  4955   const size_t columns_,
const size_t rows_,
const std::string &map_,
  4956   const StorageType type_,
void *pixels_)
  4959   ExportImagePixels(image(),x_,y_,columns_,rows_,map_.c_str(),type_,pixels_,
  4967   fileName(imageSpec_);
  4969   WriteImage(constImageInfo(),image(),exceptionInfo);
  4975   mask(mask_,WritePixelMask);
  4980   return(mask(WritePixelMask));
  4984   unsigned char *destination_)
  4989   quantum_info=AcquireQuantumInfo(imageInfo(),image());
  4991   ExportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
  4992     quantum_,destination_, exceptionInfo);
  4993   quantum_info=DestroyQuantumInfo(quantum_info);
  5010   ParseMetaGeometry(static_cast<std::string>(geometry_).c_str(),&x,&y,&width,
  5014   newImage=ResizeImage(constImage(),width,height,image()->filter,exceptionInfo);
  5015   replaceImage(newImage);
  5026   return(_imgRef->image());
  5031   return(_imgRef->image());
  5036   return(_imgRef->options()->imageInfo());
  5041   return(_imgRef->options()->imageInfo());
  5046   return(_imgRef->options());
  5051   return(_imgRef->options());
  5056   return(_imgRef->options()->quantizeInfo());
  5061   return(_imgRef->options()->quantizeInfo());
  5066   if (!_imgRef->isShared())
  5070   replaceImage(CloneImage(image(),0,0,MagickTrue,exceptionInfo));
  5084       image=AcquireImage(constImageInfo(),exceptionInfo);
  5093   MagickCore::ExceptionInfo *exceptionInfo)
  5106       DestroyImageList(next);
  5108   replaceImage(image);
  5109   if (exceptionInfo->severity == MagickCore::UndefinedException &&
  5112       (void) MagickCore::DestroyExceptionInfo(exceptionInfo);
  5115           "No image was loaded.");
  5121 void Magick::Image::floodFill(
const ssize_t x_,
const ssize_t y_,
  5123   const MagickCore::PixelInfo *target_,
const bool invert_)
  5132   fillColor=options()->fillColor();
  5137       fillPattern=CloneImage(options()->fillPattern(),0,0,MagickTrue,
  5145       options()->fillColor(fill_);
  5148     options()->fillPattern(fillPattern_->
constImage());
  5151   (void) FloodfillPaintImage(image(),options()->drawInfo(),
  5152     target_,
static_cast<ssize_t
>(x_),static_cast<ssize_t>(y_),
  5153     (MagickBooleanType) invert_,exceptionInfo);
  5155   options()->fillColor(fillColor);
  5156   options()->fillPattern(fillPattern);
  5160 void Magick::Image::mask(
const Magick::Image &mask_,
const PixelMask type)
  5166     SetImageMask(image(),type,mask_.
constImage(),exceptionInfo);
  5172 Magick::Image Magick::Image::mask(
const PixelMask type)
 const  5178   image = GetImageMask(constImage(),type,exceptionInfo);
 void localContrast(const double radius_, const double strength_)
Point density(void) const
void gaussianBlur(const double radius_, const double sigma_)
void swirl(const double degrees_)
class MagickPPExport Color
MagickPPExport const char * borderGeometryDefault
void morphology(const MorphologyMethod method_, const std::string kernel_, const ssize_t iterations_=1)
void decipher(const std::string &passphrase_)
MagickPPExport int operator!=(const Magick::Color &left_, const Magick::Color &right_)
ImageMoments moments(void) const
void splice(const Geometry &geometry_)
void width(size_t width_)
#define RestorePPChannelMask
size_t animationDelay(void) const
void resize(const Geometry &geometry_)
Image writeMask(void) const
void localContrastChannel(const ChannelType channel_, const double radius_, const double strength_)
void brightnessContrastChannel(const ChannelType channel_, const double brightness_=0.0, const double contrast_=0.0)
RenderingIntent renderingIntent(void) const
StyleType fontStyle(void) const
void ty(const double ty_)
void modulate(const double brightness_, const double saturation_, const double hue_)
size_t strokeMiterLimit(void) const
void annotate(const std::string &text_, const Geometry &location_)
void transformSkewX(const double skewx_)
VirtualPixelMethod virtualPixelMethod(void) const
Magick::ImageStatistics statistics() const
bool setColorMetric(const Image &reference_)
void chromaGreenPrimary(const double x_, const double y_, const double z_)
void fx(const std::string expression_)
#define ThrowImageException
Color matteColor(void) const
OrientationType orientation(void) const
double meanErrorPerPixel(void) const
void process(std::string name_, const ::ssize_t argc_, const char **argv_)
Blob exifProfile(void) const
void adaptiveThreshold(const size_t width_, const size_t height_, const double bias_=0.0)
void writePixels(const QuantumType quantum_, unsigned char *destination_)
void charcoal(const double radius_=0.0, const double sigma_=1.0)
EndianType endian(void) const
const Quantum * getConstPixels(const ::ssize_t x_, const ::ssize_t y_, const size_t columns_, const size_t rows_) const
void blur(const double radius_=0.0, const double sigma_=1.0)
Color borderColor(void) const
std::string label(void) const
void contrast(const bool sharpen_)
void profile(const std::string name_, const Blob &colorProfile_)
Blob iccColorProfile(void) const
const MagickCore::Image * constImage(void) const
void medianFilter(const double radius_=0.0)
size_t subRange(void) const
void height(size_t height_)
void chop(const Geometry &geometry_)
MagickPPExport const char * raiseGeometryDefault
void composite(const Image &compositeImage_, const Geometry &offset_, const CompositeOperator compose_=InCompositeOp)
void liquidRescale(const Geometry &geometry_)
void unsharpmask(const double radius_, const double sigma_, const double amount_, const double threshold_)
Color textUnderColor(void) const
#define DegreesToRadians(x)
void readPixels(const QuantumType quantum_, const unsigned char *source_)
void negate(const bool grayscale_=false)
void connectedComponents(const size_t connectivity_)
void raise(const Geometry &geometry_=raiseGeometryDefault, const bool raisedFlag_=false)
void sparseColor(const ChannelType channel_, const SparseColorMethod method_, const size_t numberArguments_, const double *arguments_)
void clutChannel(const ChannelType channel_, const Image &clutImage_, const PixelInterpolateMethod method)
void whiteThreshold(const std::string &threshold_)
std::string directory(void) const
void crop(const Geometry &geometry_)
void adaptiveResize(const Geometry &geometry_)
ImageType type(void) const
std::string backgroundTexture(void) const
std::string font(void) const
void tx(const double tx_)
void clipPath(const std::string pathname_, const bool inside_)
void posterizeChannel(const ChannelType channel_, const size_t levels_, const DitherMethod method_)
size_t quality(void) const
void defineValue(const std::string &magick_, const std::string &key_, const std::string &value_)
void vignette(const double radius_=0.0, const double sigma_=1.0, const ssize_t x_=0, const ssize_t y_=0)
std::string comment(void) const
Image separate(const ChannelType channel_) const
bool textAntiAlias(void) const
std::string magick(void) const
void shade(const double azimuth_=30, const double elevation_=30, const bool colorShading_=false)
size_t modulusDepth(void) const
void waveletDenoise(const double threshold_, const double softness_)
Image & operator=(const Image &image_)
void meanShift(const size_t width_, const size_t height_, const double color_distance_)
void kuwaharaChannel(const ChannelType channel_, const double radius_=0.0, const double sigma_=1.0)
MagickSizeType fileSize(void) const
void zoom(const Geometry &geometry_)
void autoThreshold(const AutoThresholdMethod method_)
void blurChannel(const ChannelType channel_, const double radius_=0.0, const double sigma_=1.0)
void morphologyChannel(const ChannelType channel_, const MorphologyMethod method_, const std::string kernel_, const ssize_t iterations_=1)
void highlightColor(const Color color_)
std::string fileName(void) const
ColorspaceType colorSpace(void) const
const Options * constOptions(void) const
MagickPPExport int operator<(const Magick::Color &left_, const Magick::Color &right_)
size_t quantizeColors(void) const
void yOff(::ssize_t yOff_)
Image uniqueColors(void) const
Image readMask(void) const
const MagickCore::ImageInfo * constImageInfo(void) const
void posterize(const size_t levels_, const DitherMethod method_)
void rotationalBlurChannel(const ChannelType channel_, const double angle_)
void adaptiveSharpen(const double radius_=0.0, const double sigma_=1.0)
std::string fontFamily(void) const
void oilPaint(const double radius_=0.0, const double sigma=1.0)
void contrastStretchChannel(const ChannelType channel_, const double blackPoint_, const double whitePoint_)
MagickCore::Image * replaceImage(MagickCore::Image *replacement_)
void floodFillTexture(const Geometry &point_, const Image &texture_, const bool invert_=false)
void transformScale(const double sx_, const double sy_)
FillRule fillRule(void) const
void encipher(const std::string &passphrase_)
void spread(const double amount_=3.0)
CompressionType compressType(void) const
double compareChannel(const ChannelType channel_, const Image &reference_, const MetricType metric_)
void linearStretch(const double blackPoint_, const double whitePoint_)
void randomThresholdChannel(const ChannelType channel_, const double low_, const double high_)
size_t quantizeTreeDepth(void) const
void extent(const Geometry &geometry_)
void colorMatrix(const size_t order_, const double *color_matrix_)
void pixelColor(const ::ssize_t x_, const ::ssize_t y_, const Color &color_)
std::string baseFilename(void) const
Image strokePattern(void) const
void fontTypeMetricsMultiline(const std::string &text_, TypeMetric *metrics)
Geometry page(void) const
void motionBlur(const double radius_, const double sigma_, const double angle_)
void perceptibleChannel(const ChannelType channel_, const double epsilon_)
void emboss(const double radius_=0.0, const double sigma_=1.0)
ImageType identifyType(void) const
void polaroid(const std::string &caption_, const double angle_, const PixelInterpolateMethod method_)
void levelColors(const Color &blackColor_, const Color &whiteColor_, const bool invert_=true)
void segment(const double clusterThreshold_=1.0, const double smoothingThreshold_=1.5)
void grayscale(const PixelIntensityMethod method_)
void clampChannel(const ChannelType channel_)
double strokeDashOffset(void) const
void channelDepth(const ChannelType channel_, const size_t depth_)
void orderedDither(std::string thresholdMap_)
DitherMethod quantizeDitherMethod(void) const
void stegano(const Image &watermark_)
void sharpen(const double radius_=0.0, const double sigma_=1.0)
size_t subImage(void) const
void resample(const Point &density_)
MagickCore::Image *& image(void)
void floodFillAlpha(const ::ssize_t x_, const ::ssize_t y_, const unsigned int alpha_, const bool invert_=false)
bool isOpaque(void) const
MagickPPExport int operator<=(const Magick::Color &left_, const Magick::Color &right_)
void solarize(const double factor_=50.0)
double fontPointsize(void) const
void updateNoCopy(void *data_, const size_t length_, const Allocator allocator_=NewAllocator)
MagickPPExport int operator>=(const Magick::Color &left_, const Magick::Color &right_)
void stereo(const Image &rightImage_)
void defineSet(const std::string &magick_, const std::string &key_, bool flag_)
void quantize(const bool measureError_=false)
void read(const Blob &blob_)
void autoGammaChannel(const ChannelType channel_)
void frame(const Geometry &geometry_=frameGeometryDefault)
void orderedDitherChannel(const ChannelType channel_, std::string thresholdMap_)
#define ThrowPPDrawException(quiet)
Blob iptcProfile(void) const
Quantum * getPixels(const ::ssize_t x_, const ::ssize_t y_, const size_t columns_, const size_t rows_)
LineCap strokeLineCap(void) const
void shave(const Geometry &geometry_)
std::string textEncoding(void) const
void tint(const std::string opacity_)
void perceptible(const double epsilon_)
void blackThreshold(const std::string &threshold_)
class MagickPPExport Geometry
void sharpenChannel(const ChannelType channel_, const double radius_=0.0, const double sigma_=1.0)
FilterType filterType(void) const
double xResolution(void) const
bool quantizeDither(void) const
InterlaceType interlaceType(void) const
void fillPattern(const Image &fillPattern_)
const void * getConstMetacontent(void) const
std::string format(void) const
void blackThresholdChannel(const ChannelType channel_, const std::string &threshold_)
void edge(const double radius_=0.0)
size_t colorMapSize(void) const
void kuwahara(const double radius_=0.0, const double sigma_=1.0)
std::string signature(const bool force_=false) const
void texture(const Image &texture_)
void xOff(::ssize_t xOff_)
void sepiaTone(const double threshold_)
size_t totalColors(void) const
PixelInterpolateMethod interpolate(void) const
void transparentChroma(const Color &colorLow_, const Color &colorHigh_)
void sy(const double sy_)
void shadow(const double percentAlpha_=80.0, const double sigma_=0.5, const ssize_t x_=5, const ssize_t y_=5)
void whiteThresholdChannel(const ChannelType channel_, const std::string &threshold_)
void scale(const Geometry &geometry_)
MagickCore::ImageInfo * imageInfo(void)
Image subImageSearch(const Image &reference_, const MetricType metric_, Geometry *offset_, double *similarityMetric_, const double similarityThreshold=(-1.0))
void unsharpmaskChannel(const ChannelType channel_, const double radius_, const double sigma_, const double amount_, const double threshold_)
void transformRotation(const double angle_)
void artifact(const std::string &name_, const std::string &value_)
double textKerning(void) const
double colorFuzz(void) const
void sx(const double sx_)
void cannyEdge(const double radius_=0.0, const double sigma_=1.0, const double lowerPercent_=0.1, const double upperPercent_=0.3)
MagickPPExport const char * frameGeometryDefault
const MagickCore::QuantizeInfo * constQuantizeInfo(void) const
void draw(const Drawable &drawable_)
void randomThreshold(const double low_, const double high_)
MagickPPExport void throwExceptionExplicit(const MagickCore::ExceptionType severity_, const char *reason_, const char *description_=(char *) NULL)
void evaluate(const ChannelType channel_, const MagickEvaluateOperator operator_, double rvalue_)
void rotationalBlur(const double angle_)
ColorspaceType colorSpaceType(void) const
Geometry boundingBox(void) const
void implode(const double factor_)
std::string samplingFactor(void) const
void addNoiseChannel(const ChannelType channel_, const NoiseType noiseType_, const double attenuate_=1.0)
Color strokeColor(void) const
double normalizedMeanError(void) const
#define ClonePPDrawException(wand)
void masklightColor(const Color color_)
void chromaBluePrimary(const double x_, const double y_, const double z_)
const double * strokeDashArray(void) const
void levelize(const double blackPoint_, const double whitePoint_, const double gamma_=1.0)
void adaptiveSharpenChannel(const ChannelType channel_, const double radius_=0.0, const double sigma_=1.0)
void wave(const double amplitude_=25.0, const double wavelength_=150.0)
void threshold(const double threshold_)
void convolve(const size_t order_, const double *kernel_)
void roll(const Geometry &roll_)
void rx(const double rx_)
double yResolution(void) const
void gaussianBlurChannel(const ChannelType channel_, const double radius_, const double sigma_)
void thumbnail(const Geometry &geometry_)
void alphaChannel(AlphaChannelOption alphaOption_)
CompositeOperator compose(void) const
bool blackPointCompensation(void) const
void adaptiveBlur(const double radius_=0.0, const double sigma_=1.0)
void ping(const std::string &imageSpec_)
void selectiveBlur(const double radius_, const double sigma_, const double threshold_)
void transparent(const Color &color_, const bool inverse_=false)
void inverseFourierTransform(const Image &phase_)
void colorize(const unsigned int alpha_, const Color &penColor_)
DirectionType textDirection() const
#define GetAndSetPPChannelMask(channel)
void cdl(const std::string &cdl_)
Geometry geometry(void) const
size_t animationIterations(void) const
void distort(const DistortMethod method_, const size_t numberArguments_, const double *arguments_, const bool bestfit_=false)
void isValid(const bool isValid_)
void border(const Geometry &geometry_=borderGeometryDefault)
void addNoise(const NoiseType noiseType_, const double attenuate_=1.0)
Color backgroundColor(void) const
void sample(const Geometry &geometry_)
void clut(const Image &clutImage_, const PixelInterpolateMethod method)
void affineTransform(const DrawableAffine &affine)
double normalizedMaxError(void) const
void isValid(const bool valid_)
size_t columns(void) const
Magick::ImagePerceptualHash perceptualHash() const
void attribute(const std::string name_, const char *value_)
void houghLine(const size_t width_, const size_t height_, const size_t threshold_=40)
void levelizeChannel(const ChannelType channel_, const double blackPoint_, const double whitePoint_, const double gamma_=1.0)
Color fillColor(void) const
Geometry montageGeometry(void) const
void sketch(const double radius_=0.0, const double sigma_=1.0, const double angle_=0.0)
const void * data(void) const
Image fillPattern(void) const
std::string formatExpression(const std::string expression)
LineJoin strokeLineJoin(void) const
void blueShift(const double factor_=1.5)
static ImageRef * replaceImage(ImageRef *imgRef, MagickCore::Image *replacement_)
void ry(const double ry_)
void chromaRedPrimary(const double x_, const double y_, const double z_)
size_t baseColumns(void) const
double textInterwordSpacing(void) const
MagickPPExport int operator>(const Magick::Color &left_, const Magick::Color &right_)
MagickPPExport int operator==(const Magick::Color &left_, const Magick::Color &right_)
ResolutionType resolutionUnits(void) const
class MagickPPExport Point
Quantum * setPixels(const ::ssize_t x_, const ::ssize_t y_, const size_t columns_, const size_t rows_)
class MagickPPExport Image
void chromaWhitePoint(const double x_, const double y_, const double z_)
void autoLevelChannel(const ChannelType channel_)
void negateChannel(const ChannelType channel_, const bool grayscale_=false)
std::string x11Display(void) const
size_t fontWeight(void) const
double textInterlineSpacing(void) const
GravityType textGravity() const
void brightnessContrast(const double brightness_=0.0, const double contrast_=0.0)
MagickCore::QuantizeInfo * quantizeInfo(void)
size_t length(void) const
void floodFillColor(const Geometry &point_, const Color &fillColor_, const bool invert_=false)
ClassType classType(void) const
void levelChannel(const ChannelType channel_, const double blackPoint_, const double whitePoint_, const double gamma_=1.0)
void sigmoidalContrast(const bool sharpen_, const double contrast, const double midpoint=QuantumRange/2.0)
void channel(const ChannelType channel_)
void strokePattern(const Image &strokePattern_)
void * getMetacontent(void)
void options(Options *options_)
void charcoalChannel(const ChannelType channel_, const double radius_=0.0, const double sigma_=1.0)
bool hasChannel(const PixelChannel channel) const
void deskew(const double threshold_)
size_t baseRows(void) const
void fontTypeMetrics(const std::string &text_, TypeMetric *metrics)
void transformOrigin(const double x_, const double y_)
void opaque(const Color &opaqueColor_, const Color &penColor_, const bool invert_=false)
void colorMap(const size_t index_, const Color &color_)
double strokeWidth(void) const
void isValid(bool isValid_)
void copyPixels(const Image &source_, const Geometry &geometry_, const Offset &offset_)
ColorspaceType quantizeColorSpace(void) const
bool monochrome(void) const
void cycleColormap(const ::ssize_t amount_)
void level(const double blackPoint_, const double whitePoint_, const double gamma_=1.0)
bool strokeAntiAlias(void) const
bool compare(const Image &reference_) const
void contrastStretch(const double blackPoint_, const double whitePoint_)
void selectiveBlurChannel(const ChannelType channel_, const double radius_, const double sigma_, const double threshold_)
void levelColorsChannel(const ChannelType channel_, const Color &blackColor_, const Color &whiteColor_, const bool invert_=true)
Color boxColor(void) const
void haldClut(const Image &clutImage_)
void transformSkewY(const double skewy_)
void shear(const double xShearAngle_, const double yShearAngle_)
#define SetPPChannelMask(channel)
DisposeType gifDisposeMethod(void) const
Geometry size(void) const
void transformReset(void)
void rotate(const double degrees_)
void map(const Image &mapImage_, const bool dither_=false)
void lowlightColor(const Color color_)