GetPPException;
if ((matteFlag_ && !constImage()->alpha_trait) ||
(constImage()->alpha_trait && !matteFlag_))
- SetImageAlpha(image(),OpaqueAlpha,&exceptionInfo);
+ SetImageAlpha(image(),OpaqueAlpha,exceptionInfo);
ThrowPPException;
image()->alpha_trait=matteFlag_ ? BlendPixelTrait : UndefinedPixelTrait;
bbox;
GetPPException;
- bbox=GetImageBoundingBox(constImage(),&exceptionInfo);
+ bbox=GetImageBoundingBox(constImage(),exceptionInfo);
ThrowPPException;
return(Geometry(bbox));
}
{
modifyImage();
GetPPException;
- SetImageDepth(image(),depth_,&exceptionInfo);
+ SetImageDepth(image(),depth_,exceptionInfo);
ThrowPPException;
}
channel_depth;
GetPPException;
- channel_depth=GetImageDepth(constImage(),&exceptionInfo);
+ channel_depth=GetImageDepth(constImage(),exceptionInfo);
ThrowPPException;
return(channel_depth);
}
// color map and then set to DirectClass type.
modifyImage();
GetPPException;
- SyncImage(image(),&exceptionInfo);
+ SyncImage(image(),exceptionInfo);
ThrowPPException;
image()->colormap=(PixelInfo *)RelinquishMagickMemory(image()->colormap);
image()->storage_class=static_cast<MagickCore::ClassType>(DirectClass);
GetPPException;
if (clipMask_.isValid())
- SetImageMask(image(),clipMask_.constImage(),&exceptionInfo);
+ SetImageMask(image(),clipMask_.constImage(),exceptionInfo);
else
- SetImageMask(image(),0,&exceptionInfo);
+ SetImageMask(image(),0,exceptionInfo);
ThrowPPException;
}
*image;
GetPPException;
- image=GetImageMask(constImage(),&exceptionInfo);
+ image=GetImageMask(constImage(),exceptionInfo);
ThrowPPException;
if (image == (MagickCore::Image *) NULL)
return(Magick::Image());
modifyImage();
GetPPException;
- (void) AcquireImageColormap(image(),entries_,&exceptionInfo);
+ (void) AcquireImageColormap(image(),entries_,exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
- TransformImageColorspace(image(),colorSpace_,&exceptionInfo);
+ TransformImageColorspace(image(),colorSpace_,exceptionInfo);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- SetImageColorspace(image(),colorSpace_,&exceptionInfo);
+ SetImageColorspace(image(),colorSpace_,exceptionInfo);
ThrowPPException;
options()->colorspaceType(colorSpace_);
}
{
modifyImage();
GetPPException;
- SetImageProperty(image(),"Comment",NULL,&exceptionInfo);
+ SetImageProperty(image(),"Comment",NULL,exceptionInfo);
if (comment_.length() > 0)
- SetImageProperty(image(),"Comment",comment_.c_str(),&exceptionInfo);
+ SetImageProperty(image(),"Comment",comment_.c_str(),exceptionInfo);
ThrowPPException;
}
*value;
GetPPException;
- value=GetImageProperty(constImage(),"Comment",&exceptionInfo);
+ value=GetImageProperty(constImage(),"Comment",exceptionInfo);
ThrowPPException;
if (value)
exif_profile=AcquireStringInfo(exifProfile_.length());
SetStringInfoDatum(exif_profile,(unsigned char *) exifProfile_.data());
GetPPException;
- (void) SetImageProfile(image(),"exif",exif_profile,&exceptionInfo);
+ (void) SetImageProfile(image(),"exif",exif_profile,exceptionInfo);
exif_profile=DestroyStringInfo(exif_profile);
ThrowPPException;
}
*image;
GetPPException;
- image=CloneImage(tmpTexture,0,0,MagickTrue,&exceptionInfo);
+ image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
texture.replaceImage(image);
ThrowPPException;
}
*magick_info;
GetPPException;
- magick_info=GetMagickInfo(constImage()->magick,&exceptionInfo);
+ magick_info=GetMagickInfo(constImage()->magick,exceptionInfo);
ThrowPPException;
if ((magick_info != 0) && (*magick_info->description != '\0'))
GetPPException;
text=InterpretImageProperties(imageInfo(),image(),expression.c_str(),
- &exceptionInfo);
+ exceptionInfo);
if (text != (char *) NULL)
{
result=std::string(text);
iptc_profile=AcquireStringInfo(iptcProfile_.length());
SetStringInfoDatum(iptc_profile,(unsigned char *) iptcProfile_.data());
GetPPException;
- (void) SetImageProfile(image(),"iptc",iptc_profile,&exceptionInfo);
+ (void) SetImageProfile(image(),"iptc",iptc_profile,exceptionInfo);
iptc_profile=DestroyStringInfo(iptc_profile);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- (void) SetImageProperty(image(),"Label",NULL,&exceptionInfo);
+ (void) SetImageProperty(image(),"Label",NULL,exceptionInfo);
if (label_.length() > 0)
- (void) SetImageProperty(image(),"Label",label_.c_str(),&exceptionInfo);
+ (void) SetImageProperty(image(),"Label",label_.c_str(),exceptionInfo);
ThrowPPException;
}
*value;
GetPPException;
- value=GetImageProperty(constImage(),"Label",&exceptionInfo);
+ value=GetImageProperty(constImage(),"Label",exceptionInfo);
ThrowPPException;
if (value)
{
modifyImage();
GetPPException;
- SetImageDepth(image(),depth_,&exceptionInfo);
+ SetImageDepth(image(),depth_,exceptionInfo);
ThrowPPException;
options()->depth(depth_);
}
depth;
GetPPException;
- depth=GetImageDepth(constImage(),&exceptionInfo);
+ depth=GetImageDepth(constImage(),exceptionInfo);
ThrowPPException;
return(depth);
}
*image;
GetPPException;
- image=CloneImage(tmpTexture,0,0,MagickTrue,&exceptionInfo);
+ image=CloneImage(tmpTexture,0,0,MagickTrue,exceptionInfo);
texture.replaceImage(image);
ThrowPPException;
}
colors;
GetPPException;
- colors=GetNumberColors(constImage(),0,&exceptionInfo);
+ colors=GetNumberColors(constImage(),0,exceptionInfo);
ThrowPPException;
return colors;
}
modifyImage();
options()->type(type_);
GetPPException;
- SetImageType(image(),type_,&exceptionInfo);
+ SetImageType(image(),type_,exceptionInfo);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- SetImageVirtualPixelMethod(image(),virtualPixelMethod_,&exceptionInfo);
+ SetImageVirtualPixelMethod(image(),virtualPixelMethod_,exceptionInfo);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=AdaptiveBlurImage(constImage(),radius_,sigma_,&exceptionInfo);
+ newImage=AdaptiveBlurImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
&height);
GetPPException;
- newImage=AdaptiveResizeImage(constImage(),width,height,&exceptionInfo);
+ newImage=AdaptiveResizeImage(constImage(),width,height,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,&exceptionInfo);
+ newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
SetPPChannelMask(channel_);
- newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,&exceptionInfo);
+ newImage=AdaptiveSharpenImage(constImage(),radius_,sigma_,exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowPPException;
GetPPException;
newImage=AdaptiveThresholdImage(constImage(),width_,height_,offset_,
- &exceptionInfo);
+ exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=AddNoiseImage(constImage(),noiseType_,1.0,&exceptionInfo);
+ newImage=AddNoiseImage(constImage(),noiseType_,1.0,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
SetPPChannelMask(channel_);
- newImage=AddNoiseImage(constImage(),noiseType_,1.0,&exceptionInfo);
+ newImage=AddNoiseImage(constImage(),noiseType_,1.0,exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowPPException;
_affine.ty=affine_.ty();
GetPPException;
- newImage=AffineTransformImage(constImage(),&_affine,&exceptionInfo);
+ newImage=AffineTransformImage(constImage(),&_affine,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- SetImageAlpha(image(),alpha_,&exceptionInfo);
+ SetImageAlpha(image(),alpha_,exceptionInfo);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- SetImageAlphaChannel(image(),alphaOption_,&exceptionInfo);
+ SetImageAlphaChannel(image(),alphaOption_,exceptionInfo);
ThrowPPException;
}
GetPPException;
SetPPChannelMask(AlphaChannel);
FloodfillPaintImage(image(),options()->drawInfo(),&target,x_,y_,
- method_ == FloodfillMethod ? MagickFalse : MagickTrue,&exceptionInfo);
+ method_ == FloodfillMethod ? MagickFalse : MagickTrue,exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
}
GetPPException;
- AnnotateImage(image(),drawInfo,&exceptionInfo);
+ AnnotateImage(image(),drawInfo,exceptionInfo);
// Restore original values
drawInfo->affine=oaffine;
drawInfo->gravity=gravity_;
GetPPException;
- AnnotateImage(image(),drawInfo,&exceptionInfo);
+ AnnotateImage(image(),drawInfo,exceptionInfo);
drawInfo->gravity=NorthWestGravity;
drawInfo->text=0;
{
modifyImage();
GetPPException;
- SetImageProperty(image(),name_.c_str(),value_.c_str(),&exceptionInfo);
+ SetImageProperty(image(),name_.c_str(),value_.c_str(),exceptionInfo);
ThrowPPException;
}
*value;
GetPPException;
- value=GetImageProperty(constImage(),name_.c_str(),&exceptionInfo);
+ value=GetImageProperty(constImage(),name_.c_str(),exceptionInfo);
ThrowPPException;
if (value)
{
modifyImage();
GetPPException;
- (void) SyncImageSettings(imageInfo(),image(),&exceptionInfo);
- (void) AutoGammaImage(image(),&exceptionInfo);
+ (void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
+ (void) AutoGammaImage(image(),exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
SetPPChannelMask(channel_);
- (void) SyncImageSettings(imageInfo(),image(),&exceptionInfo);
- (void) AutoGammaImage(image(),&exceptionInfo);
+ (void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
+ (void) AutoGammaImage(image(),exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
{
modifyImage();
GetPPException;
- (void) SyncImageSettings(imageInfo(),image(),&exceptionInfo);
- (void) AutoLevelImage(image(),&exceptionInfo);
+ (void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
+ (void) AutoLevelImage(image(),exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
SetPPChannelMask(channel_);
- (void) SyncImageSettings(imageInfo(),image(),&exceptionInfo);
- (void) AutoLevelImage(image(),&exceptionInfo);
+ (void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
+ (void) AutoLevelImage(image(),exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
return;
GetPPException;
- (void) SyncImageSettings(imageInfo(),image(),&exceptionInfo);
- newImage=AutoOrientImage(constImage(),image()->orientation,&exceptionInfo);
+ (void) SyncImageSettings(imageInfo(),image(),exceptionInfo);
+ newImage=AutoOrientImage(constImage(),image()->orientation,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- BlackThresholdImage(image(),threshold_.c_str(),&exceptionInfo);
+ BlackThresholdImage(image(),threshold_.c_str(),exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
SetPPChannelMask(channel_);
- BlackThresholdImage(image(),threshold_.c_str(),&exceptionInfo);
+ BlackThresholdImage(image(),threshold_.c_str(),exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=BlueShiftImage(constImage(),factor_,&exceptionInfo);
+ newImage=BlueShiftImage(constImage(),factor_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=BlurImage(constImage(),radius_,sigma_,&exceptionInfo);
+ newImage=BlurImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
SetPPChannelMask(channel_);
- newImage=BlurImage(constImage(),radius_,sigma_,&exceptionInfo);
+ newImage=BlurImage(constImage(),radius_,sigma_,exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowPPException;
GetPPException;
newImage=BorderImage(constImage(),&borderInfo,image()->compose,
- &exceptionInfo);
+ exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- BrightnessContrastImage(image(),brightness_,contrast_,&exceptionInfo);
+ BrightnessContrastImage(image(),brightness_,contrast_,exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
SetPPChannelMask(channel_);
- BrightnessContrastImage(image(),brightness_,contrast_,&exceptionInfo);
+ BrightnessContrastImage(image(),brightness_,contrast_,exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
modifyImage();
GetPPException;
newImage=CannyEdgeImage(constImage(),radius_,sigma_,lowerPercent_,
- upperPercent_,&exceptionInfo);
+ upperPercent_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=SeparateImage(image(),channel_,&exceptionInfo);
+ newImage=SeparateImage(image(),channel_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=CharcoalImage(image(),radius_,sigma_,&exceptionInfo);
+ newImage=CharcoalImage(image(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
chopInfo=geometry_;
GetPPException;
- newImage=ChopImage(image(),&chopInfo,&exceptionInfo);
+ newImage=ChopImage(image(),&chopInfo,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- (void) ColorDecisionListImage(image(),cdl_.c_str(),&exceptionInfo);
+ (void) ColorDecisionListImage(image(),cdl_.c_str(),exceptionInfo);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- ClampImage(image(),&exceptionInfo);
+ ClampImage(image(),exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
SetPPChannelMask(channel_);
- ClampImage(image(),&exceptionInfo);
+ ClampImage(image(),exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
{
modifyImage();
GetPPException;
- ClipImage(image(),&exceptionInfo);
+ ClipImage(image(),exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
ClipImagePath(image(),pathname_.c_str(),(MagickBooleanType) inside_,
- &exceptionInfo);
+ exceptionInfo);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- ClutImage(image(),clutImage_.constImage(),method,&exceptionInfo);
+ ClutImage(image(),clutImage_.constImage(),method,exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
SetPPChannelMask(channel_);
- ClutImage(image(),clutImage_.constImage(),method,&exceptionInfo);
+ ClutImage(image(),clutImage_.constImage(),method,exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
target.blue=pixel.blue;
target.alpha=pixel.alpha;
GetPPException;
- newImage=ColorizeImage(image(),blend,&target,&exceptionInfo);
+ newImage=ColorizeImage(image(),blend,&target,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
for (ssize_t i=0; i < (ssize_t) (order_*order_); i++)
kernel_info->values[i]=color_matrix_[i];
- newImage=ColorMatrixImage(image(),kernel_info,&exceptionInfo);
+ newImage=ColorMatrixImage(image(),kernel_info,exceptionInfo);
replaceImage(newImage);
}
kernel_info=DestroyKernelInfo(kernel_info);
GetPPException;
modifyImage();
ref.modifyImage();
- status=static_cast<bool>(IsImagesEqual(image(),ref.image(),&exceptionInfo));
+ status=static_cast<bool>(IsImagesEqual(image(),ref.image(),exceptionInfo));
ThrowPPException;
return(status);
}
GetPPException;
GetImageDistortion(image(),reference_.constImage(),metric_,&distortion,
- &exceptionInfo);
+ exceptionInfo);
ThrowPPException;
return(distortion);
}
GetPPException;
SetPPChannelMask(channel_);
GetImageDistortion(image(),reference_.constImage(),metric_,&distortion,
- &exceptionInfo);
+ exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
return(distortion);
GetPPException;
newImage=CompareImages(image(),reference_.constImage(),metric_,distortion,
- &exceptionInfo);
+ exceptionInfo);
ThrowPPException;
if (newImage == (MagickCore::Image *) NULL)
return(Magick::Image());
GetPPException;
SetPPChannelMask(channel_);
newImage=CompareImages(image(),reference_.constImage(),metric_,distortion,
- &exceptionInfo);
+ exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
if (newImage == (MagickCore::Image *) NULL)
modifyImage();
GetPPException;
CompositeImage(image(),compositeImage_.constImage(),compose_,MagickFalse,
- x,y,&exceptionInfo);
+ x,y,exceptionInfo);
ThrowPPException;
}
GetPPException;
CompositeImage(image(),compositeImage_.constImage(),compose_,MagickFalse,
- geometry.x,geometry.y,&exceptionInfo);
+ geometry.x,geometry.y,exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
CompositeImage(image(),compositeImage_.constImage(),compose_,MagickFalse,
- xOffset_,yOffset_,&exceptionInfo);
+ xOffset_,yOffset_,exceptionInfo);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- ContrastImage(image(),(MagickBooleanType) sharpen_,&exceptionInfo);
+ ContrastImage(image(),(MagickBooleanType) sharpen_,exceptionInfo);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- ContrastStretchImage(image(),blackPoint_,whitePoint_,&exceptionInfo);
+ ContrastStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
SetPPChannelMask(channel_);
- ContrastStretchImage(image(),blackPoint_,whitePoint_,&exceptionInfo);
+ ContrastStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
for (ssize_t i=0; i < (ssize_t) (order_*order_); i++)
kernel_info->values[i]=kernel_[i];
- newImage=ConvolveImage(image(),kernel_info,&exceptionInfo);
+ newImage=ConvolveImage(image(),kernel_info,exceptionInfo);
replaceImage(newImage);
}
kernel_info=DestroyKernelInfo(kernel_info);
cropInfo=geometry_;
GetPPException;
- newImage=CropImage(constImage(),&cropInfo,&exceptionInfo);
+ newImage=CropImage(constImage(),&cropInfo,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- CycleColormapImage(image(),amount_,&exceptionInfo);
+ CycleColormapImage(image(),amount_,exceptionInfo);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- DecipherImage(image(),passphrase_.c_str(),&exceptionInfo);
+ DecipherImage(image(),passphrase_.c_str(),exceptionInfo);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=DeskewImage(constImage(),threshold_,&exceptionInfo);
+ newImage=DeskewImage(constImage(),threshold_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=DespeckleImage(constImage(),&exceptionInfo);
+ newImage=DespeckleImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
image_type;
GetPPException;
- image_type=GetImageType(constImage(),&exceptionInfo);
+ image_type=GetImageType(constImage(),exceptionInfo);
ThrowPPException;
return(image_type);
}
void Magick::Image::display(void)
{
GetPPException;
- DisplayImages(imageInfo(),image(),&exceptionInfo);
+ DisplayImages(imageInfo(),image(),exceptionInfo);
ThrowPPException;
}
GetPPException;
newImage=DistortImage(constImage(), method_,numberArguments_,arguments_,
- bestfit_ == true ? MagickTrue : MagickFalse,&exceptionInfo);
+ bestfit_ == true ? MagickTrue : MagickFalse,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=EdgeImage(constImage(),radius_,&exceptionInfo);
+ newImage=EdgeImage(constImage(),radius_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=EmbossImage(constImage(),radius_,sigma_,&exceptionInfo);
+ newImage=EmbossImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- EncipherImage(image(),passphrase_.c_str(),&exceptionInfo);
+ EncipherImage(image(),passphrase_.c_str(),exceptionInfo);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=EnhanceImage(constImage(),&exceptionInfo);
+ newImage=EnhanceImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- EqualizeImage(image(),&exceptionInfo);
+ EqualizeImage(image(),exceptionInfo);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- (void) SetImageBackgroundColor(image(),&exceptionInfo);
+ (void) SetImageBackgroundColor(image(),exceptionInfo);
ThrowPPException;
}
extentInfo.x=geometry_.xOff();
extentInfo.y=geometry_.yOff();
GetPPException;
- newImage=ExtentImage(image(),&extentInfo,&exceptionInfo);
+ newImage=ExtentImage(image(),&extentInfo,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=FlipImage(constImage(),&exceptionInfo);
+ newImage=FlipImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
FloodfillPaintImage(image(),options()->drawInfo(),&target,
static_cast<ssize_t>(x_), static_cast<ssize_t>(y_),
- method_ == FloodfillMethod ? MagickFalse : MagickTrue,&exceptionInfo);
+ method_ == FloodfillMethod ? MagickFalse : MagickTrue,exceptionInfo);
ThrowPPException;
}
{
GetPPException;
fillPattern=CloneImage(options()->fillPattern(),0,0,MagickTrue,
- &exceptionInfo);
+ exceptionInfo);
ThrowPPException;
}
options()->fillPattern(texture_.constImage());
GetPPException;
FloodfillPaintImage(image(),options()->drawInfo(),&target,
static_cast<ssize_t>(x_),static_cast<ssize_t>(y_),MagickFalse,
- &exceptionInfo);
+ exceptionInfo);
options()->fillPattern(fillPattern);
ThrowPPException;
}
{
GetPPException;
fillPattern=CloneImage(options()->fillPattern(),0,0,MagickTrue,
- &exceptionInfo);
+ exceptionInfo);
ThrowPPException;
}
options()->fillPattern(texture_.constImage());
GetPPException;
FloodfillPaintImage(image(),options()->drawInfo(),&target,
static_cast<ssize_t>(x_),static_cast<ssize_t>(y_),MagickTrue,
- &exceptionInfo);
+ exceptionInfo);
options()->fillPattern(fillPattern);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=FlopImage(constImage(),&exceptionInfo);
+ newImage=FlopImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
drawInfo=options()->drawInfo();
drawInfo->text=const_cast<char *>(text_.c_str());
GetPPException;
- GetTypeMetrics(image(),drawInfo,&(metrics->_typeMetric),&exceptionInfo);
+ GetTypeMetrics(image(),drawInfo,&(metrics->_typeMetric),exceptionInfo);
drawInfo->text=0;
ThrowPPException;
}
drawInfo=options()->drawInfo();
drawInfo->text=const_cast<char *>(text_.c_str());
GetPPException;
- GetMultilineTypeMetrics(image(),drawInfo,&(metrics->_typeMetric),&exceptionInfo);
+ GetMultilineTypeMetrics(image(),drawInfo,&(metrics->_typeMetric),exceptionInfo);
drawInfo->text=0;
ThrowPPException;
}
info.inner_bevel=geometry_.yOff();
GetPPException;
- newImage=FrameImage(constImage(),&info,image()->compose,&exceptionInfo);
+ newImage=FrameImage(constImage(),&info,image()->compose,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
info.inner_bevel=static_cast<ssize_t>(innerBevel_);
GetPPException;
- newImage=FrameImage(constImage(),&info,image()->compose,&exceptionInfo);
+ newImage=FrameImage(constImage(),&info,image()->compose,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=FxImage(constImage(),expression_.c_str(),&exceptionInfo);
+ newImage=FxImage(constImage(),expression_.c_str(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
SetPPChannelMask(channel_);
- newImage=FxImage(constImage(),expression_.c_str(),&exceptionInfo);
+ newImage=FxImage(constImage(),expression_.c_str(),exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowPPException;
{
modifyImage();
GetPPException;
- GammaImage(image(),gamma_,&exceptionInfo);
+ GammaImage(image(),gamma_,exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
- GammaImage(image(),atof(gamma),&exceptionInfo);
+ GammaImage(image(),atof(gamma),exceptionInfo);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=GaussianBlurImage(constImage(),width_,sigma_,&exceptionInfo);
+ newImage=GaussianBlurImage(constImage(),width_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
SetPPChannelMask(channel_);
- newImage=GaussianBlurImage(constImage(),width_,sigma_,&exceptionInfo);
+ newImage=GaussianBlurImage(constImage(),width_,sigma_,exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowPPException;
*p;
GetPPException;
- p=(*GetVirtualPixels)(constImage(),x_, y_,columns_, rows_,&exceptionInfo);
+ p=(*GetVirtualPixels)(constImage(),x_, y_,columns_, rows_,exceptionInfo);
ThrowPPException;
return(p);
}
modifyImage();
GetPPException;
- result=(*GetAuthenticPixels)(image(),x_, y_,columns_,rows_,&exceptionInfo);
+ result=(*GetAuthenticPixels)(image(),x_, y_,columns_,rows_,exceptionInfo);
ThrowPPException;
return(result);
{
modifyImage();
GetPPException;
- (void) HaldClutImage(image(),clutImage_.constImage(),&exceptionInfo);
+ (void) HaldClutImage(image(),clutImage_.constImage(),exceptionInfo);
ThrowPPException;
}
GetPPException;
newImage=HoughLineImage(constImage(),width_,height_,threshold_,
- &exceptionInfo);
+ exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
newImage=ImplodeImage(constImage(),factor_,image()->interpolate,
- &exceptionInfo);
+ exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
newImage=InverseFourierTransformImage(constImage(),phase_.constImage(),
- magnitude_ == true ? MagickTrue : MagickFalse,&exceptionInfo);
+ magnitude_ == true ? MagickTrue : MagickFalse,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- (void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,&exceptionInfo);
+ (void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
SetPPChannelMask(channel_);
- (void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,&exceptionInfo);
+ (void) LevelImage(image(),blackPoint_,whitePoint_,gamma_,exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
GetPPException;
(void) LevelImageColors(image(),&black,&white,invert_ == true ?
- MagickTrue : MagickFalse,&exceptionInfo);
+ MagickTrue : MagickFalse,exceptionInfo);
ThrowPPException;
}
GetPPException;
SetPPChannelMask(channel_);
(void) LevelImageColors(image(),&black,&white,invert_ == true ?
- MagickTrue : MagickFalse,&exceptionInfo);
+ MagickTrue : MagickFalse,exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
{
modifyImage();
GetPPException;
- LinearStretchImage(image(),blackPoint_,whitePoint_,&exceptionInfo);
+ LinearStretchImage(image(),blackPoint_,whitePoint_,exceptionInfo);
ThrowPPException;
}
&height);
GetPPException;
- newImage=LiquidRescaleImage(image(),width,height,x,y,&exceptionInfo);
+ newImage=LiquidRescaleImage(image(),width,height,x,y,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=MagnifyImage(constImage(),&exceptionInfo);
+ newImage=MagnifyImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
options()->quantizeDither(dither_);
RemapImage(options()->quantizeInfo(),image(),mapImage_.constImage(),
- &exceptionInfo);
+ exceptionInfo);
ThrowPPException;
}
GetPPException;
newImage=StatisticImage(image(),MedianStatistic,(size_t) radius_,
- (size_t) radius_,&exceptionInfo);
+ (size_t) radius_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=MinifyImage(constImage(),&exceptionInfo);
+ newImage=MinifyImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
modifyImage();
GetPPException;
- ModulateImage(image(),modulate,&exceptionInfo);
+ ModulateImage(image(),modulate,exceptionInfo);
ThrowPPException;
}
GetPPException;
newImage=MorphologyImage(constImage(),method_,iterations_,kernel,
- &exceptionInfo);
+ exceptionInfo);
replaceImage(newImage);
kernel=DestroyKernelInfo(kernel);
ThrowPPException;
GetPPException;
SetPPChannelMask(channel_);
newImage=MorphologyImage(constImage(),method_,iterations_,kernel,
- &exceptionInfo);
+ exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
kernel=DestroyKernelInfo(kernel);
*newImage;
GetPPException;
- newImage=MotionBlurImage(constImage(),radius_,sigma_,angle_,&exceptionInfo);
+ newImage=MotionBlurImage(constImage(),radius_,sigma_,angle_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- NegateImage(image(),(MagickBooleanType) grayscale_,&exceptionInfo);
+ NegateImage(image(),(MagickBooleanType) grayscale_,exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
SetPPChannelMask(channel_);
- NegateImage(image(),(MagickBooleanType) grayscale_,&exceptionInfo);
+ NegateImage(image(),(MagickBooleanType) grayscale_,exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
{
modifyImage();
GetPPException;
- NormalizeImage(image(),&exceptionInfo);
+ NormalizeImage(image(),exceptionInfo);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=OilPaintImage(constImage(),radius_,sigma_,&exceptionInfo);
+ newImage=OilPaintImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
(void) QueryColorCompliance(opaqueColor.c_str(),AllCompliance,&opaque,
- &exceptionInfo);
+ exceptionInfo);
(void) QueryColorCompliance(penColor.c_str(),AllCompliance,&pen,
- &exceptionInfo);
+ exceptionInfo);
OpaquePaintImage(image(),&opaque,&pen,invert_ ? MagickTrue : MagickFalse,
- &exceptionInfo);
+ exceptionInfo);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- (void) OrderedPosterizeImage(image(),thresholdMap_.c_str(),&exceptionInfo);
+ (void) OrderedPosterizeImage(image(),thresholdMap_.c_str(),exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
SetPPChannelMask(channel_);
- (void) OrderedPosterizeImage(image(),thresholdMap_.c_str(),&exceptionInfo);
+ (void) OrderedPosterizeImage(image(),thresholdMap_.c_str(),exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
{
modifyImage();
GetPPException;
- PerceptibleImage(image(),epsilon_,&exceptionInfo);
+ PerceptibleImage(image(),epsilon_,exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
SetPPChannelMask(channel_);
- PerceptibleImage(image(),epsilon_,&exceptionInfo);
+ PerceptibleImage(image(),epsilon_,exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
GetPPException;
options()->fileName(imageSpec_);
- newImage=PingImage(imageInfo(),&exceptionInfo);
+ newImage=PingImage(imageInfo(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=PingBlob(imageInfo(),blob_.data(),blob_.length(),&exceptionInfo);
+ newImage=PingBlob(imageInfo(),blob_.data(),blob_.length(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
newImage=PolaroidImage(constImage(),options()->drawInfo(),caption_.c_str(),
- angle_,method_,&exceptionInfo);
+ angle_,method_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- PosterizeImage(image(),levels_,method_,&exceptionInfo);
+ PosterizeImage(image(),levels_,method_,exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
SetPPChannelMask(channel_);
- PosterizeImage(image(),levels_,method_,&exceptionInfo);
+ PosterizeImage(image(),levels_,method_,exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
GetPPException;
(void) InvokeDynamicImageFilter(name_.c_str(),&image(),argc,argv,
- &exceptionInfo);
+ exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
(void) ProfileImage(image(),name_.c_str(),(unsigned char *)profile_.data(),
- profile_.length(),&exceptionInfo);
+ profile_.length(),exceptionInfo);
ThrowPPException;
}
options()->quantizeInfo()->measure_error=MagickFalse;
GetPPException;
- QuantizeImage(options()->quantizeInfo(),image(),&exceptionInfo);
+ QuantizeImage(options()->quantizeInfo(),image(),exceptionInfo);
ThrowPPException;
}
{
GetPPException;
SetPPChannelMask(channel_);
- EvaluateImage(image(),operator_,rvalue_,&exceptionInfo);
+ EvaluateImage(image(),operator_,rvalue_,exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
geometry.y = y_;
GetPPException;
- cropImage=CropImage(image(),&geometry,&exceptionInfo);
+ cropImage=CropImage(image(),&geometry,exceptionInfo);
SetPPChannelMask(channel_);
- EvaluateImage(cropImage,operator_,rvalue_,&exceptionInfo);
+ EvaluateImage(cropImage,operator_,rvalue_,exceptionInfo);
RestorePPChannelMask;
(void) CompositeImage(image(),cropImage,image()->alpha_trait ==
BlendPixelTrait ? OverCompositeOp : CopyCompositeOp,MagickFalse,
- geometry.x,geometry.y,&exceptionInfo );
+ geometry.x,geometry.y,exceptionInfo );
cropImage=DestroyImageList(cropImage);
ThrowPPException;
}
GetPPException;
modifyImage();
RaiseImage(image(),&raiseInfo,raisedFlag_ == true ? MagickTrue : MagickFalse,
- &exceptionInfo);
+ exceptionInfo);
ThrowPPException;
}
{
GetPPException;
(void) RandomThresholdImage(image(),static_cast<std::string>(
- thresholds_).c_str(),&exceptionInfo);
+ thresholds_).c_str(),exceptionInfo);
ThrowPPException;
}
GetPPException;
SetPPChannelMask(channel_);
(void) RandomThresholdImage(image(),static_cast<std::string>(
- thresholds_).c_str(),&exceptionInfo);
+ thresholds_).c_str(),exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
GetPPException;
newImage=BlobToImage(imageInfo(),static_cast<const void *>(blob_.data()),
- blob_.length(),&exceptionInfo);
+ blob_.length(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
newImage=ConstituteImage(width_,height_,map_.c_str(),type_, pixels_,
- &exceptionInfo);
+ exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
options()->fileName(imageSpec_);
- newImage=ReadImage(imageInfo(),&exceptionInfo);
+ newImage=ReadImage(imageInfo(),exceptionInfo);
// Ensure that multiple image frames were not read.
if (newImage && newImage->next)
quantum_info=AcquireQuantumInfo(imageInfo(),image());
GetPPException;
ImportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
- quantum_,source_,&exceptionInfo);
+ quantum_,source_,exceptionInfo);
quantum_info=DestroyQuantumInfo(quantum_info);
ThrowPPException;
}
GetPPException;
newImage=StatisticImage(constImage(),NonpeakStatistic,(size_t) order_,
- (size_t) order_,&exceptionInfo);
+ (size_t) order_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
newImage=ResampleImage(constImage(),width,height,image()->filter,
- &exceptionInfo);
+ exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
newImage=ResizeImage(constImage(),width,height,image()->filter,
- &exceptionInfo);
+ exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
yOff = 0 - yOff;
GetPPException;
- newImage=RollImage(constImage(),xOff,yOff,&exceptionInfo);
+ newImage=RollImage(constImage(),xOff,yOff,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
newImage=RollImage(constImage(),static_cast<ssize_t>(columns_),
- static_cast<ssize_t>(rows_),&exceptionInfo);
+ static_cast<ssize_t>(rows_),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=RotateImage(constImage(),degrees_,&exceptionInfo);
+ newImage=RotateImage(constImage(),degrees_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=RotationalBlurImage(constImage(),angle_,&exceptionInfo);
+ newImage=RotationalBlurImage(constImage(),angle_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
SetPPChannelMask(channel_);
- newImage=RotationalBlurImage(constImage(),angle_,&exceptionInfo);
+ newImage=RotationalBlurImage(constImage(),angle_,exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowPPException;
&height);
GetPPException;
- newImage=SampleImage(constImage(),width,height,&exceptionInfo);
+ newImage=SampleImage(constImage(),width,height,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
&height);
GetPPException;
- newImage=ScaleImage(constImage(),width,height,&exceptionInfo);
+ newImage=ScaleImage(constImage(),width,height,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
SegmentImage(image(),options()->quantizeColorSpace(),
(MagickBooleanType) options()->verbose(),clusterThreshold_,
- smoothingThreshold_,&exceptionInfo);
- SyncImage(image(),&exceptionInfo);
+ smoothingThreshold_,exceptionInfo);
+ SyncImage(image(),exceptionInfo);
ThrowPPException;
}
GetPPException;
newImage=SelectiveBlurImage(constImage(),radius_,sigma_,threshold_,
- &exceptionInfo);
+ exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
SetPPChannelMask(channel_);
newImage=SelectiveBlurImage(constImage(),radius_,sigma_,threshold_,
- &exceptionInfo);
+ exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowPPException;
*image;
GetPPException;
- image=SeparateImage(constImage(),channel_,&exceptionInfo);
+ image=SeparateImage(constImage(),channel_,exceptionInfo);
ThrowPPException;
if (image == (MagickCore::Image *) NULL)
return(Magick::Image());
*newImage;
GetPPException;
- newImage=SepiaToneImage(constImage(),threshold_,&exceptionInfo);
+ newImage=SepiaToneImage(constImage(),threshold_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
modifyImage();
GetPPException;
- result=(*QueueAuthenticPixels)(image(),x_,y_,columns_,rows_,&exceptionInfo);
+ result=(*QueueAuthenticPixels)(image(),x_,y_,columns_,rows_,exceptionInfo);
ThrowPPException;
return(result);
}
GetPPException;
newImage=ShadeImage(constImage(),colorShading_ == true ?
- MagickTrue : MagickFalse,azimuth_,elevation_,&exceptionInfo);
+ MagickTrue : MagickFalse,azimuth_,elevation_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
newImage=ShadowImage(constImage(),percent_opacity_, sigma_,x_, y_,
- &exceptionInfo);
+ exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=SharpenImage(constImage(),radius_,sigma_,&exceptionInfo);
+ newImage=SharpenImage(constImage(),radius_,sigma_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
SetPPChannelMask(channel_);
- newImage=SharpenImage(constImage(),radius_,sigma_,&exceptionInfo);
+ newImage=SharpenImage(constImage(),radius_,sigma_,exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowPPException;
shaveInfo=geometry_;
GetPPException;
- newImage=ShaveImage(constImage(),&shaveInfo,&exceptionInfo);
+ newImage=ShaveImage(constImage(),&shaveInfo,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=ShearImage(constImage(),xShearAngle_,yShearAngle_,&exceptionInfo);
+ newImage=ShearImage(constImage(),xShearAngle_,yShearAngle_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
modifyImage();
GetPPException;
(void) SigmoidalContrastImage(image(),(MagickBooleanType) sharpen_,contrast,
- midpoint,&exceptionInfo);
+ midpoint,exceptionInfo);
ThrowPPException;
}
// Re-calculate image signature if necessary
GetPPException;
- if (force_ || !GetImageProperty(constImage(),"Signature",&exceptionInfo) ||
+ if (force_ || !GetImageProperty(constImage(),"Signature",exceptionInfo) ||
constImage()->taint)
SignatureImage(const_cast<MagickCore::Image *>(constImage()),
- &exceptionInfo);
+ exceptionInfo);
- property=GetImageProperty(constImage(),"Signature",&exceptionInfo);
+ property=GetImageProperty(constImage(),"Signature",exceptionInfo);
ThrowPPException;
return(std::string(property));
*newImage;
GetPPException;
- newImage=SketchImage(constImage(),radius_,sigma_,angle_,&exceptionInfo);
+ newImage=SketchImage(constImage(),radius_,sigma_,angle_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- SolarizeImage(image(),factor_,&exceptionInfo);
+ SolarizeImage(image(),factor_,exceptionInfo);
ThrowPPException;
}
GetPPException;
SetPPChannelMask(channel_);
newImage=SparseColorImage(constImage(),method_,numberArguments_,arguments_,
- &exceptionInfo);
+ exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowPPException;
spliceInfo=geometry_;
GetPPException;
- newImage=SpliceImage(constImage(),&spliceInfo,&exceptionInfo);
+ newImage=SpliceImage(constImage(),&spliceInfo,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
newImage=SpreadImage(constImage(),amount_,image()->interpolate,
- &exceptionInfo);
+ exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
SetPPChannelMask(RedChannel);
- (void) GetImageRange(constImage(),&minimum,&maximum,&exceptionInfo);
+ (void) GetImageRange(constImage(),&minimum,&maximum,exceptionInfo);
statistics->red.minimum=minimum;
statistics->red.maximum=maximum;
(void) GetImageMean(constImage(),&statistics->red.mean,
- &statistics->red.standard_deviation,&exceptionInfo);
+ &statistics->red.standard_deviation,exceptionInfo);
(void) GetImageKurtosis(constImage(),&statistics->red.kurtosis,
- &statistics->red.skewness,&exceptionInfo);
+ &statistics->red.skewness,exceptionInfo);
(void) SetImageChannelMask(image(),GreenChannel);
- (void) GetImageRange(constImage(),&minimum,&maximum,&exceptionInfo);
+ (void) GetImageRange(constImage(),&minimum,&maximum,exceptionInfo);
statistics->green.minimum=minimum;
statistics->green.maximum=maximum;
(void) GetImageMean(constImage(),&statistics->green.mean,
- &statistics->green.standard_deviation,&exceptionInfo);
+ &statistics->green.standard_deviation,exceptionInfo);
(void) GetImageKurtosis(constImage(),&statistics->green.kurtosis,
- &statistics->green.skewness,&exceptionInfo);
+ &statistics->green.skewness,exceptionInfo);
(void) SetImageChannelMask(image(),GreenChannel);
- (void) GetImageRange(constImage(),&minimum,&maximum,&exceptionInfo);
+ (void) GetImageRange(constImage(),&minimum,&maximum,exceptionInfo);
statistics->blue.minimum=minimum;
statistics->blue.maximum=maximum;
(void) GetImageMean(constImage(),&statistics->blue.mean,
- &statistics->blue.standard_deviation,&exceptionInfo);
+ &statistics->blue.standard_deviation,exceptionInfo);
(void) GetImageKurtosis(constImage(),&statistics->blue.kurtosis,
- &statistics->blue.skewness,&exceptionInfo);
+ &statistics->blue.skewness,exceptionInfo);
(void) SetImageChannelMask(image(),AlphaChannel);
- (void) GetImageRange(constImage(),&minimum,&maximum,&exceptionInfo);
+ (void) GetImageRange(constImage(),&minimum,&maximum,exceptionInfo);
statistics->alpha.minimum=minimum;
statistics->alpha.maximum=maximum;
(void) GetImageMean(constImage(),&statistics->alpha.mean,
- &statistics->alpha.standard_deviation,&exceptionInfo);
+ &statistics->alpha.standard_deviation,exceptionInfo);
(void) GetImageKurtosis(constImage(),&statistics->alpha.kurtosis,
- &statistics->alpha.skewness,&exceptionInfo);
+ &statistics->alpha.skewness,exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=SteganoImage(constImage(),watermark_.constImage(),&exceptionInfo);
+ newImage=SteganoImage(constImage(),watermark_.constImage(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=StereoImage(constImage(),rightImage_.constImage(),&exceptionInfo);
+ newImage=StereoImage(constImage(),rightImage_.constImage(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- StripImage(image(),&exceptionInfo);
+ StripImage(image(),exceptionInfo);
ThrowPPException;
}
GetPPException;
newImage=SimilarityImage(image(),reference_.constImage(),metric_,
- similarityThreshold,&offset,similarityMetric_,&exceptionInfo);
+ similarityThreshold,&offset,similarityMetric_,exceptionInfo);
ThrowPPException;
if (offset_ != (Geometry *) NULL)
*offset_=offset;
GetPPException;
newImage=SwirlImage(constImage(),degrees_,image()->interpolate,
- &exceptionInfo);
+ exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
void Magick::Image::syncPixels(void)
{
GetPPException;
- (void) (*SyncAuthenticPixels)(image(),&exceptionInfo);
+ (void) (*SyncAuthenticPixels)(image(),exceptionInfo);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- TextureImage(image(),texture_.constImage(),&exceptionInfo);
+ TextureImage(image(),texture_.constImage(),exceptionInfo);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- BilevelImage(image(),threshold_,&exceptionInfo);
+ BilevelImage(image(),threshold_,exceptionInfo);
ThrowPPException;
}
&height);
GetPPException;
- newImage=ThumbnailImage(constImage(),width,height,&exceptionInfo);
+ newImage=ThumbnailImage(constImage(),width,height,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
color=static_cast<PixelInfo>(constOptions()->fillColor());
- newImage=TintImage(constImage(),opacity_.c_str(),&color,&exceptionInfo);
+ newImage=TintImage(constImage(),opacity_.c_str(),&color,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
modifyImage();
GetPPException;
TransformImage(&(image()),0,std::string(imageGeometry_).c_str(),
- &exceptionInfo);
+ exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
TransformImage(&(image()),std::string(cropGeometry_).c_str(),std::string(
- imageGeometry_).c_str(), &exceptionInfo);
+ imageGeometry_).c_str(), exceptionInfo);
ThrowPPException;
}
color=color_;
GetPPException;
(void) QueryColorCompliance(color.c_str(),AllCompliance,&target,
- &exceptionInfo);
+ exceptionInfo);
modifyImage();
TransparentPaintImage(image(),&target,TransparentAlpha,MagickFalse,
- &exceptionInfo);
+ exceptionInfo);
ThrowPPException;
}
GetPPException;
(void) QueryColorCompliance(colorLow.c_str(),AllCompliance,&targetLow,
- &exceptionInfo);
+ exceptionInfo);
(void) QueryColorCompliance(colorHigh.c_str(),AllCompliance,&targetHigh,
- &exceptionInfo);
+ exceptionInfo);
modifyImage();
TransparentPaintImageChroma(image(),&targetLow,&targetHigh,TransparentAlpha,
- MagickFalse,&exceptionInfo);
+ MagickFalse,exceptionInfo);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=TransposeImage(constImage(),&exceptionInfo);
+ newImage=TransposeImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=TransverseImage(constImage(),&exceptionInfo);
+ newImage=TransverseImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*newImage;
GetPPException;
- newImage=TrimImage(constImage(),&exceptionInfo);
+ newImage=TrimImage(constImage(),exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
*image;
GetPPException;
- image=UniqueImageColors(constImage(),&exceptionInfo);
+ image=UniqueImageColors(constImage(),exceptionInfo);
ThrowPPException;
if (image == (MagickCore::Image *) NULL)
return(Magick::Image());
GetPPException;
newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
- &exceptionInfo);
+ exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
SetPPChannelMask(channel_);
newImage=UnsharpMaskImage(constImage(),radius_,sigma_,amount_,threshold_,
- &exceptionInfo);
+ exceptionInfo);
RestorePPChannelMask;
replaceImage(newImage);
ThrowPPException;
*newImage;
GetPPException;
- newImage=VignetteImage(constImage(),radius_,sigma_,x_,y_,&exceptionInfo);
+ newImage=VignetteImage(constImage(),radius_,sigma_,x_,y_,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
GetPPException;
newImage=WaveImage(constImage(),amplitude_,wavelength_,image()->interpolate,
- &exceptionInfo);
+ exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
{
modifyImage();
GetPPException;
- WhiteThresholdImage(image(),threshold_.c_str(),&exceptionInfo);
+ WhiteThresholdImage(image(),threshold_.c_str(),exceptionInfo);
ThrowPPException;
}
modifyImage();
GetPPException;
SetPPChannelMask(channel_);
- WhiteThresholdImage(image(),threshold_.c_str(),&exceptionInfo);
+ WhiteThresholdImage(image(),threshold_.c_str(),exceptionInfo);
RestorePPChannelMask;
ThrowPPException;
}
modifyImage();
GetPPException;
- data=ImagesToBlob(constImageInfo(),image(),&length,&exceptionInfo);
+ data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
if (length > 0)
blob_->updateNoCopy(data,length,Blob::MallocAllocator);
ThrowPPException;
modifyImage();
magick(magick_);
GetPPException;
- data=ImagesToBlob(constImageInfo(),image(),&length,&exceptionInfo);
+ data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
if (length > 0)
blob_->updateNoCopy(data,length,Blob::MallocAllocator);
ThrowPPException;
magick(magick_);
depth(depth_);
GetPPException;
- data=ImagesToBlob(constImageInfo(),image(),&length,&exceptionInfo);
+ data=ImagesToBlob(constImageInfo(),image(),&length,exceptionInfo);
if (length > 0)
blob_->updateNoCopy(data,length,Blob::MallocAllocator);
ThrowPPException;
{
GetPPException;
ExportImagePixels(image(),x_,y_,columns_,rows_,map_.c_str(),type_,pixels_,
- &exceptionInfo);
+ exceptionInfo);
ThrowPPException;
}
modifyImage();
fileName(imageSpec_);
GetPPException;
- WriteImage(constImageInfo(),image(),&exceptionInfo);
+ WriteImage(constImageInfo(),image(),exceptionInfo);
ThrowPPException;
}
quantum_info=AcquireQuantumInfo(imageInfo(),image());
GetPPException;
ExportQuantumPixels(image(),(MagickCore::CacheView *) NULL,quantum_info,
- quantum_,destination_, &exceptionInfo);
+ quantum_,destination_, exceptionInfo);
quantum_info=DestroyQuantumInfo(quantum_info);
ThrowPPException;
}
&height);
GetPPException;
- newImage=ResizeImage(constImage(),width,height,image()->filter,&exceptionInfo);
+ newImage=ResizeImage(constImage(),width,height,image()->filter,exceptionInfo);
replaceImage(newImage);
ThrowPPException;
}
}
GetPPException;
- replaceImage(CloneImage(image(),0,0,MagickTrue,&exceptionInfo));
+ replaceImage(CloneImage(image(),0,0,MagickTrue,exceptionInfo));
ThrowPPException;
}
GetPPException;
_imgRef->id(_imgRef->id()+1);
sprintf(id,"%.20g\n",(double) _imgRef->id());
- SetImageRegistry(ImageRegistryType,id,image(),&exceptionInfo);
+ SetImageRegistry(ImageRegistryType,id,image(),exceptionInfo);
ThrowPPException;
}
return(_imgRef->id());
else
{
GetPPException;
- image=AcquireImage(constImageInfo(),&exceptionInfo);
+ image=AcquireImage(constImageInfo(),exceptionInfo);
ThrowPPException;
}
template <class InputIterator>
void animateImages( InputIterator first_,
InputIterator last_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
linkImages( first_, last_ );
MagickCore::AnimateImages( first_->imageInfo(), first_->image() );
unlinkImages( first_, last_ );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
}
// Append images from list into single image in either horizontal or
InputIterator first_,
InputIterator last_,
bool stack_ = false) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
linkImages( first_, last_ );
MagickCore::Image* image = MagickCore::AppendImages( first_->image(),
(MagickBooleanType) stack_,
- &exceptionInfo );
+ exceptionInfo );
unlinkImages( first_, last_ );
appendedImage_->replaceImage( image );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Average a set of images.
void averageImages( Image *averagedImage_,
InputIterator first_,
InputIterator last_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
linkImages( first_, last_ );
MagickCore::Image* image = MagickCore::EvaluateImages( first_->image(),
- MagickCore::MeanEvaluateOperator, &exceptionInfo );
+ MagickCore::MeanEvaluateOperator, exceptionInfo );
unlinkImages( first_, last_ );
averagedImage_->replaceImage( image );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Merge a sequence of images.
void coalesceImages( Container *coalescedImages_,
InputIterator first_,
InputIterator last_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
// Build image list
linkImages( first_, last_ );
MagickCore::Image* images = MagickCore::CoalesceImages( first_->image(),
- &exceptionInfo);
+ exceptionInfo);
// Unlink image list
unlinkImages( first_, last_ );
insertImages( coalescedImages_, images );
// Report any error
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Return format coders matching specified conditions.
) {
// Obtain first entry in MagickInfo list
size_t number_formats;
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
char **coder_list =
- MagickCore::GetMagickList( "*", &number_formats, &exceptionInfo );
+ MagickCore::GetMagickList( "*", &number_formats, exceptionInfo );
if( !coder_list )
{
throwException( exceptionInfo );
for ( ::ssize_t i=0; i < (::ssize_t) number_formats; i++)
{
const MagickCore::MagickInfo *magick_info =
- MagickCore::GetMagickInfo( coder_list[i], &exceptionInfo );
+ MagickCore::GetMagickInfo( coder_list[i], exceptionInfo );
coder_list[i]=(char *)
MagickCore::RelinquishMagickMemory( coder_list[i] );
}
}
coder_list=(char **) MagickCore::RelinquishMagickMemory( coder_list );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
//
template <class Container >
void colorHistogram( Container *histogram_, const Image image)
{
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
// Obtain histogram array
size_t colors;
MagickCore::PixelInfo *histogram_array =
- MagickCore::GetImageHistogram( image.constImage(), &colors, &exceptionInfo );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ MagickCore::GetImageHistogram( image.constImage(), &colors, exceptionInfo );
+ ThrowPPException;
// Clear out container
histogram_->clear();
InputIterator first_,
InputIterator last_,
const ChannelType channel_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
linkImages( first_, last_ );
- MagickCore::Image* image = CombineImages( first_->image(), channel_, &exceptionInfo );
+ MagickCore::Image* image = CombineImages( first_->image(), channel_, exceptionInfo );
unlinkImages( first_, last_ );
combinedImage_->replaceImage( image );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Break down an image sequence into constituent parts. This is
void deconstructImages( Container *deconstructedImages_,
InputIterator first_,
InputIterator last_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
// Build image list
linkImages( first_, last_ );
MagickCore::Image* images = DeconstructImages( first_->image(),
- &exceptionInfo);
+ exceptionInfo);
// Unlink image list
unlinkImages( first_, last_ );
insertImages( deconstructedImages_, images );
// Report any error
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
//
template <class InputIterator>
void displayImages( InputIterator first_,
InputIterator last_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
linkImages( first_, last_ );
MagickCore::DisplayImages( first_->imageInfo(), first_->image() );
unlinkImages( first_, last_ );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Applies a value to the image with an arithmetic, relational,
InputIterator first_,
InputIterator last_,
const MagickEvaluateOperator operator_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
linkImages( first_, last_ );
- MagickCore::Image* image = EvaluateImages( first_->image(), operator_, &exceptionInfo );
+ MagickCore::Image* image = EvaluateImages( first_->image(), operator_, exceptionInfo );
unlinkImages( first_, last_ );
evaluatedImage_->replaceImage( image );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Merge a sequence of image frames which represent image layers.
void flattenImages( Image *flattendImage_,
InputIterator first_,
InputIterator last_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
linkImages( first_, last_ );
MagickCore::Image* image = MagickCore::MergeImageLayers( first_->image(),
- FlattenLayer,&exceptionInfo );
+ FlattenLayer,exceptionInfo );
unlinkImages( first_, last_ );
flattendImage_->replaceImage( image );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Implements the discrete Fourier transform (DFT) of the image either as a
template <class Container >
void forwardFourierTransformImage( Container *fourierImages_,
const Image &image_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
// Build image list
MagickCore::Image* images = ForwardFourierTransformImage(
- image_.constImage(), MagickTrue, &exceptionInfo);
+ image_.constImage(), MagickTrue, exceptionInfo);
// Ensure container is empty
fourierImages_->clear();
insertImages( fourierImages_, images );
// Report any error
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
template <class Container >
void forwardFourierTransformImage( Container *fourierImages_,
const Image &image_, const bool magnitude_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
// Build image list
MagickCore::Image* images = ForwardFourierTransformImage(
image_.constImage(), magnitude_ == true ? MagickTrue : MagickFalse,
- &exceptionInfo);
+ exceptionInfo);
// Ensure container is empty
fourierImages_->clear();
insertImages( fourierImages_, images );
// Report any error
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Applies a mathematical expression to a sequence of images.
void fxImages(Image *fxImage_,InputIterator first_,InputIterator last_,
const std::string expression)
{
- MagickCore::ExceptionInfo
- exceptionInfo;
-
MagickCore::Image
*image;
- MagickCore::GetExceptionInfo(&exceptionInfo);
+ GetPPException;
linkImages(first_,last_);
image=FxImageChannel(first_->constImage(),DefaultChannels,
- expression.c_str(),&exceptionInfo);
+ expression.c_str(),exceptionInfo);
unlinkImages(first_,last_);
fxImage_->replaceImage(image);
- throwException(exceptionInfo);
- (void) DestroyExceptionInfo(&exceptionInfo);
+ ThrowPPException;
}
// Replace the colors of a sequence of images with the closest color
bool dither_ = false,
bool measureError_ = false ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
- MagickCore::QuantizeInfo quantizeInfo;
MagickCore::GetQuantizeInfo( &quantizeInfo );
quantizeInfo.dither_method = dither_ ? MagickCore::RiemersmaDitherMethod :
MagickCore::NoDitherMethod;
if ( exceptionInfo.severity != MagickCore::UndefinedException )
{
unlinkImages( first_, last_ );
- throwException( exceptionInfo );
}
MagickCore::Image* image = first_->image();
while( image )
{
// Calculate quantization error
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
if ( measureError_ )
{
- MagickCore::GetImageQuantizeError( image, &exceptionInfo );
+ MagickCore::GetImageQuantizeError( image, exceptionInfo );
if ( exceptionInfo.severity > MagickCore::UndefinedException )
{
unlinkImages( first_, last_ );
}
// Udate DirectClass representation of pixels
- MagickCore::SyncImage( image, &exceptionInfo );
+ MagickCore::SyncImage( image, exceptionInfo );
unlinkImages( first_, last_ );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
// Next image
image=image->next;
}
unlinkImages( first_, last_ );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
}
// Composes all the image layers from the current given
InputIterator first_,
InputIterator last_,
const LayerMethod method_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
linkImages( first_, last_ );
- MagickCore::Image* image = MergeImageLayers( first_->image(), method_, &exceptionInfo );
+ MagickCore::Image* image = MergeImageLayers( first_->image(), method_, exceptionInfo );
unlinkImages( first_, last_ );
mergedImage_->replaceImage( image );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Create a composite image by combining several separate images.
// Do montage
GetPPException;
images=MagickCore::MontageImages(first_->image(),montageInfo,
- &exceptionInfo);
+ exceptionInfo);
// Unlink linked image list
unlinkImages(first_,last_);
InputIterator first_,
InputIterator last_,
size_t frames_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
// Build image list
linkImages( first_, last_ );
MagickCore::Image* images = MagickCore::MorphImages( first_->image(), frames_,
- &exceptionInfo);
+ exceptionInfo);
// Unlink image list
unlinkImages( first_, last_ );
insertImages( morphedImages_, images );
// Report any error
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Inlay a number of images to form a single coherent picture.
void mosaicImages( Image *mosaicImage_,
InputIterator first_,
InputIterator last_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
linkImages( first_, last_ );
MagickCore::Image* image = MagickCore::MergeImageLayers( first_->image(),
- MosaicLayer,&exceptionInfo );
+ MosaicLayer,exceptionInfo );
unlinkImages( first_, last_ );
mosaicImage_->replaceImage( image );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Compares each image the GIF disposed forms of the previous image in
void optimizeImageLayers( Container *optimizedImages_,
InputIterator first_,
InputIterator last_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
linkImages( first_, last_ );
- MagickCore::Image* images = OptimizeImageLayers( first_->image(), &exceptionInfo );
+ MagickCore::Image* images = OptimizeImageLayers( first_->image(), exceptionInfo );
unlinkImages( first_, last_ );
insertImages( optimizedImages_, images );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// optimizeImagePlusLayers is exactly as optimizeImageLayers, but may
void optimizePlusImageLayers( Container *optimizedImages_,
InputIterator first_,
InputIterator last_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
linkImages( first_, last_ );
- MagickCore::Image* images = OptimizePlusImageLayers( first_->image(), &exceptionInfo );
+ MagickCore::Image* images = OptimizePlusImageLayers( first_->image(), exceptionInfo );
unlinkImages( first_, last_ );
insertImages( optimizedImages_, images );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPDrawException;
}
// Adds the names of the profiles from the image to the container.
void quantizeImages( InputIterator first_,
InputIterator last_,
bool measureError_ = false ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
linkImages( first_, last_ );
if ( exceptionInfo.severity > MagickCore::UndefinedException )
{
unlinkImages( first_, last_ );
- throwException( exceptionInfo );
}
MagickCore::Image* image = first_->image();
{
// Calculate quantization error
if ( measureError_ )
- MagickCore::GetImageQuantizeError( image, &exceptionInfo );
+ MagickCore::GetImageQuantizeError( image, exceptionInfo );
// Update DirectClass representation of pixels
- MagickCore::SyncImage( image, &exceptionInfo );
+ MagickCore::SyncImage( image, exceptionInfo );
// Next image
image=image->next;
}
unlinkImages( first_, last_ );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Read images into existing container (appending to container)
MagickCore::ImageInfo *imageInfo = MagickCore::CloneImageInfo(0);
imageSpec_.copy( imageInfo->filename, MaxTextExtent-1 );
imageInfo->filename[ imageSpec_.length() ] = 0;
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
- MagickCore::Image* images = MagickCore::ReadImage( imageInfo, &exceptionInfo );
+ GetPPException;
+ MagickCore::Image* images = MagickCore::ReadImage( imageInfo, exceptionInfo );
MagickCore::DestroyImageInfo(imageInfo);
insertImages( sequence_, images);
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
template <class Container>
void readImages( Container *sequence_,
const Blob &blob_ ) {
MagickCore::ImageInfo *imageInfo = MagickCore::CloneImageInfo(0);
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
MagickCore::Image *images = MagickCore::BlobToImage( imageInfo,
blob_.data(),
- blob_.length(), &exceptionInfo );
+ blob_.length(), exceptionInfo );
MagickCore::DestroyImageInfo(imageInfo);
insertImages( sequence_, images );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Returns a separate grayscale image for each channel specified.
void separateImages( Container *separatedImages_,
const Image &image_,
const ChannelType channel_ ) {
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
- MagickCore::Image* images = MagickCore::SeparateImages( image_.constImage(), &exceptionInfo );
+ MagickCore::Image* images = MagickCore::SeparateImages( image_.constImage(), exceptionInfo );
separatedImages_->clear();
insertImages( separatedImages_, images );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Smush images from list into single image in either horizontal or
GetPPException;
linkImages(first_,last_);
newImage=MagickCore::SmushImages(first_->constImage(),
- (MagickBooleanType) stack_,offset_,&exceptionInfo);
+ (MagickBooleanType) stack_,offset_,exceptionInfo);
unlinkImages(first_,last_);
smushedImage_->replaceImage(newImage);
ThrowPPException;
first_->adjoin( adjoin_ );
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
linkImages( first_, last_ );
::ssize_t errorStat = MagickCore::WriteImages( first_->constImageInfo(),
first_->image(),
imageSpec_.c_str(),
- &exceptionInfo );
+ exceptionInfo );
unlinkImages( first_, last_ );
if ( errorStat != false )
{
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ (void) MagickCore::DestroyExceptionInfo( exceptionInfo );
return;
}
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
// Write images to BLOB
template <class InputIterator>
linkImages( first_, last_ );
- MagickCore::ExceptionInfo exceptionInfo;
- MagickCore::GetExceptionInfo( &exceptionInfo );
+ GetPPException;
size_t length = 2048; // Efficient size for small images
void* data = MagickCore::ImagesToBlob( first_->imageInfo(),
first_->image(),
&length,
- &exceptionInfo);
+ exceptionInfo);
blob_->updateNoCopy( data, length, Magick::Blob::MallocAllocator );
unlinkImages( first_, last_ );
- throwException( exceptionInfo );
- (void) MagickCore::DestroyExceptionInfo( &exceptionInfo );
+ ThrowPPException;
}
} // namespace Magick
projects / imagemagick / commitdiff