{
modifyImage();
ChannelType channel_mask = SetPixelChannelMask( image(), channel_ );
- SeparateImage ( image() );
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
+ SeparateImage ( image(), &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
(void) SetPixelChannelMap( image(), channel_mask );
- throwImageException();
}
// Set or obtain modulus channel depth
// results in updating current image.
modifyImage();
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
CompositeImage( image(),
compose_,
compositeImage_.constImage(),
xOffset_,
- yOffset_ );
- throwImageException();
+ yOffset_, &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
void Magick::Image::composite ( const Image &compositeImage_,
const Geometry &offset_,
&x, &y,
&width, &height );
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
CompositeImage( image(),
compose_,
compositeImage_.constImage(),
- x, y );
- throwImageException();
+ x, y, &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
void Magick::Image::composite ( const Image &compositeImage_,
const GravityType gravity_,
SetGeometry(compositeImage_.constImage(), &geometry);
GravityAdjustGeometry(columns(), rows(), gravity_, &geometry);
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
CompositeImage( image(),
compose_,
compositeImage_.constImage(),
- geometry.x, geometry.y );
- throwImageException();
+ geometry.x, geometry.y, &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
// Contrast image
void Magick::Image::alpha ( const unsigned int alpha_ )
{
modifyImage();
- SetImageAlpha( image(), alpha_ );
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
+ SetImageAlpha( image(), alpha_, &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
// Change the color of an opaque pixel to the pen color.
EvaluateImage( crop_image, operator_, rvalue_, &exceptionInfo );
(void) SetPixelChannelMap( image(), channel_mask );
(void) CompositeImage( image(), image()->matte != MagickFalse ?
- OverCompositeOp : CopyCompositeOp, crop_image, geometry.x, geometry.y );
+ OverCompositeOp : CopyCompositeOp, crop_image, geometry.x, geometry.y,
+ &exceptionInfo );
crop_image = DestroyImageList(crop_image);
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
void Magick::Image::texture ( const Image &texture_ )
{
modifyImage();
- TextureImage( image(), texture_.constImage() );
- throwImageException();
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
+ TextureImage( image(), texture_.constImage(), &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
// Threshold image
void Magick::Image::threshold ( const double threshold_ )
{
modifyImage();
- BilevelImage( image(), threshold_ );
- throwImageException();
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
+ BilevelImage( image(), threshold_, &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
// Transform image based on image geometry only
void Magick::Image::transform ( const Geometry &imageGeometry_ )
{
modifyImage();
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
TransformImage ( &(image()), 0,
- std::string(imageGeometry_).c_str() );
- throwImageException();
+ std::string(imageGeometry_).c_str(), &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
// Transform image based on image and crop geometries
void Magick::Image::transform ( const Geometry &imageGeometry_,
const Geometry &cropGeometry_ )
{
modifyImage();
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
TransformImage ( &(image()), std::string(cropGeometry_).c_str(),
- std::string(imageGeometry_).c_str() );
- throwImageException();
+ std::string(imageGeometry_).c_str(), &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
// Add matte image to image, setting pixels matching color to transparent
// matte channel, then create an opaque matte channel. Likewise, if
// the image already has a matte channel but a matte channel is not
// desired, then set the matte channel to opaque.
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
if ((matteFlag_ && !constImage()->matte) ||
(constImage()->matte && !matteFlag_))
- SetImageAlpha(image(),OpaqueAlpha);
+ SetImageAlpha(image(),OpaqueAlpha,&exceptionInfo);
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
image()->matte = (MagickBooleanType) matteFlag_;
}
void Magick::Image::strip ( void )
{
modifyImage();
- StripImage( image() );
- throwImageException();
+ ExceptionInfo exceptionInfo;
+ GetExceptionInfo( &exceptionInfo );
+ StripImage( image(), &exceptionInfo );
+ throwException( exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
}
// enabled/disable stroke anti-aliasing
MagickTrue, // orphan
&exceptionInfo);
throwException( exceptionInfo );
- (void) DestroyExceptionInfo( &exceptionInfo );
+ (void) DestroyExceptionInfo( &exceptionInfo );
texture.replaceImage( image );
}
return texture;
/*
Create X image.
*/
- (void) TransformImageColorspace(image_list[scene],RGBColorspace);
+ (void) TransformImageColorspace(image_list[scene],RGBColorspace,exception);
windows->image.pixmap=(Pixmap) NULL;
windows->image.matte_pixmap=(Pixmap) NULL;
if ((resource_info->map_type != (char *) NULL) ||
resolution.y=resolution.x;
}
if (identity == MagickFalse)
- (void) TransformImage(&annotate_image,"0x0",(char *) NULL);
+ (void) TransformImage(&annotate_image,"0x0",(char *) NULL,exception);
else
{
RectangleInfo
(void) FormatLocaleString(geometry,MaxTextExtent,
"%.20gx%.20g%+.20g%+.20g",(double) crop_info.width,(double)
crop_info.height,(double) crop_info.x,(double) crop_info.y);
- (void) TransformImage(&annotate_image,geometry,(char *) NULL);
+ (void) TransformImage(&annotate_image,geometry,(char *) NULL,exception);
}
metrics->pixels_per_em.x=(resolution.y/DefaultResolution)*
ExpandAffine(&draw_info->affine)*draw_info->pointsize;
annotate_view=DestroyCacheView(annotate_view);
(void) CompositeImage(image,OverCompositeOp,annotate_image,
(ssize_t) ceil(offset->x-0.5),(ssize_t) ceil(offset->y-(metrics->ascent+
- metrics->descent)-0.5));
+ metrics->descent)-0.5),exception);
}
annotate_image=DestroyImage(annotate_image);
return(MagickTrue);
break;
default:
{
- (void) TransformImageColorspace(image,image->colorspace);
+ (void) TransformImageColorspace(image,image->colorspace,exception);
break;
}
}
% The format of the TransformImageColorspace method is:
%
% MagickBooleanType TransformImageColorspace(Image *image,
-% const ColorspaceType colorspace)
+% const ColorspaceType colorspace,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o colorspace: the colorspace.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType TransformImageColorspace(Image *image,
- const ColorspaceType colorspace)
+ const ColorspaceType colorspace,ExceptionInfo *exception)
{
MagickBooleanType
status;
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if (colorspace == UndefinedColorspace)
- return(SetImageColorspace(image,colorspace,&image->exception));
+ return(SetImageColorspace(image,colorspace,exception));
if (image->colorspace == colorspace)
return(MagickTrue);
if ((colorspace == RGBColorspace) || (colorspace == TransparentColorspace))
extern MagickExport MagickBooleanType
RGBTransformImage(Image *,const ColorspaceType),
SetImageColorspace(Image *,const ColorspaceType,ExceptionInfo *),
- TransformImageColorspace(Image *,const ColorspaceType),
+ TransformImageColorspace(Image *,const ColorspaceType,ExceptionInfo *),
TransformRGBImage(Image *,const ColorspaceType);
#if defined(__cplusplus) || defined(c_plusplus)
highlight_view=DestroyCacheView(highlight_view);
reconstruct_view=DestroyCacheView(reconstruct_view);
image_view=DestroyCacheView(image_view);
- (void) CompositeImage(difference_image,image->compose,highlight_image,0,0);
+ (void) CompositeImage(difference_image,image->compose,highlight_image,0,0,
+ exception);
highlight_image=DestroyImage(highlight_image);
if (status == MagickFalse)
difference_image=DestroyImage(difference_image);
%
% MagickBooleanType CompositeImage(Image *image,
% const CompositeOperator compose,Image *composite_image,
-% const ssize_t x_offset,const ssize_t y_offset)
+% const ssize_t x_offset,const ssize_t y_offset,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% Previous to IM v6.5.3-3 this was called "modify-outside-overlay"
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static inline double MagickMin(const double x,const double y)
MagickExport MagickBooleanType CompositeImage(Image *image,
const CompositeOperator compose,const Image *composite_image,
- const ssize_t x_offset,const ssize_t y_offset)
+ const ssize_t x_offset,const ssize_t y_offset,ExceptionInfo *exception)
{
#define CompositeImageTag "Composite/Image"
double
sans;
- ExceptionInfo
- *exception;
-
GeometryInfo
geometry_info;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(composite_image != (Image *) NULL);
assert(composite_image->signature == MagickSignature);
- exception=(&image->exception);
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
GetPixelInfo(image,&zero);
%
% The format of the TextureImage method is:
%
-% MagickBooleanType TextureImage(Image *image,const Image *texture)
+% MagickBooleanType TextureImage(Image *image,const Image *texture,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o texture: This image is the texture to layer on the background.
%
*/
-MagickExport MagickBooleanType TextureImage(Image *image,const Image *texture)
+MagickExport MagickBooleanType TextureImage(Image *image,const Image *texture,
+ ExceptionInfo *exception)
{
#define TextureImageTag "Texture/Image"
*image_view,
*texture_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
if (texture == (const Image *) NULL)
return(MagickFalse);
(void) SetImageVirtualPixelMethod(texture,TileVirtualPixelMethod);
- exception=(&image->exception);
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
status=MagickTrue;
thread_status;
thread_status=CompositeImage(image,image->compose,texture,x+
- texture->tile_offset.x,y+texture->tile_offset.y);
+ texture->tile_offset.x,y+texture->tile_offset.y,exception);
if (thread_status == MagickFalse)
{
status=thread_status;
extern MagickExport MagickBooleanType
CompositeImage(Image *,const CompositeOperator,const Image *,const ssize_t,
- const ssize_t),
- TextureImage(Image *,const Image *);
+ const ssize_t,ExceptionInfo *),
+ TextureImage(Image *,const Image *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
frame_info->inner_bevel);
y=(ssize_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
frame_info->inner_bevel);
- (void) CompositeImage(frame_image,compose,image,x,y);
+ (void) CompositeImage(frame_image,compose,image,x,y,exception);
}
return(frame_image);
}
Composite image with X Image window.
*/
(void) CompositeImage(image,compose,composite_image,composite_info.x,
- composite_info.y);
+ composite_info.y,exception);
composite_image=DestroyImage(composite_image);
XSetCursorState(display,windows,MagickFalse);
/*
windows->image.window_changes.height=(int) cache_image->rows;
(void) FormatLocaleString(image_geometry,MaxTextExtent,"%dx%d!",
windows->image.ximage->width,windows->image.ximage->height);
- (void) TransformImage(image,windows->image.crop_geometry,image_geometry);
+ (void) TransformImage(image,windows->image.crop_geometry,image_geometry,
+ exception);
if (windows->image.crop_geometry != (char *) NULL)
- windows->image.crop_geometry=(char *)
- RelinquishMagickMemory(windows->image.crop_geometry);
+ windows->image.crop_geometry=(char *) RelinquishMagickMemory(
+ windows->image.crop_geometry);
windows->image.crop_geometry=cache_image->geometry;
if (redo_image != (Image *) NULL)
redo_image=DestroyImage(redo_image);
*/
(void) FormatLocaleString(image_geometry,MaxTextExtent,"%dx%d!",
windows->image.ximage->width,windows->image.ximage->height);
- (void) TransformImage(image,windows->image.crop_geometry,image_geometry);
+ (void) TransformImage(image,windows->image.crop_geometry,image_geometry,
+ exception);
if (windows->image.crop_geometry != (char *) NULL)
- windows->image.crop_geometry=(char *)
- RelinquishMagickMemory(windows->image.crop_geometry);
+ windows->image.crop_geometry=(char *) RelinquishMagickMemory(
+ windows->image.crop_geometry);
windows->image.x=0;
windows->image.y=0;
XConfigureImageColormap(display,resource_info,windows,*image);
XSetCursorState(display,windows,MagickTrue);
XCheckRefreshWindows(display,windows);
threshold=SiPrefixToDouble(factor,QuantumRange);
- (void) BilevelImage(*image,threshold);
+ (void) BilevelImage(*image,threshold,exception);
XSetCursorState(display,windows,MagickFalse);
if (windows->image.orphan != MagickFalse)
break;
/*
Paste image with X Image window.
*/
- (void) CompositeImage(image,compose,paste_image,paste_info.x,paste_info.y);
+ (void) CompositeImage(image,compose,paste_image,paste_info.x,paste_info.y,
+ exception);
paste_image=DestroyImage(paste_image);
XSetCursorState(display,windows,MagickFalse);
/*
return(MagickFalse);
(void) FormatLocaleString(geometry,MaxTextExtent,"%dx%d!",
windows->image.ximage->width,windows->image.ximage->height);
- (void) TransformImage(&print_image,windows->image.crop_geometry,geometry);
+ (void) TransformImage(&print_image,windows->image.crop_geometry,geometry,
+ exception);
/*
Print image.
*/
SaveToUndoBufferCommand,image,exception);
windows->image.orphan=MagickFalse;
(void) CompositeImage(*image,CopyCompositeOp,roi_image,
- crop_info.x,crop_info.y);
+ crop_info.x,crop_info.y,exception);
roi_image=DestroyImage(roi_image);
(void) SetImageProgressMonitor(*image,progress_monitor,
(*image)->client_data);
return(MagickFalse);
(void) FormatLocaleString(geometry,MaxTextExtent,"%dx%d!",
windows->image.ximage->width,windows->image.ximage->height);
- (void) TransformImage(&save_image,windows->image.crop_geometry,geometry);
+ (void) TransformImage(&save_image,windows->image.crop_geometry,geometry,
+ exception);
/*
Write image.
*/
distort alpha channel separately
*/
channel_mask=SetPixelChannelMask(tmp_image,AlphaChannel);
- (void) SeparateImage(tmp_image);
+ (void) SeparateImage(tmp_image,exception);
SetPixelChannelMap(tmp_image,channel_mask);
(void) SetImageAlphaChannel(tmp_image,OpaqueAlphaChannel,exception);
resize_alpha=DistortImage(tmp_image,AffineDistortion,12,distort_args,
return((Image *) NULL);
}
/* replace resize images alpha with the separally distorted alpha */
- (void) SetImageAlphaChannel(resize_image,DeactivateAlphaChannel,exception);
- (void) SetImageAlphaChannel(resize_alpha,DeactivateAlphaChannel,exception);
+ (void) SetImageAlphaChannel(resize_image,DeactivateAlphaChannel,
+ exception);
+ (void) SetImageAlphaChannel(resize_alpha,DeactivateAlphaChannel,
+ exception);
(void) CompositeImage(resize_image,CopyOpacityCompositeOp,resize_alpha,
- 0,0);
+ 0,0,exception);
resize_alpha=DestroyImage(resize_alpha);
}
(void) SetImageVirtualPixelMethod(resize_image,vp_save);
(void) FormatLocaleString(geometry,MaxTextExtent,"%gx%g!",
primitive_info[1].point.x,primitive_info[1].point.y);
composite_image->filter=image->filter;
- (void) TransformImage(&composite_image,(char *) NULL,geometry);
+ (void) TransformImage(&composite_image,(char *) NULL,geometry,
+ exception);
}
if (composite_image->matte == MagickFalse)
(void) SetImageAlphaChannel(composite_image,OpaqueAlphaChannel,
exception);
if (draw_info->alpha != OpaqueAlpha)
- (void) SetImageAlpha(composite_image,draw_info->alpha);
+ (void) SetImageAlpha(composite_image,draw_info->alpha,exception);
SetGeometry(image,&geometry);
image->gravity=draw_info->gravity;
geometry.x=x;
(void) DrawAffineImage(image,composite_image,&affine);
else
(void) CompositeImage(image,draw_info->compose,composite_image,
- geometry.x,geometry.y);
+ geometry.x,geometry.y,exception);
composite_image=DestroyImage(composite_image);
break;
}
preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
if (preview_image == (Image *) NULL)
break;
- (void) BilevelImage(thumbnail,
- (double) (percentage*((MagickRealType) QuantumRange+1.0))/100.0);
+ (void) BilevelImage(thumbnail,(double) (percentage*((MagickRealType)
+ QuantumRange+1.0))/100.0,exception);
(void) FormatLocaleString(label,MaxTextExtent,"threshold %g",
(double) (percentage*((MagickRealType) QuantumRange+1.0))/100.0);
break;
}
picture_image->background_color=image->border_color;
(void) SetImageBackgroundColor(picture_image);
- (void) CompositeImage(picture_image,OverCompositeOp,image,quantum,quantum);
+ (void) CompositeImage(picture_image,OverCompositeOp,image,quantum,quantum,
+ exception);
if (caption_image != (Image *) NULL)
{
(void) CompositeImage(picture_image,OverCompositeOp,caption_image,
- quantum,(ssize_t) (image->rows+3*quantum/2));
+ quantum,(ssize_t) (image->rows+3*quantum/2),exception);
caption_image=DestroyImage(caption_image);
}
(void) QueryColorCompliance("none",AllCompliance,
}
polaroid_image=flop_image;
(void) CompositeImage(polaroid_image,OverCompositeOp,picture_image,
- (ssize_t) (-0.01*picture_image->columns/2.0),0L);
+ (ssize_t) (-0.01*picture_image->columns/2.0),0L,exception);
picture_image=DestroyImage(picture_image);
(void) QueryColorCompliance("none",AllCompliance,
&polaroid_image->background_color,exception);
return((Image *) NULL);
(void) NormalizeImage(dodge_image,exception);
(void) NegateImage(dodge_image,MagickFalse,exception);
- (void) TransformImage(&dodge_image,(char *) NULL,"50%");
+ (void) TransformImage(&dodge_image,(char *) NULL,"50%",exception);
sketch_image=CloneImage(image,0,0,MagickTrue,exception);
if (sketch_image == (Image *) NULL)
{
dodge_image=DestroyImage(dodge_image);
return((Image *) NULL);
}
- (void) CompositeImage(sketch_image,ColorDodgeCompositeOp,dodge_image,0,0);
+ (void) CompositeImage(sketch_image,ColorDodgeCompositeOp,dodge_image,0,0,
+ exception);
dodge_image=DestroyImage(dodge_image);
blend_image=CloneImage(image,0,0,MagickTrue,exception);
if (blend_image == (Image *) NULL)
return((Image *) NULL);
}
(void) SetImageArtifact(blend_image,"compose:args","20x80");
- (void) CompositeImage(sketch_image,BlendCompositeOp,blend_image,0,0);
+ (void) CompositeImage(sketch_image,BlendCompositeOp,blend_image,0,0,
+ exception);
blend_image=DestroyImage(blend_image);
return(sketch_image);
}
return((Image *) NULL);
}
blur_image->matte=MagickFalse;
- (void) CompositeImage(canvas_image,CopyOpacityCompositeOp,blur_image,0,0);
+ (void) CompositeImage(canvas_image,CopyOpacityCompositeOp,blur_image,0,0,
+ exception);
blur_image=DestroyImage(blur_image);
vignette_image=MergeImageLayers(canvas_image,FlattenLayer,exception);
canvas_image=DestroyImage(canvas_image);
%
% The format of the SeparateImage method is:
%
-% MagickBooleanType SeparateImage(Image *image)
+% MagickBooleanType SeparateImage(Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-MagickExport MagickBooleanType SeparateImage(Image *image)
+MagickExport MagickBooleanType SeparateImage(Image *image,
+ ExceptionInfo *exception)
{
#define SeparateImageTag "Separate/Image"
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- exception=(&image->exception);
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
/*
{
channel_mask=SetPixelChannelMask(separate_image,
(ChannelType) (1 << i));
- (void) SeparateImage(separate_image);
+ (void) SeparateImage(separate_image,exception);
(void) SetPixelChannelMap(separate_image,channel_mask);
AppendImageToList(&images,separate_image);
}
the alpha channel.
*/
channel_mask=SetPixelChannelMask(image,GrayChannel);
- status=SeparateImage(image);
+ status=SeparateImage(image,exception);
(void) SetPixelChannelMask(image,channel_mask);
image->matte=MagickTrue; /* make sure transparency is now on! */
if (alpha_type == ShapeAlphaChannel)
case ExtractAlphaChannel:
{
channel_mask=SetPixelChannelMask(image,AlphaChannel);
- status=SeparateImage(image);
+ status=SeparateImage(image,exception);
(void) SetPixelChannelMask(image,channel_mask);
image->matte=MagickFalse;
break;
}
case OpaqueAlphaChannel:
{
- status=SetImageAlpha(image,OpaqueAlpha);
+ status=SetImageAlpha(image,OpaqueAlpha,exception);
image->matte=MagickTrue;
break;
}
case TransparentAlphaChannel:
{
- status=SetImageAlpha(image,TransparentAlpha);
+ status=SetImageAlpha(image,TransparentAlpha,exception);
image->matte=MagickTrue;
break;
}
{
if (image->matte == MagickFalse)
{
- status=SetImageAlpha(image,OpaqueAlpha);
+ status=SetImageAlpha(image,OpaqueAlpha,exception);
image->matte=MagickTrue;
}
break;
%
% The format of the SetImageColor method is:
%
-% MagickBooleanType SetImageColor(Image *image,const PixelInfo *color)
+% MagickBooleanType SetImageColor(Image *image,const PixelInfo *color,
+% ExeptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o background: the image color.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType SetImageColor(Image *image,
- const PixelInfo *color)
+ const PixelInfo *color,ExceptionInfo *exception)
{
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
image->fuzz=color->fuzz;
image->depth=color->depth;
status=MagickTrue;
- exception=(&image->exception);
image_view=AcquireCacheView(image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(status)
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% SetImageAlphs() sets the alpha levels of the image.
+% SetImageAlpha() sets the alpha levels of the image.
%
% The format of the SetImageAlpha method is:
%
-% MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha)
+% MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% fully transparent.
%
*/
-MagickExport MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha)
+MagickExport MagickBooleanType SetImageAlpha(Image *image,const Quantum alpha,
+ ExceptionInfo *exception)
{
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
assert(image->signature == MagickSignature);
image->matte=alpha != OpaqueAlpha ? MagickTrue : MagickFalse;
status=MagickTrue;
- exception=(&image->exception);
image_view=AcquireCacheView(image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(status)
case BilevelType:
{
if (IsImageGray(image,&image->exception) == MagickFalse)
- status=TransformImageColorspace(image,GRAYColorspace);
+ status=TransformImageColorspace(image,GRAYColorspace,exception);
if (IsImageMonochrome(image,&image->exception) == MagickFalse)
{
quantize_info=AcquireQuantizeInfo(image_info);
case GrayscaleType:
{
if (IsImageGray(image,&image->exception) == MagickFalse)
- status=TransformImageColorspace(image,GRAYColorspace);
+ status=TransformImageColorspace(image,GRAYColorspace,exception);
image->matte=MagickFalse;
break;
}
case GrayscaleMatteType:
{
if (IsImageGray(image,&image->exception) == MagickFalse)
- status=TransformImageColorspace(image,GRAYColorspace);
+ status=TransformImageColorspace(image,GRAYColorspace,exception);
if (image->matte == MagickFalse)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
break;
case PaletteType:
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- status=TransformImageColorspace(image,RGBColorspace);
+ status=TransformImageColorspace(image,RGBColorspace,exception);
if ((image->storage_class == DirectClass) || (image->colors > 256))
{
quantize_info=AcquireQuantizeInfo(image_info);
channel_mask;
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- status=TransformImageColorspace(image,RGBColorspace);
+ status=TransformImageColorspace(image,RGBColorspace,exception);
if (image->matte == MagickFalse)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
channel_mask=SetPixelChannelMask(image,AlphaChannel);
- (void) BilevelImage(image,(double) QuantumRange/2.0);
+ (void) BilevelImage(image,(double) QuantumRange/2.0,exception);
(void) SetPixelChannelMask(image,channel_mask);
quantize_info=AcquireQuantizeInfo(image_info);
status=QuantizeImage(quantize_info,image,exception);
case PaletteMatteType:
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- status=TransformImageColorspace(image,RGBColorspace);
+ status=TransformImageColorspace(image,RGBColorspace,exception);
if (image->matte == MagickFalse)
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
quantize_info=AcquireQuantizeInfo(image_info);
case TrueColorType:
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- status=TransformImageColorspace(image,RGBColorspace);
+ status=TransformImageColorspace(image,RGBColorspace,exception);
if (image->storage_class != DirectClass)
status=SetImageStorageClass(image,DirectClass,&image->exception);
image->matte=MagickFalse;
case TrueColorMatteType:
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- status=TransformImageColorspace(image,RGBColorspace);
+ status=TransformImageColorspace(image,RGBColorspace,exception);
if (image->storage_class != DirectClass)
status=SetImageStorageClass(image,DirectClass,&image->exception);
if (image->matte == MagickFalse)
if (image->colorspace != CMYKColorspace)
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- status=TransformImageColorspace(image,RGBColorspace);
- status=TransformImageColorspace(image,CMYKColorspace);
+ status=TransformImageColorspace(image,RGBColorspace,exception);
+ status=TransformImageColorspace(image,CMYKColorspace,exception);
}
if (image->storage_class != DirectClass)
status=SetImageStorageClass(image,DirectClass,&image->exception);
if (image->colorspace != CMYKColorspace)
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- status=TransformImageColorspace(image,RGBColorspace);
- status=TransformImageColorspace(image,CMYKColorspace);
+ status=TransformImageColorspace(image,RGBColorspace,exception);
+ status=TransformImageColorspace(image,CMYKColorspace,exception);
}
if (image->storage_class != DirectClass)
status=SetImageStorageClass(image,DirectClass,&image->exception);
x_offset-=SmushXGap(smush_image,image,offset,exception);
y_offset-=geometry.y;
}
- status=CompositeImage(smush_image,OverCompositeOp,image,x_offset,y_offset);
+ status=CompositeImage(smush_image,OverCompositeOp,image,x_offset,y_offset,
+ exception);
proceed=SetImageProgress(image,SmushImageTag,n,number_images);
if (proceed == MagickFalse)
break;
%
% The format of the StripImage method is:
%
-% MagickBooleanType StripImage(Image *image)
+% MagickBooleanType StripImage(Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
-MagickExport MagickBooleanType StripImage(Image *image)
+MagickExport MagickBooleanType StripImage(Image *image,ExceptionInfo *exception)
{
+ MagickBooleanType
+ status;
+
assert(image != (Image *) NULL);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
+ (void) exception;
DestroyImageProfiles(image);
(void) DeleteImageProperty(image,"comment");
(void) DeleteImageProperty(image,"date:create");
(void) DeleteImageProperty(image,"date:modify");
- (void) SetImageArtifact(image,"png:include-chunk","none,trns,gama");
- return(MagickTrue);
+ status=SetImageArtifact(image,"png:include-chunk","none,trns,gama");
+ return(status);
}
\f
/*
ListMagickInfo(FILE *,ExceptionInfo *),
ModifyImage(Image **,ExceptionInfo *),
ResetImagePage(Image *,const char *),
- SeparateImage(Image *),
- SetImageAlpha(Image *,const Quantum),
+ SeparateImage(Image *,ExceptionInfo *),
+ SetImageAlpha(Image *,const Quantum,ExceptionInfo *),
SetImageAlphaChannel(Image *,const AlphaChannelType,ExceptionInfo *),
SetImageBackgroundColor(Image *),
SetImageClipMask(Image *,const Image *,ExceptionInfo *),
- SetImageColor(Image *,const PixelInfo *),
+ SetImageColor(Image *,const PixelInfo *,ExceptionInfo *),
SetImageExtent(Image *,const size_t,const size_t,ExceptionInfo *),
SetImageInfo(ImageInfo *,const unsigned int,ExceptionInfo *),
SetImageMask(Image *,const Image *,ExceptionInfo *),
SetImageStorageClass(Image *,const ClassType,ExceptionInfo *),
SetImageType(Image *,const ImageType,ExceptionInfo *),
- StripImage(Image *),
+ StripImage(Image *,ExceptionInfo *),
SyncImage(Image *),
SyncImageSettings(const ImageInfo *,Image *),
SyncImagesSettings(ImageInfo *,Image *);
*/
dispose_image=CloneImage(coalesce_image,0,0,MagickTrue,exception);
(void) CompositeImage(coalesce_image,CopyCompositeOp,next,next->page.x,
- next->page.y);
+ next->page.y,exception);
next=GetNextImageInList(next);
for ( ; next != (Image *) NULL; next=GetNextImageInList(next))
{
coalesce_image=GetNextImageInList(coalesce_image);
coalesce_image->matte=MagickTrue;
(void) CompositeImage(coalesce_image,next->matte != MagickFalse ?
- OverCompositeOp : CopyCompositeOp,next,next->page.x,next->page.y);
+ OverCompositeOp : CopyCompositeOp,next,next->page.x,next->page.y,
+ exception);
(void) CloneImageProfiles(coalesce_image,next);
(void) CloneImageProperties(coalesce_image,next);
(void) CloneImageArtifacts(coalesce_image,next);
return((Image *) NULL);
}
(void) CompositeImage(current_image,curr->matte != MagickFalse ?
- OverCompositeOp : CopyCompositeOp,curr,curr->page.x,curr->page.y);
+ OverCompositeOp : CopyCompositeOp,curr,curr->page.x,curr->page.y,
+ exception);
/*
Handle Background dispose: image is displayed for the delay period.
image_a->page=next->page;
image_a->page.x=0;
image_a->page.y=0;
- (void) CompositeImage(image_a,CopyCompositeOp,next,next->page.x,next->page.y);
+ (void) CompositeImage(image_a,CopyCompositeOp,next,next->page.x,next->page.y,
+ exception);
/*
Compute the bounding box of changes for the later images
*/
return((Image *) NULL);
}
(void) CompositeImage(image_a,CopyCompositeOp,next,next->page.x,
- next->page.y);
+ next->page.y,exception);
bounds[i]=CompareImagesBounds(image_b,image_a,method,exception);
image_b=DestroyImage(image_b);
return;
}
(void) CompositeImage(current_image,next->matte != MagickFalse ?
- OverCompositeOp : CopyCompositeOp, next,next->page.x,next->page.y);
+ OverCompositeOp : CopyCompositeOp, next,next->page.x,next->page.y,
+ exception);
/*
At this point the image would be displayed, for the delay period
**
next=GetNextImageInList(next);
if ( next != (Image *) NULL ) {
(void) CompositeImage(next, ChangeMaskCompositeOp,
- dispose_image, -(next->page.x), -(next->page.y) );
+ dispose_image, -(next->page.x), -(next->page.y), exception );
}
}
dispose_image=DestroyImage(dispose_image);
% o exception: return any errors or warnings in this structure.
%
*/
+
static inline void CompositeCanvas(Image *destination,
- const CompositeOperator compose, Image *source,ssize_t x_offset,
- ssize_t y_offset )
+ const CompositeOperator compose,Image *source,ssize_t x_offset,
+ ssize_t y_offset,ExceptionInfo *exception)
{
x_offset+=source->page.x-destination->page.x;
y_offset+=source->page.y-destination->page.y;
- (void) CompositeImage(destination,compose,source,x_offset,y_offset);
+ (void) CompositeImage(destination,compose,source,x_offset,y_offset,
+ exception);
}
MagickExport void CompositeLayers(Image *destination,
assert(exception->signature == MagickSignature);
if (source->debug != MagickFalse || destination->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s - %s",
- source->filename, destination->filename);
+ source->filename, destination->filename);
/*
Overlay single source image over destation image/list
if ( source->previous == (Image *) NULL && source->next == (Image *) NULL )
while ( destination != (Image *) NULL )
{
- CompositeCanvas(destination, compose, source, x_offset, y_offset);
+ CompositeCanvas(destination, compose, source, x_offset, y_offset,
+ exception);
destination=GetNextImageInList(destination);
}
{
Image *dest = CloneImage(destination,0,0,MagickTrue,exception);
- CompositeCanvas(destination, compose, source, x_offset, y_offset);
+ CompositeCanvas(destination, compose, source, x_offset, y_offset,
+ exception);
/* copy source image attributes ? */
if ( source->next != (Image *) NULL )
{
CloneImage(dest,0,0,MagickTrue,exception));
destination=GetLastImageInList(destination);
- CompositeCanvas(destination, compose, source, x_offset, y_offset);
+ CompositeCanvas(destination, compose, source, x_offset, y_offset,
+ exception);
destination->delay = source->delay;
destination->iterations = source->iterations;
source=GetNextImageInList(source);
else
while ( source != (Image *) NULL && destination != (Image *) NULL )
{
- CompositeCanvas(destination, compose, source, x_offset, y_offset);
+ CompositeCanvas(destination, compose, source, x_offset, y_offset,
+ exception);
source=GetNextImageInList(source);
destination=GetNextImageInList(destination);
}
% o exception: return any errors or warnings in this structure.
%
*/
-MagickExport Image *MergeImageLayers(Image *image,
- const ImageLayerMethod method,ExceptionInfo *exception)
+MagickExport Image *MergeImageLayers(Image *image,const ImageLayerMethod method,
+ ExceptionInfo *exception)
{
#define MergeLayersTag "Merge/Layers"
for (scene=0; scene < (ssize_t) number_images; scene++)
{
(void) CompositeImage(canvas,image->compose,image,image->page.x-
- canvas->page.x,image->page.y-canvas->page.y);
+ canvas->page.x,image->page.y-canvas->page.y,exception);
proceed=SetImageProgress(image,MergeLayersTag,(MagickOffsetType) scene,
number_images);
if (proceed == MagickFalse)
progress_monitor=SetImageProgressMonitor(montage,(MagickProgressMonitor)
NULL,montage->client_data);
if (texture != (Image *) NULL)
- (void) TextureImage(montage,texture);
+ (void) TextureImage(montage,texture,exception);
if (montage_info->title != (char *) NULL)
{
char
shadow_image=ShadowImage(image,80.0,2.0,5,5,exception);
if (shadow_image != (Image *) NULL)
{
- (void) CompositeImage(shadow_image,OverCompositeOp,image,0,0);
+ (void) CompositeImage(shadow_image,OverCompositeOp,image,0,0,
+ exception);
image=DestroyImage(image);
image=shadow_image;
}
}
(void) CompositeImage(montage,image->compose,image,x_offset+x,
- y_offset+y);
+ y_offset+y,exception);
value=GetImageProperty(image,"label",exception);
if (value != (const char *) NULL)
{
/* Preserve the alpha channel of input image - but turned off */
(void) SetImageAlphaChannel(rslt_image, DeactivateAlphaChannel,
exception);
- (void) CompositeImage(rslt_image, CopyOpacityCompositeOp, image, 0, 0);
+ (void) CompositeImage(rslt_image, CopyOpacityCompositeOp, image, 0, 0,
+ exception);
(void) SetImageAlphaChannel(rslt_image, DeactivateAlphaChannel,
exception);
}
case TopHatMorphology:
case BottomHatMorphology:
if ( verbose == MagickTrue )
- (void) FormatLocaleFile(stderr, "\n%s: Difference with original image",
- CommandOptionToMnemonic(MagickMorphologyOptions, method) );
+ (void) FormatLocaleFile(stderr,
+ "\n%s: Difference with original image",CommandOptionToMnemonic(
+ MagickMorphologyOptions, method) );
curr_image->sync=MagickFalse;
- (void) CompositeImage(curr_image,DifferenceCompositeOp,image,0,0);
+ (void) CompositeImage(curr_image,DifferenceCompositeOp,image,0,0,
+ exception);
break;
case EdgeMorphology:
if ( verbose == MagickTrue )
- (void) FormatLocaleFile(stderr, "\n%s: Difference of Dilate and Erode",
- CommandOptionToMnemonic(MagickMorphologyOptions, method) );
+ (void) FormatLocaleFile(stderr,
+ "\n%s: Difference of Dilate and Erode",CommandOptionToMnemonic(
+ MagickMorphologyOptions, method) );
curr_image->sync=MagickFalse;
(void) CompositeImage(curr_image,DifferenceCompositeOp,save_image,0,
- 0);
+ 0,exception);
save_image = DestroyImage(save_image); /* finished with save image */
break;
default:
(void) FormatLocaleFile(stderr, " (compose \"%s\")",
CommandOptionToMnemonic(MagickComposeOptions, rslt_compose) );
rslt_image->sync=MagickFalse;
- (void) CompositeImage(rslt_image, rslt_compose, curr_image, 0, 0);
+ (void) CompositeImage(rslt_image, rslt_compose, curr_image, 0, 0,
+ exception);
curr_image = DestroyImage(curr_image);
curr_image = (Image *) image; /* continue with original image */
}
if ( bitmap.bmBits == NULL )
bitmap.bmBits = bitmap_bits;
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- TransformImageColorspace(image,RGBColorspace);
+ TransformImageColorspace(image,RGBColorspace,exception);
/*
Extract crop image.
*/
q=bitmap_bits;
if (bitmap.bmBits == NULL)
bitmap.bmBits=bitmap_bits;
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
exception=(&image->exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
if ((cube_info->quantize_info->colorspace != UndefinedColorspace) &&
(cube_info->quantize_info->colorspace != CMYKColorspace))
(void) TransformImageColorspace((Image *) image,
- cube_info->quantize_info->colorspace);
+ cube_info->quantize_info->colorspace,exception);
else
if ((image->colorspace != GRAYColorspace) &&
(IsRGBColorspace(image->colorspace) == MagickFalse) &&
(image->colorspace != CMYColorspace))
- (void) TransformImageColorspace((Image *) image,RGBColorspace);
+ (void) TransformImageColorspace((Image *) image,RGBColorspace,exception);
if (AcquireImageColormap(image,cube_info->colors,exception) == MagickFalse)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
(void) SyncImage(image);
if ((cube_info->quantize_info->colorspace != UndefinedColorspace) &&
(cube_info->quantize_info->colorspace != CMYKColorspace))
- (void) TransformImageColorspace((Image *) image,RGBColorspace);
+ (void) TransformImageColorspace((Image *) image,RGBColorspace,exception);
return(MagickTrue);
}
\f
if ((cube_info->quantize_info->colorspace != UndefinedColorspace) &&
(cube_info->quantize_info->colorspace != CMYKColorspace))
(void) TransformImageColorspace((Image *) image,
- cube_info->quantize_info->colorspace);
+ cube_info->quantize_info->colorspace,exception);
else
if ((image->colorspace != GRAYColorspace) &&
(image->colorspace != CMYColorspace) &&
(IsRGBColorspace(image->colorspace) == MagickFalse))
- (void) TransformImageColorspace((Image *) image,RGBColorspace);
+ (void) TransformImageColorspace((Image *) image,RGBColorspace,exception);
midpoint.red=(MagickRealType) QuantumRange/2.0;
midpoint.green=(MagickRealType) QuantumRange/2.0;
midpoint.blue=(MagickRealType) QuantumRange/2.0;
image_view=DestroyCacheView(image_view);
if ((cube_info->quantize_info->colorspace != UndefinedColorspace) &&
(cube_info->quantize_info->colorspace != CMYKColorspace))
- (void) TransformImageColorspace((Image *) image,RGBColorspace);
+ (void) TransformImageColorspace((Image *) image,RGBColorspace,exception);
return(MagickTrue);
}
\f
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->type != GrayscaleType)
- (void) TransformImageColorspace(image,GRAYColorspace);
+ (void) TransformImageColorspace(image,GRAYColorspace,exception);
colormap_index=(ssize_t *) AcquireQuantumMemory(MaxMap+1,
sizeof(*colormap_index));
if (colormap_index == (ssize_t *) NULL)
}
}
if (IsRGBColorspace(colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,colorspace);
+ (void) TransformImageColorspace(image,colorspace,exception);
/*
Initialize histogram.
*/
status=Classify(image,extrema,cluster_threshold,WeightingExponent,verbose,
exception);
if (IsRGBColorspace(colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,colorspace);
+ (void) TransformImageColorspace(image,colorspace,exception);
/*
Relinquish resources.
*/
%
% The format of the BilevelImage method is:
%
-% MagickBooleanType BilevelImage(Image *image,const double threshold)
+% MagickBooleanType BilevelImage(Image *image,const double threshold,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o threshold: define the threshold values.
%
+% o exception: return any errors or warnings in this structure.
+%
% Aside: You can get the same results as operator using LevelImages()
% with the 'threshold' value for both the black_point and the white_point.
%
*/
-MagickExport MagickBooleanType BilevelImage(Image *image,const double threshold)
+MagickExport MagickBooleanType BilevelImage(Image *image,const double threshold,
+ ExceptionInfo *exception)
{
#define ThresholdImageTag "Threshold/Image"
CacheView
*image_view;
- ExceptionInfo
- *exception;
-
MagickBooleanType
status;
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- exception=(&image->exception);
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
return(MagickFalse);
/*
*GetThresholdMap(const char *,ExceptionInfo *);
extern MagickExport MagickBooleanType
- BilevelImage(Image *,const double),
+ BilevelImage(Image *,const double,ExceptionInfo *),
BlackThresholdImage(Image *,const char *,ExceptionInfo *),
ClampImage(Image *,ExceptionInfo *),
ListThresholdMaps(FILE *,ExceptionInfo *),
extent_image->matte=MagickTrue;
(void) SetImageBackgroundColor(extent_image);
(void) CompositeImage(extent_image,image->compose,image,-geometry->x,
- -geometry->y);
+ -geometry->y,exception);
return(extent_image);
}
\f
% The format of the TransformImage method is:
%
% MagickBooleanType TransformImage(Image **image,const char *crop_geometry,
-% const char *image_geometry)
+% const char *image_geometry,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_geometry: An image geometry string. This geometry defines the
% final size of the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType TransformImage(Image **image,
- const char *crop_geometry,const char *image_geometry)
+ const char *crop_geometry,const char *image_geometry,ExceptionInfo *exception)
{
Image
*resize_image,
/*
Crop image to a user specified size.
*/
- crop_image=CropImageToTiles(*image,crop_geometry,&(*image)->exception);
+ crop_image=CropImageToTiles(*image,crop_geometry,exception);
if (crop_image == (Image *) NULL)
- transform_image=CloneImage(*image,0,0,MagickTrue,&(*image)->exception);
+ transform_image=CloneImage(*image,0,0,MagickTrue,exception);
else
{
transform_image=DestroyImage(transform_image);
/*
Scale image to a user specified size.
*/
- flags=ParseRegionGeometry(transform_image,image_geometry,&geometry,
- &(*image)->exception);
+ flags=ParseRegionGeometry(transform_image,image_geometry,&geometry,exception);
(void) flags;
if ((transform_image->columns == geometry.width) &&
(transform_image->rows == geometry.height))
return(MagickTrue);
resize_image=ResizeImage(transform_image,geometry.width,geometry.height,
- transform_image->filter,transform_image->blur,&(*image)->exception);
+ transform_image->filter,transform_image->blur,exception);
if (resize_image == (Image *) NULL)
return(MagickFalse);
transform_image=DestroyImage(transform_image);
% The format of the TransformImage method is:
%
% MagickBooleanType TransformImages(Image **image,
-% const char *crop_geometry,const char *image_geometry)
+% const char *crop_geometry,const char *image_geometry,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_geometry: An image geometry string. This geometry defines the
% final size of the image.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
MagickExport MagickBooleanType TransformImages(Image **images,
- const char *crop_geometry,const char *image_geometry)
+ const char *crop_geometry,const char *image_geometry,ExceptionInfo *exception)
{
Image
*image,
if ((*images)->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
(*images)->filename);
- image_list=ImageListToArray(*images,&(*images)->exception);
+ image_list=ImageListToArray(*images,exception);
if (image_list == (Image **) NULL)
return(MagickFalse);
status=MagickTrue;
for (i=0; image_list[i] != (Image *) NULL; i++)
{
image=image_list[i];
- status|=TransformImage(&image,crop_geometry,image_geometry);
+ status|=TransformImage(&image,crop_geometry,image_geometry,exception);
AppendImageToList(&transform_images,image);
}
*images=transform_images;
*TrimImage(const Image *,ExceptionInfo *);
extern MagickExport MagickBooleanType
- TransformImage(Image **,const char *,const char *),
- TransformImages(Image **,const char *,const char *);
+ TransformImage(Image **,const char *,const char *,ExceptionInfo *),
+ TransformImages(Image **,const char *,const char *,ExceptionInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
static void
XMakeImageLSBFirst(const XResourceInfo *,const XWindowInfo *,Image *,
- XImage *,XImage *),
+ XImage *,XImage *,ExceptionInfo *),
XMakeImageMSBFirst(const XResourceInfo *,const XWindowInfo *,Image *,
- XImage *,XImage *);
+ XImage *,XImage *,ExceptionInfo *);
static Window
XSelectWindow(Display *,RectangleInfo *);
*/
(void) FormatLocaleString(image_geometry,MaxTextExtent,"%ux%u",
width,height);
- (void) TransformImage(&annotate_image,(char *) NULL,image_geometry);
+ (void) TransformImage(&annotate_image,(char *) NULL,image_geometry,
+ exception);
}
if (annotate_info->degrees != 0.0)
{
(void) XParseGeometry(annotate_info->geometry,&x,&y,&width,&height);
matte=image->matte;
(void) CompositeImage(image,annotate_image->matte != MagickFalse ?
- OverCompositeOp : CopyCompositeOp,annotate_image,(ssize_t) x,(ssize_t) y);
+ OverCompositeOp : CopyCompositeOp,annotate_image,(ssize_t) x,(ssize_t) y,
+ exception);
image->matte=matte;
annotate_image=DestroyImage(annotate_image);
return(MagickTrue);
*/
(void) FormatLocaleString(image_geometry,MaxTextExtent,"%ux%u",
width,height);
- (void) TransformImage(&draw_image,(char *) NULL,image_geometry);
+ (void) TransformImage(&draw_image,(char *) NULL,image_geometry,
+ exception);
}
if (draw_info->degrees != 0.0)
{
(void) XParseGeometry(draw_info->geometry,&x,&y,&width,&height);
if (draw_info->stencil == TransparentStencil)
(void) CompositeImage(image,CopyOpacityCompositeOp,draw_image,(ssize_t) x,
- (ssize_t) y);
+ (ssize_t) y,exception);
else
{
matte=image->matte;
(void) CompositeImage(image,OverCompositeOp,draw_image,(ssize_t) x,
- (ssize_t) y);
+ (ssize_t) y,exception);
image->matte=matte;
}
draw_image=DestroyImage(draw_image);
if (y_offset < 0)
y_offset=0;
(void) CompositeImage(image,CopyCompositeOp,composite_image,(ssize_t)
- x_offset,(ssize_t) y_offset);
+ x_offset,(ssize_t) y_offset,exception);
}
/*
Relinquish resources.
while (colormap_info != (ColormapInfo *) NULL)
{
next=colormap_info->next;
- colormap_info->colors=(XColor *)
- RelinquishMagickMemory(colormap_info->colors);
+ colormap_info->colors=(XColor *) RelinquishMagickMemory(
+ colormap_info->colors);
colormap_info=(ColormapInfo *) RelinquishMagickMemory(colormap_info);
colormap_info=next;
}
if ((ximage->byte_order == LSBFirst) || ((ximage->format == XYBitmap) &&
(ximage->bitmap_bit_order == LSBFirst)))
XMakeImageLSBFirst(resource_info,window,window->image,ximage,
- matte_image);
+ matte_image,exception);
else
XMakeImageMSBFirst(resource_info,window,window->image,ximage,
- matte_image);
+ matte_image,exception);
}
if (window->matte_image != (XImage *) NULL)
{
%
% The format of the XMakeImageLSBFirst method is:
%
-% void XMakeImageLSBFirst(Display *display,XWindows *windows)
+% void XMakeImageLSBFirst(Display *display,XWindows *windows,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o matte_image: Specifies a pointer to a XImage structure; returned from
% XCreateImage.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static void XMakeImageLSBFirst(const XResourceInfo *resource_info,
- const XWindowInfo *window,Image *image,XImage *ximage,XImage *matte_image)
+ const XWindowInfo *window,Image *image,XImage *ximage,XImage *matte_image,
+ ExceptionInfo *exception)
{
CacheView
*canvas_view;
{
canvas=CloneImage(image,0,0,MagickTrue,&image->exception);
if (canvas != (Image *) NULL)
- (void) CompositeImage(canvas,DstOverCompositeOp,pattern,0,0);
+ (void) CompositeImage(canvas,DstOverCompositeOp,pattern,0,0,
+ exception);
pattern=DestroyImage(pattern);
}
}
%
% The format of the XMakeImageMSBFirst method is:
%
-% XMakeImageMSBFirst(resource_info,window,image,ximage,matte_image)
+% XMakeImageMSBFirst(resource_info,window,image,ximage,matte_image,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o matte_image: Specifies a pointer to a XImage structure; returned from
% XCreateImage.
%
+% o exception: return any errors or warnings in this structure.
+%
*/
static void XMakeImageMSBFirst(const XResourceInfo *resource_info,
- const XWindowInfo *window,Image *image,XImage *ximage,XImage *matte_image)
+ const XWindowInfo *window,Image *image,XImage *ximage,XImage *matte_image,
+ ExceptionInfo *exception)
{
CacheView
*canvas_view;
{
canvas=CloneImage(image,0,0,MagickTrue,&image->exception);
if (canvas != (Image *) NULL)
- (void) CompositeImage(canvas,DstOverCompositeOp,pattern,0,0);
+ (void) CompositeImage(canvas,DstOverCompositeOp,pattern,0,0,
+ exception);
pattern=DestroyImage(pattern);
}
}
else
{
(void) CompositeImage(composite_image,CopyCompositeOp,
- reconstruct_image,offset.x,offset.y);
+ reconstruct_image,offset.x,offset.y,exception);
difference_image=CompareImages(image,composite_image,metric,
&distortion,exception);
if (difference_image != (Image *) NULL)
for (y=0; y < (ssize_t) (*image)->rows; y+=(ssize_t) composite_image->rows)
for (x=0; x < (ssize_t) (*image)->columns; x+=(ssize_t) columns)
status&=CompositeImage(*image,composite_options->compose,
- composite_image,x,y);
+ composite_image,x,y,exception);
GetImageException(*image,exception);
}
else
Digitally composite image.
*/
status&=CompositeImage(*image,composite_options->compose,
- composite_image,geometry.x,geometry.y);
+ composite_image,geometry.x,geometry.y,exception);
GetImageException(*image,exception);
}
}
RemoveImageStack(composite_image);
RemoveImageStack(images);
(void) TransformImage(&composite_image,(char *) NULL,
- composite_image->geometry);
+ composite_image->geometry,exception);
RemoveImageStack(mask_image);
if (mask_image != (Image *) NULL)
{
Merge Y displacement into X displacement image.
*/
(void) CompositeImage(composite_image,CopyGreenCompositeOp,mask_image,
- 0,0);
+ 0,0,exception);
mask_image=DestroyImage(mask_image);
}
else
if ((wand->images == (Image *) NULL) ||
(composite_wand->images == (Image *) NULL))
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- status=CompositeImage(wand->images,compose,composite_wand->images,x,y);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
+ status=CompositeImage(wand->images,compose,composite_wand->images,x,y,
+ wand->exception);
return(status);
}
\f
ThrowWandException(WandError,"ContainsNoImages",wand->name);
status=ExportImagePixels(wand->images,x,y,columns,rows,map,
storage,pixels,wand->exception);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
return(status);
}
\f
char
threshold[MaxTextExtent];
- MagickBooleanType
- status;
-
assert(wand != (MagickWand *) NULL);
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
(void) FormatLocaleString(threshold,MaxTextExtent,"%gx%g",low,high);
- status=RandomThresholdImage(wand->images,threshold,wand->exception);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
- return(status);
+ return(RandomThresholdImage(wand->images,threshold,wand->exception));
}
\f
/*
*/
WandExport MagickBooleanType MagickSeparateImage(MagickWand *wand)
{
- MagickBooleanType
- status;
-
assert(wand != (MagickWand *) NULL);
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- status=SeparateImage(wand->images);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
- return(status);
+ return(SeparateImage(wand->images,wand->exception));
}
\f
/*
WandExport MagickBooleanType MagickSetImageColor(MagickWand *wand,
const PixelWand *color)
{
- MagickBooleanType
- status;
-
PixelInfo
pixel;
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
PixelGetMagickColor(color,&pixel);
- status=SetImageColor(wand->images,&pixel);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
- return(status);
+ return(SetImageColor(wand->images,&pixel,wand->exception));
}
\f
/*
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
if ((wand->images->matte == MagickFalse) && (matte != MagickFalse))
- (void) SetImageAlpha(wand->images,OpaqueAlpha);
+ (void) SetImageAlpha(wand->images,OpaqueAlpha,wand->exception);
wand->images->matte=matte;
return(MagickTrue);
}
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- status=SetImageAlpha(wand->images,ClampToQuantum(QuantumRange*alpha));
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
+ status=SetImageAlpha(wand->images,ClampToQuantum(QuantumRange*alpha),
+ wand->exception);
return(status);
}
\f
*/
WandExport MagickBooleanType MagickStripImage(MagickWand *wand)
{
- MagickBooleanType
- status;
-
assert(wand != (MagickWand *) NULL);
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- status=StripImage(wand->images);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
- return(status);
+ return(StripImage(wand->images,wand->exception));
}
\f
/*
texture_image=CloneImage(wand->images,0,0,MagickTrue,wand->exception);
if (texture_image == (Image *) NULL)
return((MagickWand *) NULL);
- status=TextureImage(texture_image,texture_wand->images);
+ status=TextureImage(texture_image,texture_wand->images,wand->exception);
if (status == MagickFalse)
{
- InheritException(wand->exception,&texture_image->exception);
texture_image=DestroyImage(texture_image);
return((MagickWand *) NULL);
}
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- status=BilevelImage(wand->images,threshold);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
+ status=BilevelImage(wand->images,threshold,wand->exception);
return(status);
}
\f
transform_image=CloneImage(wand->images,0,0,MagickTrue,wand->exception);
if (transform_image == (Image *) NULL)
return((MagickWand *) NULL);
- status=TransformImage(&transform_image,crop,geometry);
+ status=TransformImage(&transform_image,crop,geometry,wand->exception);
if (status == MagickFalse)
{
- InheritException(wand->exception,&transform_image->exception);
transform_image=DestroyImage(transform_image);
return((MagickWand *) NULL);
}
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- return(TransformImageColorspace(wand->images,colorspace));
+ return(TransformImageColorspace(wand->images,colorspace,wand->exception));
}
\f
/*
char
thresholds[MaxTextExtent];
- MagickBooleanType
- status;
-
assert(wand != (MagickWand *) NULL);
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
QuantumFormat "," QuantumFormat "," QuantumFormat "," QuantumFormat,
PixelGetRedQuantum(threshold),PixelGetGreenQuantum(threshold),
PixelGetBlueQuantum(threshold),PixelGetAlphaQuantum(threshold));
- status=WhiteThresholdImage(wand->images,thresholds,&wand->images->exception);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
- return(status);
+ return(WhiteThresholdImage(wand->images,thresholds,wand->exception));
}
\f
/*
return(MagickFalse);
write_info=CloneImageInfo(wand->image_info);
write_info->adjoin=MagickTrue;
- status=WriteImage(write_info,image,&image->exception);
+ status=WriteImage(write_info,image,wand->exception);
image=DestroyImage(image);
write_info=DestroyImageInfo(write_info);
return(status);
write_info=CloneImageInfo(wand->image_info);
SetImageInfoFile(write_info,file);
write_info->adjoin=MagickTrue;
- status=WriteImage(write_info,image,&image->exception);
+ status=WriteImage(write_info,image,wand->exception);
write_info=DestroyImageInfo(write_info);
image=DestroyImage(image);
return(status);
write_info=CloneImageInfo(wand->image_info);
write_info->adjoin=adjoin;
status=WriteImages(write_info,wand->images,filename,wand->exception);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
write_info=DestroyImageInfo(write_info);
return(status);
}
status=WriteImages(write_info,wand->images,(const char *) NULL,
wand->exception);
write_info=DestroyImageInfo(write_info);
- if (status == MagickFalse)
- InheritException(wand->exception,&wand->images->exception);
return(status);
}
(void) SyncImageSettings(mogrify_info,*image);
if (*option == '+')
{
- (void) TransformImageColorspace(*image,RGBColorspace);
+ (void) TransformImageColorspace(*image,RGBColorspace,exception);
InheritException(exception,&(*image)->exception);
break;
}
colorspace=(ColorspaceType) ParseCommandOption(
MagickColorspaceOptions,MagickFalse,argv[i+1]);
- (void) TransformImageColorspace(*image,colorspace);
+ (void) TransformImageColorspace(*image,colorspace,exception);
InheritException(exception,&(*image)->exception);
break;
}
*/
(void) CompositeImage(region_image,region_image->matte !=
MagickFalse ? CopyCompositeOp : OverCompositeOp,*image,
- region_geometry.x,region_geometry.y);
- InheritException(exception,®ion_image->exception);
+ region_geometry.x,region_geometry.y,exception);
*image=DestroyImage(*image);
*image=region_image;
region_image = (Image *) NULL;
Strip image of profiles and comments.
*/
(void) SyncImageSettings(mogrify_info,*image);
- (void) StripImage(*image);
- InheritException(exception,&(*image)->exception);
+ (void) StripImage(*image,exception);
break;
}
if (LocaleCompare("stroke",option+1) == 0)
threshold=(double) QuantumRange/2;
else
threshold=SiPrefixToDouble(argv[i+1],QuantumRange);
- (void) BilevelImage(*image,threshold);
+ (void) BilevelImage(*image,threshold,exception);
InheritException(exception,&(*image)->exception);
break;
}
(void) SyncImageSettings(mogrify_info,*image);
(void) CompositeImage(region_image,region_image->matte !=
MagickFalse ? CopyCompositeOp : OverCompositeOp,*image,
- region_geometry.x,region_geometry.y);
- InheritException(exception,®ion_image->exception);
+ region_geometry.x,region_geometry.y,exception);
*image=DestroyImage(*image);
*image=region_image;
region_image = (Image *) NULL;
break;
}
(void) TransformImage(&composite_image,(char *) NULL,
- composite_image->geometry);
+ composite_image->geometry,exception);
SetGeometry(composite_image,&geometry);
(void) ParseAbsoluteGeometry(composite_image->geometry,&geometry);
GravityAdjustGeometry(image->columns,image->rows,image->gravity,
Merge Y displacement into X displacement image.
*/
(void) CompositeImage(composite_image,CopyGreenCompositeOp,
- mask_image,0,0);
+ mask_image,0,0,exception);
mask_image=DestroyImage(mask_image);
}
else
}
}
(void) CompositeImage(image,image->compose,composite_image,
- geometry.x,geometry.y);
+ geometry.x,geometry.y,exception);
if (mask_image != (Image *) NULL)
mask_image=image->mask=DestroyImage(image->mask);
composite_image=DestroyImage(composite_image);
break;
}
for ( ; image; image=image->next)
- (void) TransformImageColorspace(image,(ColorspaceType) sp);
+ (void) TransformImageColorspace(image,(ColorspaceType) sp,
+ exception);
break;
}
if (LocaleCompare(attribute,"comment") == 0)
if (compose != DissolveCompositeOp)
(void) SetImageAlpha(composite_image,(Quantum)
SiPrefixToDouble(argument_list[6].string_reference,
- QuantumRange));
+ QuantumRange),exception);
else
{
CacheView
opacity=(Quantum) SiPrefixToDouble(
argument_list[6].string_reference,QuantumRange);
if (composite_image->matte != MagickTrue)
- (void) SetImageAlpha(composite_image,OpaqueAlpha);
+ (void) SetImageAlpha(composite_image,OpaqueAlpha,exception);
composite_view=AcquireCacheView(composite_image);
for (y=0; y < (ssize_t) composite_image->rows ; y++)
{
for (x=0; x < (ssize_t) image->columns; x+=(ssize_t) composite_image->columns)
{
if (attribute_flag[8] != 0) /* rotate */
- (void) CompositeImage(image,compose,rotate_image,x,y);
+ (void) CompositeImage(image,compose,rotate_image,x,y,
+ exception);
else
- (void) CompositeImage(image,compose,composite_image,x,y);
+ (void) CompositeImage(image,compose,composite_image,x,y,
+ exception);
}
if (attribute_flag[8] != 0) /* rotate */
rotate_image=DestroyImage(rotate_image);
composite_image=CloneImage(composite_image,0,0,MagickTrue,
&image->exception);
(void) CompositeImage(composite_image,CopyGreenCompositeOp,
- argument_list[10].image_reference,0,0);
+ argument_list[10].image_reference,0,0,exception);
}
else
{
exception);
channel_mask=SetPixelChannelMask(image,channel);
if (attribute_flag[8] == 0) /* no rotate */
- CompositeImage(image,compose,composite_image,geometry.x,geometry.y);
+ CompositeImage(image,compose,composite_image,geometry.x,geometry.y,
+ exception);
else
{
/*
composite_image->columns)/2;
geometry.y-=(ssize_t) (rotate_image->rows-
composite_image->rows)/2;
- CompositeImage(image,compose,rotate_image,geometry.x,geometry.y);
+ CompositeImage(image,compose,rotate_image,geometry.x,geometry.y,
+ exception);
rotate_image=DestroyImage(rotate_image);
}
if (attribute_flag[10] != 0) /* mask */
if (attribute_flag[2] != 0)
geometry.y=argument_list[2].integer_reference;
if (image->matte == MagickFalse)
- (void) SetImageAlpha(image,OpaqueAlpha);
+ (void) SetImageAlpha(image,OpaqueAlpha,exception);
(void) GetOneVirtualPixel(image,geometry.x,geometry.y,virtual_pixel,
exception);
target.red=virtual_pixel[RedPixelChannel];
{
if (attribute_flag[0] == 0)
break;
- TextureImage(image,argument_list[0].image_reference);
+ TextureImage(image,argument_list[0].image_reference,exception);
break;
}
case 55: /* Evalute */
threshold=SiPrefixToDouble(argument_list[0].string_reference,
QuantumRange);
channel_mask=SetPixelChannelMask(image,channel);
- (void) BilevelImage(image,threshold);
+ (void) BilevelImage(image,threshold,exception);
(void) SetPixelChannelMask(image,channel_mask);
break;
}
if (attribute_flag[0] != 0)
channel=(ChannelType) argument_list[0].integer_reference;
channel_mask=SetPixelChannelMask(image,channel);
- (void) SeparateImage(image);
+ (void) SeparateImage(image,exception);
(void) SetPixelChannelMask(image,channel_mask);
break;
}
}
case 84: /* Strip */
{
- (void) StripImage(image);
+ (void) StripImage(image,exception);
break;
}
case 85: /* Tint */
if (attribute_flag[0] != 0)
channel=(ChannelType) argument_list[0].integer_reference;
channel_mask=SetPixelChannelMask(image,channel);
- (void) SeparateImage(image);
+ (void) SeparateImage(image,exception);
(void) SetPixelChannelMask(image,channel_mask);
break;
}
if (attribute_flag[0] != 0)
(void) QueryColorCompliance(argument_list[0].string_reference,
AllCompliance,&color,exception);
- (void) SetImageColor(image,&color);
+ (void) SetImageColor(image,&color,exception);
break;
}
case 136: /* Mode */
Composite region.
*/
status=CompositeImage(region_image,CopyCompositeOp,image,
- region_info.x,region_info.y);
+ region_info.x,region_info.y,exception);
(void) status;
(void) CatchImageException(region_image);
image=DestroyImage(image);
clone=CloneImage(image,0,0,MagickTrue,exception);
if ((clone == (Image *) NULL) || (exception->severity >= ErrorException))
goto PerlException;
- TransformImage(&clone,crop_geometry,geometry);
+ TransformImage(&clone,crop_geometry,geometry,exception);
for ( ; clone; clone=clone->next)
{
AddImageToRegistry(sv,clone);
Write AAI header.
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
(void) WriteBlobLSBLong(image,(unsigned int) image->columns);
(void) WriteBlobLSBLong(image,(unsigned int) image->rows);
/*
(void) WriteBlobLSBShort(image,0);
(void) WriteBlobLSBShort(image,(unsigned short) image->rows);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
length=(image->columns+7)/8;
pixels=(unsigned char *) AcquireQuantumMemory(length,sizeof(*pixels));
if (pixels == (unsigned char *) NULL)
Write AVS header.
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
(void) WriteBlobMSBLong(image,(unsigned int) image->columns);
(void) WriteBlobMSBLong(image,(unsigned int) image->rows);
/*
Convert MIFF to BGR raster pixels.
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
if ((LocaleCompare(image_info->magick,"BGRA") == 0) &&
(image->matte == MagickFalse))
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
Initialize BMP raster file header.
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
(void) ResetMagickMemory(&bmp_info,0,sizeof(bmp_info));
bmp_info.file_size=14+12;
if (type > 2)
if (status == MagickFalse)
return(status);
if (image->colorspace != LogColorspace)
- (void) TransformImageColorspace(image,LogColorspace);
+ (void) TransformImageColorspace(image,LogColorspace,exception);
/*
Write image information.
*/
(void) WriteBlobString(image,buffer);
(void) WriteBlobString(image,"<Data>");
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
Convert MIFF to CMYK raster pixels.
*/
if (image->colorspace != CMYKColorspace)
- (void) TransformImageColorspace(image,CMYKColorspace);
+ (void) TransformImageColorspace(image,CMYKColorspace,exception);
if ((LocaleCompare(image_info->magick,"CMYKA") == 0) &&
(image->matte == MagickFalse))
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
Initialize DIB raster file header.
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
if (image->storage_class == DirectClass)
{
/*
(void) FormatLocaleString(filename,MaxTextExtent,"tiff:%s",
write_info->filename);
(void) CopyMagickString(write_info->filename,filename,MaxTextExtent);
- (void) TransformImage(&write_image,(char *) NULL,"512x512>");
+ (void) TransformImage(&write_image,(char *) NULL,"512x512>",exception);
if ((write_image->storage_class == DirectClass) ||
(write_image->colors > 256))
{
Convert MIFF to monochrome.
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
status=HuffmanEncodeImage(write_info,image,image,exception);
if (GetNextImageInList(image) == (Image *) NULL)
break;
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
/*
Allocate image memory.
*/
*/
image->depth=8;
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
memory_limit=20000000;
fpx_status=FPX_SetToolkitMemoryLimit(&memory_limit);
if (fpx_status != FPX_OK)
do
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
opacity=(-1);
if (IsImageOpaque(image,exception) != MagickFalse)
{
image=AcquireImage(image_info,exception);
if ((image->columns == 0) || (image->rows == 0))
ThrowReaderException(OptionError,"MustSpecifyImageSize");
- (void) SetImageAlpha(image,(Quantum) TransparentAlpha);
+ (void) SetImageAlpha(image,(Quantum) TransparentAlpha,exception);
(void) CopyMagickString(image->filename,image_info->filename,MaxTextExtent);
(void) CopyMagickString(colorname,image_info->filename,MaxTextExtent);
(void) sscanf(image_info->filename,"%[^-]",colorname);
Write grayscale pixels.
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
quantum_type=GrayQuantum;
quantum_info=AcquireQuantumInfo(image_info,image);
if (quantum_info == (QuantumInfo *) NULL)
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
/*
Write header.
*/
if (hrz_image == (Image *) NULL)
return(MagickFalse);
if (IsRGBColorspace(hrz_image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(hrz_image,RGBColorspace);
+ (void) TransformImageColorspace(hrz_image,RGBColorspace,exception);
/*
Allocate memory for pixels.
*/
return(status);
(void) CloseBlob(image);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
*url='\0';
if ((LocaleCompare(image_info->magick,"FTP") == 0) ||
(LocaleCompare(image_info->magick,"HTTP") == 0))
Initialize ICON raster file header.
*/
if (next->colorspace != RGBColorspace)
- (void) TransformImageColorspace(next,RGBColorspace);
+ (void) TransformImageColorspace(next,RGBColorspace,exception);
icon_info.file_size=14+12+28;
icon_info.offset_bits=icon_info.file_size;
icon_info.compression=BI_RGB;
ipl_info.height = (unsigned int) image->rows;
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
if(IsRGBColorspace(image->colorspace) == MagickTrue) { ipl_info.colors = 3; }
else{ ipl_info.colors = 1; }
Allocate pixel data.
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
number_packets=(image->columns+7)/8;
pixels=(unsigned char *) AcquireQuantumMemory(number_packets,
image->rows*sizeof(*pixels));
Initialize JPEG 2000 API.
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
jp2_stream=JP2StreamManager(image);
if (jp2_stream == (jas_stream_t *) NULL)
ThrowWriterException(DelegateError,"UnableToManageJP2Stream");
default:
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
break;
}
}
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
/*
Allocate colormap.
*/
do
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
is_gray = IsImageGray(image,exception);
z = is_gray ? 0 : 3;
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
/*
Convert image to a bi-level image.
*/
SetImageType(composite_image,TrueColorMatteType,
&exception);
(void) CompositeImage(composite_image,
- CopyOpacityCompositeOp,msl_info->image[j],0,0);
+ CopyOpacityCompositeOp,msl_info->image[j],0,0,
+ &exception);
break;
}
}
if (compose != DissolveCompositeOp)
{
(void) SetImageAlpha(composite_image,(Quantum)
- opacity);
+ opacity,&exception);
break;
}
(void) SetImageArtifact(msl_info->image[n],
"compose:args",value);
if (composite_image->matte != MagickTrue)
- (void) SetImageAlpha(composite_image,OpaqueAlpha);
+ (void) SetImageAlpha(composite_image,OpaqueAlpha,
+ &exception);
composite_view=AcquireCacheView(composite_image);
for (y=0; y < (ssize_t) composite_image->rows ; y++)
{
{
if (rotate_image != (Image *) NULL)
(void) CompositeImage(image,compose,rotate_image,
- x,y);
+ x,y,&exception);
else
(void) CompositeImage(image,compose,
- composite_image,x,y);
+ composite_image,x,y,&exception);
}
if (rotate_image != (Image *) NULL)
rotate_image=DestroyImage(rotate_image);
&exception);
channel_mask=SetPixelChannelMask(image,channel);
if (rotate_image == (Image *) NULL)
- CompositeImage(image,compose,composite_image,geometry.x,geometry.y);
+ CompositeImage(image,compose,composite_image,geometry.x,geometry.y,
+ &exception);
else
{
/*
composite_image->columns)/2;
geometry.y-=(ssize_t) (rotate_image->rows-
composite_image->rows)/2;
- CompositeImage(image,compose,rotate_image,geometry.x,geometry.y);
+ CompositeImage(image,compose,rotate_image,geometry.x,geometry.y,
+ &exception);
rotate_image=DestroyImage(rotate_image);
}
(void) SetPixelChannelMask(image,channel_mask);
ThrowMSLException(OptionError,"UnrecognizedColorspace",
value);
(void) TransformImageColorspace(msl_info->image[n],
- (ColorspaceType) colorspace);
+ (ColorspaceType) colorspace,&exception);
break;
}
(void) SetMSLAttributes(msl_info,keyword,value);
opac = (int)(QuantumRange * ((float)opac/100));
} else
opac = StringToLong( value );
- (void) SetImageAlpha( msl_info->image[n], (Quantum) opac );
+ (void) SetImageAlpha( msl_info->image[n], (Quantum) opac,
+ &exception);
break;
}
(void) SetMSLAttributes(msl_info,keyword,value);
}
}
}
- (void) TextureImage(msl_info->image[n],texture_image);
+ (void) TextureImage(msl_info->image[n],texture_image,&exception);
texture_image=DestroyImage(texture_image);
break;
}
process image.
*/
{
- BilevelImage(msl_info->image[n],threshold);
- break;
+ BilevelImage(msl_info->image[n],threshold,&exception);
+ break;
}
}
else if (LocaleCompare((const char *) tag, "transparent") == 0)
Allocate memory for pixels.
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
pixels=(unsigned char *) AcquireQuantumMemory((size_t) image->columns,
3UL*sizeof(*pixels));
if (pixels == (unsigned char *) NULL)
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
/*
Convert image to a bi-level image.
*/
do
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
count=GetNumberColors(image,NULL,exception);
for (bits_per_pixel=1; (one << bits_per_pixel) < count; bits_per_pixel*=2) ;
if (image_info->depth > 100)
bits_per_pixel=image_info->depth-100;
if (bits_per_pixel < 16)
- (void) TransformImageColorspace(image,image->colorspace);
+ (void) TransformImageColorspace(image,image->colorspace,exception);
if (bits_per_pixel < 8)
{
- (void) TransformImageColorspace(image,GRAYColorspace);
+ (void) TransformImageColorspace(image,GRAYColorspace,exception);
(void) SetImageType(image,PaletteType,exception);
(void) SortColormapByIntensity(image,exception);
}
affinity_image=ConstituteImage(256,1,"RGB",CharPixel,&PalmPalette,
exception);
(void) TransformImageColorspace(affinity_image,
- affinity_image->colorspace);
+ affinity_image->colorspace,exception);
(void) RemapImage(quantize_info,image,affinity_image,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
image=AcquireImage(blob_info,exception);
image->background_color=pattern_image->background_color;
(void) SetImageBackgroundColor(image);
- (void) TextureImage(image,pattern_image);
+ (void) TextureImage(image,pattern_image,exception);
pattern_image=DestroyImage(pattern_image);
}
blob_info=DestroyImageInfo(blob_info);
*/
static MagickBooleanType WritePCDTile(Image *image,const char *page_geometry,
- const char *tile_geometry)
+ const char *tile_geometry,ExceptionInfo *exception)
{
GeometryInfo
geometry_info;
tile_image=DestroyImage(tile_image);
tile_image=bordered_image;
}
- (void) TransformImage(&tile_image,(char *) NULL,tile_geometry);
+ (void) TransformImage(&tile_image,(char *) NULL,tile_geometry,exception);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(tile_image,YCCColorspace);
+ (void) TransformImageColorspace(tile_image,YCCColorspace,exception);
downsample_image=ResizeImage(tile_image,tile_image->columns/2,
tile_image->rows/2,TriangleFilter,1.0,&image->exception);
if (downsample_image == (Image *) NULL)
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(pcd_image,RGBColorspace);
+ (void) TransformImageColorspace(pcd_image,RGBColorspace,exception);
/*
Write PCD image header.
*/
/*
Write PCD tiles.
*/
- status=WritePCDTile(pcd_image,"768x512>","192x128");
- status=WritePCDTile(pcd_image,"768x512>","384x256");
- status=WritePCDTile(pcd_image,"768x512>","768x512");
+ status=WritePCDTile(pcd_image,"768x512>","192x128",exception);
+ status=WritePCDTile(pcd_image,"768x512>","384x256",exception);
+ status=WritePCDTile(pcd_image,"768x512>","768x512",exception);
(void) CloseBlob(pcd_image);
if (pcd_image != image)
pcd_image=DestroyImage(pcd_image);
do
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
/*
Initialize the printer.
*/
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
page_table=(MagickOffsetType *) NULL;
if ((LocaleCompare(image_info->magick,"DCX") == 0) ||
((GetNextImageInList(image) != (Image *) NULL) &&
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
if (image -> colors <= 2 || GetImageType( image, exception ) == BilevelType) { /* TS */
bits_per_pixel = 1;
if (scanline == (unsigned char *) NULL)
ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
/*
Convert to GRAY raster scanline.
*/
if (compression == JPEG2000Compression)
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
}
/*
Scale relative to dots-per-inch.
if ((code == 0x9a) || (code == 0x9b) ||
((bytes_per_line & 0x8000) != 0))
(void) CompositeImage(image,CopyCompositeOp,tile_image,
- destination.left,destination.top);
+ destination.left,destination.top,exception);
tile_image=DestroyImage(tile_image);
break;
}
MagickMax(image->columns,tile_image->columns),
MagickMax(image->rows,tile_image->rows),exception);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,tile_image->colorspace);
+ (void) TransformImageColorspace(image,tile_image->colorspace,
+ exception);
(void) CompositeImage(image,CopyCompositeOp,tile_image,frame.left,
- frame.right);
+ frame.right,exception);
image->compression=tile_image->compression;
tile_image=DestroyImage(tile_image);
continue;
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
/*
Initialize image info.
*/
}
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
/*
Sometimes we get PseudoClass images whose RGB values don't match
{
/* Add an opaque matte channel */
image->matte = MagickTrue;
- (void) SetImageAlpha(image,OpaqueAlpha);
+ (void) SetImageAlpha(image,OpaqueAlpha,exception);
if (logging != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
(void) CopyMagickString(jpeg_image->magick,"JPEG",MaxTextExtent);
channel_mask=SetPixelChannelMask(jpeg_image,AlphaChannel);
- status=SeparateImage(jpeg_image);
+ status=SeparateImage(jpeg_image,exception);
(void) SetPixelChannelMap(jpeg_image,channel_mask);
jpeg_image->matte=MagickFalse;
if (format != '7')
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
(void) FormatLocaleString(buffer,MaxTextExtent,"%.20g %.20g\n",
(double) image->columns,(double) image->rows);
(void) WriteBlobString(image,buffer);
*/
if ((IsRGBColorspace(image->colorspace) == MagickFalse) &&
(image->colorspace != CMYKColorspace))
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
delta.x=DefaultResolution;
delta.y=DefaultResolution;
resolution.x=image->x_resolution;
if (mask_image == (Image *) NULL)
ThrowWriterException(CoderError,image->exception.reason);
channel_mask=SetPixelChannelMask(mask_image,AlphaChannel);
- status=SeparateImage(mask_image);
+ status=SeparateImage(mask_image,exception);
(void) SetPixelChannelMap(mask_image,channel_mask);
if (status == MagickFalse)
{
(image_info->colorspace != CMYKColorspace))
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
(void) WriteBlobMSBShort(image,(unsigned short)
(image->storage_class == PseudoClass ? IndexedMode : RGBMode));
}
else
{
if (image->colorspace != CMYKColorspace)
- (void) TransformImageColorspace(image,CMYKColorspace);
+ (void) TransformImageColorspace(image,CMYKColorspace,exception);
(void) WriteBlobMSBShort(image,CMYKMode);
}
}
Convert MIFF to RGB raster pixels.
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
if ((LocaleCompare(image_info->magick,"RGBA") == 0) &&
(image->matte == MagickFalse))
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
Initialize SGI raster file header.
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
(void) ResetMagickMemory(&iris_info,0,sizeof(iris_info));
iris_info.magic=0x01DA;
compression=image->compression;
Initialize SUN raster file header.
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
sun_info.magic=0x59a66a95;
if ((image->columns != (unsigned int) image->columns) ||
(image->rows != (unsigned int) image->rows))
if ((image->columns > 65535L) || (image->rows > 65535L))
ThrowWriterException(ImageError,"WidthOrHeightExceedsLimit");
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
targa_info.id_length=0;
value=GetImageProperty(image,"comment",exception);
if (value != (const char *) NULL)
else
{
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
photometric=PHOTOMETRIC_RGB;
}
(void) TIFFSetField(tiff,TIFFTAG_SAMPLESPERPIXEL,3);
if (image->matte != MagickFalse)
quantum_type=CMYKAQuantum;
if (image->colorspace != CMYKColorspace)
- (void) TransformImageColorspace(image,CMYKColorspace);
+ (void) TransformImageColorspace(image,CMYKColorspace,exception);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
tile_image->tile_offset.x=0;
tile_image->tile_offset.y=0;
}
- (void) TextureImage(image,tile_image);
+ (void) TextureImage(image,tile_image,exception);
tile_image=DestroyImage(tile_image);
return(GetFirstImageInList(image));
}
progress_monitor=SetImageProgressMonitor(image,
(MagickProgressMonitor) NULL,image->client_data);
- (void) TextureImage(image,texture);
+ (void) TextureImage(image,texture,exception);
(void) SetImageProgressMonitor(image,progress_monitor,
image->client_data);
}
progress_monitor=SetImageProgressMonitor(image,
(MagickProgressMonitor) NULL,image->client_data);
- (void) TextureImage(image,texture);
+ (void) TextureImage(image,texture,exception);
(void) SetImageProgressMonitor(image,progress_monitor,image->client_data);
}
(void) AnnotateImage(image,draw_info,exception);
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
transparent=MagickFalse;
i=0;
p=(const Quantum *) NULL;
uyvy_image=CloneImage(image,0,0,MagickTrue,exception);
if (uyvy_image == (Image *) NULL)
return(MagickFalse);
- (void) TransformImageColorspace(uyvy_image,YCbCrColorspace);
+ (void) TransformImageColorspace(uyvy_image,YCbCrColorspace,exception);
full=MagickFalse;
(void) ResetMagickMemory(&pixel,0,sizeof(PixelInfo));
for (y=0; y < (ssize_t) image->rows; y++)
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
/*
Write header.
*/
Initialize VIFF image structure.
*/
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
if (IsImageGray(image,exception) != MagickFalse)
(void) SetImageStorageClass(image,DirectClass,exception);
viff_info.identifier=(char) 0xab;
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
/*
Convert image to a bi-level image.
*/
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
/*
Write X bitmap header.
*/
/* composite the tile onto the layer's image, and then destroy it */
(void) CompositeImage(inLayerInfo->image,CopyCompositeOp,tile_image,
- destLeft * TILE_WIDTH,destTop*TILE_HEIGHT);
+ destLeft * TILE_WIDTH,destTop*TILE_HEIGHT,exception);
tile_image=DestroyImage(tile_image);
/* adjust tile position */
Composite the layer data onto the main image, dispose the layer.
*/
(void) CompositeImage(image,OverCompositeOp,layer_info[0].image,
- layer_info[0].offset_x,layer_info[0].offset_y);
+ layer_info[0].offset_x,layer_info[0].offset_y,exception);
layer_info[0].image =DestroyImage( layer_info[0].image);
}
else
(void) CompositeImage(image,CopyCompositeOp,
layer_info[number_layers-1].image,
layer_info[number_layers-1].offset_x,
- layer_info[number_layers-1].offset_y);
+ layer_info[number_layers-1].offset_y,exception);
layer_info[number_layers-1].image=DestroyImage(
layer_info[number_layers-1].image);
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
SetGeometry(image,&geometry);
(void) ParseMetaGeometry(PiconGeometry,&geometry.x,&geometry.y,
&geometry.width,&geometry.height);
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
opacity=(-1);
if (image->matte == MagickFalse)
{
if (status == MagickFalse)
return(status);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
- (void) TransformImageColorspace(image,RGBColorspace);
+ (void) TransformImageColorspace(image,RGBColorspace,exception);
/*
Initialize XWD file header.
*/
Convert MIFF to YCbCr raster pixels.
*/
if (image->colorspace != YCbCrColorspace)
- (void) TransformImageColorspace(image,YCbCrColorspace);
+ (void) TransformImageColorspace(image,YCbCrColorspace,exception);
if ((LocaleCompare(image_info->magick,"YCbCrA") == 0) &&
(image->matte == MagickFalse))
(void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
(void) CloseBlob(image);
return(MagickFalse);
}
- (void) TransformImageColorspace(yuv_image,YCbCrColorspace);
+ (void) TransformImageColorspace(yuv_image,YCbCrColorspace,exception);
/*
Downsample image.
*/
(void) CloseBlob(image);
return(MagickFalse);
}
- (void) TransformImageColorspace(chroma_image,YCbCrColorspace);
+ (void) TransformImageColorspace(chroma_image,YCbCrColorspace,exception);
if (interlace == NoInterlace)
{
/*
projects / imagemagick / commitdiff