% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MagickAddImage() adds the specified images at the current image location.
+% MagickAddImage() adds a clone of the images in the second wand and
+% inserts them into the first wand, at the current image location.
+%
+% Use MagickSetFirstIterator(), to insert new images before all the current
+% images in the wand, otherwise image is placed after the current image.
%
% The format of the MagickAddImage method is:
%
Image *images)
{
Image
- *sentinel;
+ *current;
+
+ current=wand->images; /* note the current image */
- sentinel=wand->images;
- if (sentinel == (Image *) NULL)
+ /* if no images in wand, just add them and set first image as current */
+ if (current == (Image *) NULL)
{
wand->images=GetFirstImageInList(images);
return(MagickTrue);
}
- if (wand->active == MagickFalse)
+
+ /* user jumped to first image, so prepend new images - remain active */
+ if ((wand->set_first != MagickFalse) &&
+ (current->previous == (Image *) NULL) )
{
- if ((wand->pend != MagickFalse) && (sentinel->next == (Image *) NULL))
+ PrependImageToList(¤t,images);
+ wand->images=GetFirstImageInList(images);
+ return(MagickTrue);
+ }
+ wand->set_first = MagickFalse; /* flag no longer valid */
+
+ /* Current image was flaged as 'pending' iterative processing. */
+ if (wand->image_pending != MagickFalse)
+ {
+ /* current pending image is the last, append new images */
+ if (current->next == (Image *) NULL)
{
- AppendImageToList(&sentinel,images);
+ AppendImageToList(¤t,images);
wand->images=GetLastImageInList(images);
return(MagickTrue);
}
- if ((wand->pend != MagickFalse) && (sentinel->previous == (Image *) NULL))
+ /* current pending image is the first image, prepend it */
+ if (current->previous == (Image *) NULL)
{
- PrependImageToList(&sentinel,images);
+ PrependImageToList(¤t,images);
wand->images=GetFirstImageInList(images);
return(MagickTrue);
}
}
- if (sentinel->next == (Image *) NULL)
+
+ /* if at last image append new images */
+ if (current->next == (Image *) NULL)
{
- InsertImageInList(&sentinel,images);
+ InsertImageInList(¤t,images);
wand->images=GetLastImageInList(images);
return(MagickTrue);
}
- InsertImageInList(&sentinel,images);
+ /* otherwise just insert image, just after the current image */
+ InsertImageInList(¤t,images);
wand->images=GetFirstImageInList(images);
return(MagickTrue);
}
assert(add_wand->signature == WandSignature);
if (add_wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",add_wand->name);
+
+ /* clone images in second wand, and insert into first */
images=CloneImageList(add_wand->images,wand->exception);
if (images == (Image *) NULL)
return(MagickFalse);
%
% MagickGetImageBlob() implements direct to memory image formats. It returns
% the image as a blob (a formatted "file" in memory) and its length, starting
-% from the current position in the image sequence. Use MagickSetImageFormat()
+% from the current position in the image sequence. Use MagickSetImageFormat()
% to set the format to write to the blob (GIF, JPEG, PNG, etc.).
%
% Utilize MagickResetIterator() to ensure the write is from the beginning of
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% MagickNextImage() associates the next image in the image list with a magick
-% wand.
+% wand. It returns true if the it succeeds, meaning the current image is the
+% next image to be iterated over.
%
% The format of the MagickNextImage method is:
%
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- if (wand->pend != MagickFalse)
+ /* If current image is 'pending' just return true. */
+ if (wand->image_pending != MagickFalse)
{
- wand->pend=MagickFalse;
+ wand->image_pending=MagickFalse;
return(MagickTrue);
}
+ /* If there is no next image, (Iterator is finished) */
if (GetNextImageInList(wand->images) == (Image *) NULL)
- {
- wand->pend=MagickTrue;
return(MagickFalse);
- }
+ /* just move to next image - current image is not 'pending' */
wand->images=GetNextImageInList(wand->images);
return(MagickTrue);
}
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MagickPingImage() is like MagickReadImage() except the only valid
+% MagickPingImage() is the same as MagickReadImage() except the only valid
% information returned is the image width, height, size, and format. It
% is designed to efficiently obtain this information from a file without
% reading the entire image sequence into memory.
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- if (wand->pend != MagickFalse)
- {
- wand->pend=MagickFalse;
- return(MagickTrue);
- }
+
+ wand->image_pending=MagickFalse; /* pending status has no meaning */
+ /* If there is no prev image, return false (Iterator is finished) */
if (GetPreviousImageInList(wand->images) == (Image *) NULL)
- {
- wand->pend=MagickTrue;
return(MagickFalse);
- }
+ /* just do it - current image is not 'pending' */
wand->images=GetPreviousImageInList(wand->images);
return(MagickTrue);
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% MagickReadImage() reads an image or image sequence. The images are inserted
-% at the current image pointer position. Use MagickSetFirstIterator(),
-% MagickSetLastIterator, or MagickSetImageIndex() to specify the current
-% image pointer position at the beginning of the image list, the end, or
-% anywhere in-between respectively.
+% at the current image pointer position.
+%
+% Use MagickSetFirstIterator(), to insert new images before all the current
+% images in the wand, MagickSetLastIterator() to append add to the end,
+% MagickSetImageIndex() to place images just after the given index.
%
% The format of the MagickReadImage method is:
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% MagickReadImageBlob() reads an image or image sequence from a blob.
+% In all other respects it is like MagickReadImage().
%
% The format of the MagickReadImageBlob method is:
%
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MagickReadImageFile() reads an image or image sequence from an open file
-% descriptor.
+% MagickReadImageFile() reads an image or image sequence from an already
+% opened file descriptor. Otherwise it is like MagickReadImage().
%
% The format of the MagickReadImageFile method is:
%
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% ClearMagickWand() clears resources associated with the wand.
+% ClearMagickWand() clears resources associated with the wand, leaving the
+% wand blank, and ready to be used for a new set of images.
%
% The format of the ClearMagickWand method is:
%
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->quantize_info=DestroyQuantizeInfo(wand->quantize_info);
- wand->image_info=DestroyImageInfo(wand->image_info);
wand->images=DestroyImageList(wand->images);
- wand->quantize_info=CloneQuantizeInfo((QuantizeInfo *) NULL);
+ if (wand->quantize_info != (QuantizeInfo *) NULL )
+ wand->quantize_info=DestroyQuantizeInfo(wand->quantize_info);
+ if (wand->draw_info != (DrawInfo *) NULL )
+ wand->draw_info=DestroyDrawInfo(wand->draw_info);
wand->image_info=AcquireImageInfo();
ClearMagickException(wand->exception);
wand->debug=IsEventLogging();
clone_wand->exception=AcquireExceptionInfo();
InheritException(clone_wand->exception,wand->exception);
clone_wand->image_info=CloneImageInfo(wand->image_info);
- clone_wand->quantize_info=CloneQuantizeInfo(wand->quantize_info);
+ if ( wand->quantize_info == (QuantizeInfo *) NULL )
+ clone_wand->quantize_info=(QuantizeInfo *) NULL;
+ else
+ clone_wand->quantize_info=CloneQuantizeInfo(wand->quantize_info);
+ if ( wand->draw_info == (DrawInfo *) NULL )
+ clone_wand->draw_info=(DrawInfo *) NULL;
+ else
+ clone_wand->draw_info=CloneDrawInfo(wand->draw_info);
clone_wand->images=CloneImageList(wand->images,clone_wand->exception);
clone_wand->debug=IsEventLogging();
if (clone_wand->debug != MagickFalse)
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->quantize_info=DestroyQuantizeInfo(wand->quantize_info);
+ if (wand->quantize_info != (QuantizeInfo *) NULL )
+ wand->quantize_info=DestroyQuantizeInfo(wand->quantize_info);
+ if (wand->draw_info != (DrawInfo *) NULL )
+ wand->draw_info=DestroyDrawInfo(wand->draw_info);
wand->image_info=DestroyImageInfo(wand->image_info);
wand->images=DestroyImageList(wand->images);
wand->exception=DestroyExceptionInfo(wand->exception);
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->active=MagickFalse;
- wand->pend=MagickTrue;
wand->images=GetFirstImageInList(wand->images);
+ wand->set_first=MagickFalse; /* we did not jump to the first image */
+ wand->image_pending=MagickTrue; /* this image is the 'next' image */
}
\f
/*
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->active=MagickTrue;
- wand->pend=MagickFalse;
wand->images=GetFirstImageInList(wand->images);
+ wand->set_first=MagickTrue; /* we jumped to the first image */
+ wand->image_pending=MagickFalse; /* but this image is not 'next' */
}
\f
/*
InheritException(wand->exception,&wand->images->exception);
return(MagickFalse);
}
- wand->active=MagickTrue;
- wand->pend=MagickFalse;
wand->images=image;
+ wand->set_first=MagickFalse; /* we are not at very start of list */
+ wand->image_pending=MagickFalse; /* but it is not iteration pending */
return(MagickTrue);
}
/*
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- wand->active=MagickFalse;
- wand->pend=MagickTrue;
wand->images=GetLastImageInList(wand->images);
+ wand->set_first=MagickFalse; /* we are not at very start of list */
+ wand->image_pending=MagickFalse; /* and is not iteration pending */
}
\f
/*
wand->id=AcquireWandId();
(void) FormatLocaleString(wand->name,MaxTextExtent,"%s-%.20g",MagickWandId,
(double) wand->id);
- wand->exception=AcquireExceptionInfo();
- wand->image_info=AcquireImageInfo();
- wand->quantize_info=CloneQuantizeInfo((QuantizeInfo *) NULL);
wand->images=NewImageList();
+ wand->image_info=AcquireImageInfo();
+ wand->quantize_info=(QuantizeInfo *) NULL; /* not used in MagickWand API */
+ wand->draw_info=(DrawInfo *) NULL; /* not used in MagickWand API */
+ wand->exception=AcquireExceptionInfo();
wand->debug=IsEventLogging();
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
}
/*
-** SparseColorOption() parse the complex -sparse-color argument into an
-** an array of floating point values than call SparseColorImage().
-** Argument is a complex mix of floating-point pixel coodinates, and color
-** specifications (or direct floating point numbers). The number of floats
-** needed to represent a color varies depending on teh current channel
-** setting.
+ SparseColorOption() parse the complex -sparse-color argument into an
+ an array of floating point values than call SparseColorImage().
+ Argument is a complex mix of floating-point pixel coodinates, and color
+ specifications (or direct floating point numbers). The number of floats
+ needed to represent a color varies depending on teh current channel
+ setting.
*/
static Image *SparseColorOption(const Image *image,
const SparseColorMethod method,const char *arguments,
if ( token[0] == '\0' ) break;
if ( isalpha((int) token[0]) || token[0] == '#' ) {
/* Color string given */
- (void) QueryMagickColorCompliance(token,&color,exception);
+ (void) QueryMagickColorCompliance(token,AllComplience,&color,
+ exception);
if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
sparse_arguments[x++] = QuantumScale*color.red;
if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
if (*argv[0] == '+')
{
(void) DeleteImageOption(image_info,argv[0]+1);
- (void) QueryColorCompliance(BackgroundColor,
+ (void) QueryColorCompliance(BackgroundColor,AllComplience,
&image_info->background_color,exception);
break;
}
(void) SetImageOption(image_info,argv[0]+1,argv[1]);
- (void) QueryColorCompliance(argv[1],&image_info->background_color,
- exception);
+ (void) QueryColorCompliance(argv[1],AllComplience,
+ &image_info->background_color,exception);
break;
}
if (LocaleCompare("bias",argv[0]+1) == 0)
if (*argv[0] == '+')
{
(void) DeleteImageOption(image_info,argv[0]+1);
- (void) QueryColorCompliance(BorderColor,&image_info->border_color,
- exception);
+ (void) QueryColorCompliance(BorderColor,AllComplience,
+ &image_info->border_color,exception);
break;
}
- (void) QueryColorCompliance(argv[1],&image_info->border_color,
+ (void) QueryColorCompliance(argv[1],AllCompliece,&image_info->border_color,
exception);
(void) SetImageOption(image_info,argv[0]+1,argv[1]);
break;
if (*argv[0] == '+')
{
(void) SetImageOption(image_info,argv[0]+1,argv[1]);
- (void) QueryColorCompliance(MatteColor,&image_info->matte_color,
- exception);
+ (void) QueryColorCompliance(MatteColor,AllComplience,
+ &image_info->matte_color,exception);
break;
}
(void) SetImageOption(image_info,argv[0]+1,argv[1]);
- (void) QueryColorCompliance(argv[1],&image_info->matte_color,
+ (void) QueryColorCompliance(argv[1],AllComplience,&image_info->matte_color,
exception);
break;
}
{
if (*argv[0] == '+')
{
- (void) QueryColorCompliance("none",&image_info->transparent_color, exception);
+ (void) QueryColorCompliance("none",AllComplience,
+ &image_info->transparent_color,exception);
(void) SetImageOption(image_info,argv[0]+1,"none");
break;
}
- (void) QueryColorCompliance(argv[1],&image_info->transparent_color,
+ (void) QueryColorCompliance("none",AllComplience,
+ &image_info->transparent_color,exception);
exception);
(void) SetImageOption(image_info,argv[0]+1,argv[1]);
break;
assert((*image)->signature == MagickSignature);
if ((*image)->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",(*image)->filename);
-
+ if (argc < 0)
+ return(MagickTrue);
draw_info=CloneDrawInfo(image_info,(DrawInfo *) NULL);
quantize_info=AcquireQuantizeInfo(image_info);
SetGeometryInfo(&geometry_info);
(void) SyncImageSettings(image_info,*image);
(void) ParseRegionGeometry(*image,argv[1],&geometry,exception);
new_image=AdaptiveResizeImage(*image,geometry.width,
- geometry.height,exception);
+ geometry.height,interpolate_method,exception);
break;
}
if (LocaleCompare("adaptive-sharpen",argv[0]+1) == 0)
flags=ParsePageGeometry(*image,argv[1],&geometry,exception);
if ((flags & SigmaValue) == 0)
geometry.height=geometry.width;
- new_image=BorderImage(*image,&geometry,exception);
+ new_image=BorderImage(*image,&geometry,compose,exception);
break;
}
if (LocaleCompare("bordercolor",argv[0]+1) == 0)
{
if (*argv[0] == '+')
{
- (void) QueryColorCompliance(BorderColor,&draw_info->border_color,
- exception);
+ (void) QueryColorCompliance(BorderColor,AllComplience,
+ &draw_info->border_color,exception);
break;
}
- (void) QueryColorCompliance(argv[1],&draw_info->border_color,
+ (void) QueryColorCompliance(argv[1],AllComplience,&draw_info->border_color,
exception);
break;
}
if (LocaleCompare("box",argv[0]+1) == 0)
{
- (void) QueryColorCompliance(argv[1],&draw_info->undercolor,
+ (void) QueryColorCompliance(argv[1],AllComplience,&draw_info->undercolor,
exception);
break;
}
}
mask_view=DestroyCacheView(mask_view);
mask_image->matte=MagickTrue;
- (void) SetImageClipMask(*image,mask_image);
+ (void) SetImageClipMask(*image,mask_image,exception);
mask_image=DestroyImage(mask_image);
InheritException(exception,&(*image)->exception);
break;
InheritException(exception,&(*image)->exception);
break;
}
+ if (LocaleCompare("compose",argv[0]+1) == 0)
+ {
+ (void) SyncImageSettings(image_info,*image);
+ compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions,
+ MagickFalse,argv[1]);
+ break;
+ }
if (LocaleCompare("contrast",argv[0]+1) == 0)
{
(void) SyncImageSettings(image_info,*image);
GetPixelInfo(*image,&fill);
if (*argv[0] == '+')
{
- (void) QueryMagickColorCompliance("none",&fill,exception);
- (void) QueryColorCompliance("none",&draw_info->fill,exception);
+ (void) QueryMagickColorCompliance("none",AllCompliance,&fill,
+ exception);
+ (void) QueryColorCompliance("none",AllComplience,&draw_info->fill,
+ exception);
if (draw_info->fill_pattern != (Image *) NULL)
draw_info->fill_pattern=DestroyImage(draw_info->fill_pattern);
break;
}
sans=AcquireExceptionInfo();
- (void) QueryMagickColorCompliance(argv[1],&fill,sans);
- status=QueryColorCompliance(argv[1],&draw_info->fill,sans);
+ (void) QueryMagickColorCompliance(argv[1],AllCompliance,&fill,sans);
+ status=QueryColorCompliance(argv[1],AllComplience,&draw_info->fill,sans);
sans=DestroyExceptionInfo(sans);
if (status == MagickFalse)
draw_info->fill_pattern=GetImageCache(image_info,argv[1],
*/
(void) SyncImageSettings(image_info,*image);
(void) ParsePageGeometry(*image,argv[1],&geometry,exception);
- (void) QueryMagickColorCompliance(argv[2],&target,exception);
+ (void) QueryMagickColorCompliance(argv[2],AllCompliance,&target,
+ exception);
(void) FloodfillPaintImage(*image,draw_info,&target,geometry.x,
geometry.y,*argv[0] == '-' ? MagickFalse : MagickTrue,exception);
break;
frame_info.y=(ssize_t) frame_info.height;
frame_info.width=(*image)->columns+2*frame_info.width;
frame_info.height=(*image)->rows+2*frame_info.height;
- new_image=FrameImage(*image,&frame_info,exception);
+ new_image=FrameImage(*image,&frame_info,compose,exception);
break;
}
if (LocaleCompare("function",argv[0]+1) == 0)
*/
(void) SyncImageSettings(image_info,*image);
(void) ParseGeometry(argv[1],&geometry_info);
- new_image=ImplodeImage(*image,geometry_info.rho,exception);
+ new_image=ImplodeImage(*image,geometry_info.rho,
+ interpolate_method,exception);
break;
}
if (LocaleCompare("interline-spacing",argv[0]+1) == 0)
draw_info->interline_spacing=geometry_info.rho;
break;
}
+ if (LocaleCompare("interpolate",argv[0]+1) == 0)
+ {
+ interpolate_method=(PixelInterpolateMethod) ParseCommandOption(
+ MagickInterpolateOptions,MagickFalse,argv[1]);
+ break;
+ }
if (LocaleCompare("interword-spacing",argv[0]+1) == 0)
{
if (*argv[0] == '+')
p=(const char *) argv[1];
GetMagickToken(p,&p,token); /* get black point color */
if ((isalpha((int) *token) != 0) || ((*token == '#') != 0))
- (void) QueryMagickColorCompliance(token,&black_point,exception);
+ (void) QueryMagickColorCompliance(token,AllCompliance,
+ &black_point,exception);
else
- (void) QueryMagickColorCompliance("#000000",&black_point,exception);
+ (void) QueryMagickColorCompliance("#000000",AllCompliance,
+ &black_point,exception);
if (isalpha((int) token[0]) || (token[0] == '#'))
GetMagickToken(p,&p,token);
if (*token == '\0')
if ((isalpha((int) *token) == 0) && ((*token == '#') == 0))
GetMagickToken(p,&p,token); /* Get white point color. */
if ((isalpha((int) *token) != 0) || ((*token == '#') != 0))
- (void) QueryMagickColorCompliance(token,&white_point,exception);
+ (void) QueryMagickColorCompliance(token,AllCompliance,
+ &white_point,exception);
else
- (void) QueryMagickColorCompliance("#ffffff",&white_point,exception);
+ (void) QueryMagickColorCompliance("#ffffff",AllCompliance,
+ &white_point,exception);
}
(void) LevelImageColors(*image,&black_point,&white_point,
*argv[0] == '+' ? MagickTrue : MagickFalse,exception);
target;
(void) SyncImageSettings(image_info,*image);
- (void) QueryMagickColorCompliance(argv[1],&target,exception);
+ (void) QueryMagickColorCompliance(argv[1],AllCompliance,&target,
+ exception);
(void) OpaquePaintImage(*image,&target,&fill,*argv[0] == '-' ?
MagickFalse : MagickTrue,exception);
break;
{
if (*argv[0] == '+')
{
- (void) QueryColorCompliance("none",&draw_info->fill,exception);
+ (void) QueryColorCompliance("none",AllComplience,&draw_info->fill,
+ exception);
break;
}
- (void) QueryColorCompliance(argv[1],&draw_info->fill,exception);
+ (void) QueryColorCompliance(argv[1],AllComplience,&draw_info->fill,
+ exception);
break;
}
if (LocaleCompare("pointsize",argv[0]+1) == 0)
char
*value;
- /*
- Set image argv[0].
- */
if (*argv[0] == '+')
{
if (LocaleNCompare(argv[1],"registry:",9) == 0)
(void) SetImageRegistry(StringRegistryType,argv[1]+9,value,
exception);
else
- if (LocaleNCompare(argv[1],"argv[0]:",7) == 0)
+ if (LocaleNCompare(argv[1],"option:",7) == 0)
{
- (void) SetImageOption(image_info,argv[1]+7,value);
(void) SetImageOption(image_info,argv[1]+7,value);
(void) SetImageArtifact(*image,argv[1]+7,value);
}
if (*argv[0] == '+')
{
- (void) QueryColorCompliance("none",&draw_info->stroke,exception);
+ (void) QueryColorCompliance("none",AllComplience,&draw_info->stroke,
+ exception);
if (draw_info->stroke_pattern != (Image *) NULL)
draw_info->stroke_pattern=DestroyImage(
draw_info->stroke_pattern);
break;
}
sans=AcquireExceptionInfo();
- status=QueryColorCompliance(argv[1],&draw_info->stroke,sans);
+ status=QueryColorCompliance(argv[1],AllComplience,&draw_info->stroke,sans);
sans=DestroyExceptionInfo(sans);
if (status == MagickFalse)
draw_info->stroke_pattern=GetImageCache(image_info,argv[1],
target;
(void) SyncImageSettings(image_info,*image);
- (void) QueryMagickColorCompliance(argv[1],&target,exception);
+ (void) QueryMagickColorCompliance(argv[1],AllCompliance,&target,
+ exception);
(void) TransparentPaintImage(*image,&target,(Quantum)
TransparentAlpha,*argv[0] == '-' ? MagickFalse : MagickTrue,
&(*image)->exception);
{
if (LocaleCompare("undercolor",argv[0]+1) == 0)
{
- (void) QueryColorCompliance(argv[1],&draw_info->undercolor,
+ (void) QueryColorCompliance(argv[1],AllComplience,&draw_info->undercolor,
exception);
break;
}
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
new_image=WaveImage(*image,geometry_info.rho,
- geometry_info.sigma,exception);
+ geometry_info.sigma,interpolate_method,exception);
break;
}
if (LocaleCompare("weight",argv[0]+1) == 0)
*/
quantize_info=DestroyQuantizeInfo(quantize_info);
draw_info=DestroyDrawInfo(draw_info);
- status=(*image)->exception.severity == UndefinedException ? 1 : 0;
-
- return(status);
+ status=(MagickStatusType) ((*image)->exception.severity ==
+ UndefinedException ? 1 : 0);
+ return(status == 0 ? MagickFalse : MagickTrue);
}
\f
/*
if ((*images)->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
(*images)->filename);
-
- quantize_info=AcquireQuantizeInfo(image_info);
- channel=image_info->channel;
-
+ if ((argc <= 0) || (*argv == (char *) NULL))
+ return(MagickTrue);
status=MagickTrue;
switch (*(argv[0]+1))
status=MagickFalse;
break;
}
- (void) ClutImageChannel(image,channel,clut_image);
+ (void) ClutImage(image,clut_image,interpolate_method,exception);
clut_image=DestroyImage(clut_image);
*images=DestroyImageList(*images);
*images=image;
}
quantize_info=DestroyQuantizeInfo(quantize_info);
+ status=(MagickStatusType) ((*image)->exception.severity ==
+ UndefinedException ? 1 : 0);
return(status != 0 ? MagickTrue : MagickFalse);
}
#endif
projects / imagemagick / commitdiff