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_)