2010-03-05 6.6.0-2 Cristy <quetzlzacatenango@image...>
- * add support for the -mip option (maximum intensity projection).
+ * add support for the -intensity-projection option that returns the
+ maximum (or minimum) intensity projection for a sequence of images.
2010-02-27 6.6.0-1 Cristy <quetzlzacatenango@image...>
* Check to see if ICON image width /height exceeds that of the image canvas.
# #
# #
# #
+# I n t e n s i t y P r o j e c t i o n #
+# #
+# #
+# #
+###############################################################################
+#
+#
+void
+IntensityProjection(ref)
+ Image::Magick ref=NO_INIT
+ ALIAS:
+ IntensityProjectionImage = 1
+ intensityprojection = 2
+ intensityprojectionimage = 3
+ PPCODE:
+ {
+ AV
+ *av;
+
+ char
+ *attribute,
+ *p;
+
+ ExceptionInfo
+ *exception;
+
+ HV
+ *hv;
+
+ Image
+ *image;
+
+ MagickBooleanType
+ projection;
+
+ register long
+ i;
+
+ struct PackageInfo
+ *info;
+
+ SV
+ *perl_exception,
+ *reference,
+ *rv,
+ *sv;
+
+ exception=AcquireExceptionInfo();
+ perl_exception=newSVpv("",0);
+ if (sv_isobject(ST(0)) == 0)
+ {
+ ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
+ PackageName);
+ goto PerlException;
+ }
+ reference=SvRV(ST(0));
+ hv=SvSTASH(reference);
+ image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
+ if (image == (Image *) NULL)
+ {
+ ThrowPerlException(exception,OptionError,"NoImagesDefined",
+ PackageName);
+ goto PerlException;
+ }
+ projection=MagickFalse;
+ for (i=2; i < items; i+=2)
+ {
+ attribute=(char *) SvPV(ST(i-1),na);
+ switch (*attribute)
+ {
+ case 'P':
+ case 'p':
+ {
+ if (LocaleCompare(attribute,"projection") == 0)
+ {
+ long
+ in;
+
+ in=!SvPOK(ST(i)) ? SvIV(ST(i)) : ParseMagickOption(
+ MagickBooleanOptions,MagickFalse,SvPV(ST(i),na));
+ if (in < 0)
+ {
+ ThrowPerlException(exception,OptionError,"UnrecognizedType",
+ SvPV(ST(i),na));
+ return;
+ }
+ projection=(MagickBooleanType) in;
+ break;
+ }
+ ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
+ attribute);
+ break;
+ }
+ default:
+ {
+ ThrowPerlException(exception,OptionError,"UnrecognizedAttribute",
+ attribute);
+ break;
+ }
+ }
+ }
+ image=IntensityProjectionImages(image,MagickFalse,exception);
+ if ((image == (Image *) NULL) || (exception->severity >= ErrorException))
+ goto PerlException;
+ /*
+ Create blessed Perl array for the returned image.
+ */
+ av=newAV();
+ ST(0)=sv_2mortal(sv_bless(newRV((SV *) av),hv));
+ SvREFCNT_dec(av);
+ AddImageToRegistry(image);
+ rv=newRV(sv);
+ av_push(av,sv_bless(rv,hv));
+ SvREFCNT_dec(sv);
+ info=GetPackageInfo(aTHX_ (void *) av,info,exception);
+ (void) FormatMagickString(info->image_info->filename,MaxTextExtent,
+ "mip-%.*s",(int) (MaxTextExtent-9),
+ ((p=strrchr(image->filename,'/')) ? p+1 : image->filename));
+ (void) CopyMagickString(image->filename,info->image_info->filename,
+ MaxTextExtent);
+ SetImageInfo(info->image_info,0,exception);
+ exception=DestroyExceptionInfo(exception);
+ SvREFCNT_dec(perl_exception);
+ XSRETURN(1);
+
+ PerlException:
+ InheritPerlException(exception,perl_exception);
+ exception=DestroyExceptionInfo(exception);
+ sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
+ SvPOK_on(perl_exception);
+ ST(0)=sv_2mortal(perl_exception);
+ XSRETURN(1);
+ }
+\f
+#
+###############################################################################
+# #
+# #
+# #
# L a y e r s #
# #
# #
# #
# #
# #
-# M a x i m u m I n t e n s i t y P r o j e c t i o n #
-# #
-# #
-# #
-###############################################################################
-#
-#
-void
-MaximumIntensityProjection(ref)
- Image::Magick ref=NO_INIT
- ALIAS:
- MaximumIntensityProjectionImage = 1
- maximumintensityprojection = 2
- maximumintensityprojectionimage = 3
- PPCODE:
- {
- AV
- *av;
-
- char
- *p;
-
- ExceptionInfo
- *exception;
-
- HV
- *hv;
-
- Image
- *image;
-
- struct PackageInfo
- *info;
-
- SV
- *perl_exception,
- *reference,
- *rv,
- *sv;
-
- exception=AcquireExceptionInfo();
- perl_exception=newSVpv("",0);
- if (sv_isobject(ST(0)) == 0)
- {
- ThrowPerlException(exception,OptionError,"ReferenceIsNotMyType",
- PackageName);
- goto PerlException;
- }
- reference=SvRV(ST(0));
- hv=SvSTASH(reference);
- image=SetupList(aTHX_ reference,&info,(SV ***) NULL,exception);
- if (image == (Image *) NULL)
- {
- ThrowPerlException(exception,OptionError,"NoImagesDefined",
- PackageName);
- goto PerlException;
- }
- image=MaximumIntensityProjectionImages(image,exception);
- if ((image == (Image *) NULL) || (exception->severity >= ErrorException))
- goto PerlException;
- /*
- Create blessed Perl array for the returned image.
- */
- av=newAV();
- ST(0)=sv_2mortal(sv_bless(newRV((SV *) av),hv));
- SvREFCNT_dec(av);
- AddImageToRegistry(image);
- rv=newRV(sv);
- av_push(av,sv_bless(rv,hv));
- SvREFCNT_dec(sv);
- info=GetPackageInfo(aTHX_ (void *) av,info,exception);
- (void) FormatMagickString(info->image_info->filename,MaxTextExtent,
- "mip-%.*s",(int) (MaxTextExtent-9),
- ((p=strrchr(image->filename,'/')) ? p+1 : image->filename));
- (void) CopyMagickString(image->filename,info->image_info->filename,
- MaxTextExtent);
- SetImageInfo(info->image_info,0,exception);
- exception=DestroyExceptionInfo(exception);
- SvREFCNT_dec(perl_exception);
- XSRETURN(1);
-
- PerlException:
- InheritPerlException(exception,perl_exception);
- exception=DestroyExceptionInfo(exception);
- sv_setiv(perl_exception,(IV) SvCUR(perl_exception) != 0);
- SvPOK_on(perl_exception);
- ST(0)=sv_2mortal(perl_exception);
- XSRETURN(1);
- }
-\f
-#
-###############################################################################
-# #
-# #
-# #
# M o g r i f y #
# #
# #
#include "magick/monitor.h"
#include "magick/monitor-private.h"
#include "magick/montage.h"
+#include "magick/morphology.h"
#include "magick/paint.h"
#include "magick/pixel-private.h"
#include "magick/property.h"
*filter_view,
*image_view;
+ KernelInfo
+ *normal_kernel;
+
Image
*filter_image;
}
message=DestroyString(message);
}
- status=AccelerateConvolveImage(image,kernel,filter_image,exception);
+ normal_kernel=CloneKernelInfo(kernel);
+ if (normal_kernel == (KernelInfo *) NULL)
+ {
+ filter_image=DestroyImage(filter_image);
+ ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
+ }
+ ScaleKernelInfo(normal_kernel,1.0,NormalizeValue);
+ status=AccelerateConvolveImage(image,normal_kernel,filter_image,exception);
if (status == MagickTrue)
return(filter_image);
/*
if (status == MagickFalse)
continue;
- p=GetCacheViewVirtualPixels(image_view,-((long) kernel->width/2L),
- y-(long) (kernel->height/2L),image->columns+kernel->width,kernel->height,
- exception);
+ p=GetCacheViewVirtualPixels(image_view,-((long) normal_kernel->width/2L),
+ y-(long) (normal_kernel->height/2L),image->columns+normal_kernel->width,
+ normal_kernel->height,exception);
q=GetCacheViewAuthenticPixels(filter_view,0,y,filter_image->columns,1,
exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
u;
pixel=bias;
- k=kernel->values;
+ k=normal_kernel->values;
kernel_pixels=p;
if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
{
- for (v=0; v < (long) kernel->width; v++)
+ for (v=0; v < (long) normal_kernel->width; v++)
{
- for (u=0; u < (long) kernel->height; u++)
+ for (u=0; u < (long) normal_kernel->height; u++)
{
pixel.red+=(*k)*kernel_pixels[u].red;
pixel.green+=(*k)*kernel_pixels[u].green;
pixel.blue+=(*k)*kernel_pixels[u].blue;
k++;
}
- kernel_pixels+=image->columns+kernel->width;
+ kernel_pixels+=image->columns+normal_kernel->width;
}
if ((channel & RedChannel) != 0)
SetRedPixelComponent(q,ClampRedPixelComponent(&pixel));
SetBluePixelComponent(q,ClampBluePixelComponent(&pixel));
if ((channel & OpacityChannel) != 0)
{
- k=kernel->values;
+ k=normal_kernel->values;
kernel_pixels=p;
- for (v=0; v < (long) kernel->width; v++)
+ for (v=0; v < (long) normal_kernel->width; v++)
{
- for (u=0; u < (long) kernel->height; u++)
+ for (u=0; u < (long) normal_kernel->height; u++)
{
pixel.opacity+=(*k)*kernel_pixels[u].opacity;
k++;
}
- kernel_pixels+=image->columns+kernel->width;
+ kernel_pixels+=image->columns+normal_kernel->width;
}
SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
}
register const IndexPacket
*restrict kernel_indexes;
- k=kernel->values;
+ k=normal_kernel->values;
kernel_indexes=indexes;
- for (v=0; v < (long) kernel->width; v++)
+ for (v=0; v < (long) normal_kernel->width; v++)
{
- for (u=0; u < (long) kernel->height; u++)
+ for (u=0; u < (long) normal_kernel->height; u++)
{
pixel.index+=(*k)*kernel_indexes[u];
k++;
}
- kernel_indexes+=image->columns+kernel->width;
+ kernel_indexes+=image->columns+normal_kernel->width;
}
filter_indexes[x]=ClampToQuantum(pixel.index);
}
gamma;
gamma=0.0;
- for (v=0; v < (long) kernel->width; v++)
+ for (v=0; v < (long) normal_kernel->width; v++)
{
- for (u=0; u < (long) kernel->height; u++)
+ for (u=0; u < (long) normal_kernel->height; u++)
{
alpha=(MagickRealType) (QuantumScale*(QuantumRange-
kernel_pixels[u].opacity));
gamma+=(*k)*alpha;
k++;
}
- kernel_pixels+=image->columns+kernel->width;
+ kernel_pixels+=image->columns+normal_kernel->width;
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
q->blue=ClampToQuantum(gamma*GetBluePixelComponent(&pixel));
if ((channel & OpacityChannel) != 0)
{
- k=kernel->values;
+ k=normal_kernel->values;
kernel_pixels=p;
- for (v=0; v < (long) kernel->width; v++)
+ for (v=0; v < (long) normal_kernel->width; v++)
{
- for (u=0; u < (long) kernel->height; u++)
+ for (u=0; u < (long) normal_kernel->height; u++)
{
pixel.opacity+=(*k)*kernel_pixels[u].opacity;
k++;
}
- kernel_pixels+=image->columns+kernel->width;
+ kernel_pixels+=image->columns+normal_kernel->width;
}
SetOpacityPixelComponent(q,ClampOpacityPixelComponent(&pixel));
}
register const IndexPacket
*restrict kernel_indexes;
- k=kernel->values;
+ k=normal_kernel->values;
kernel_pixels=p;
kernel_indexes=indexes;
- for (v=0; v < (long) kernel->width; v++)
+ for (v=0; v < (long) normal_kernel->width; v++)
{
- for (u=0; u < (long) kernel->height; u++)
+ for (u=0; u < (long) normal_kernel->height; u++)
{
alpha=(MagickRealType) (QuantumScale*(QuantumRange-
kernel_pixels[u].opacity));
pixel.index+=(*k)*alpha*kernel_indexes[u];
k++;
}
- kernel_pixels+=image->columns+kernel->width;
- kernel_indexes+=image->columns+kernel->width;
+ kernel_pixels+=image->columns+normal_kernel->width;
+ kernel_indexes+=image->columns+normal_kernel->width;
}
filter_indexes[x]=ClampToQuantum(gamma*
GetIndexPixelComponent(&pixel));
filter_image->type=image->type;
filter_view=DestroyCacheView(filter_view);
image_view=DestroyCacheView(image_view);
+ normal_kernel=DestroyKernelInfo(normal_kernel);
if (status == MagickFalse)
filter_image=DestroyImage(filter_image);
return(filter_image);
% %
% %
% %
-+ C l o n e K e r n e l I n f o %
+% C l o n e K e r n e l I n f o %
% %
% %
% %
% o kernel: the Morphology/Convolution kernel to be cloned
%
*/
-
-static KernelInfo *CloneKernelInfo(const KernelInfo *kernel)
+MagickBooleanType KernelInfo *CloneKernelInfo(const KernelInfo *kernel)
{
register long
i;
% %
% %
% %
-+ S c a l e K e r n e l I n f o %
+% S c a l e K e r n e l I n f o %
% %
% %
% %
% This function is internal to this module only at this time, but can be
% exported to other modules if needed.
*/
-static void ScaleKernelInfo(KernelInfo *kernel, const double scaling_factor,
- const GeometryFlags normalize_flags)
+MagickExport void ScaleKernelInfo(KernelInfo *kernel,
+ const double scaling_factor,const GeometryFlags normalize_flags)
{
register long
i;
extern MagickExport KernelInfo
*AcquireKernelInfo(const char *),
*AcquireKernelBuiltIn(const KernelInfoType,const GeometryInfo *),
+ *CloneKernelInfo(const KernelInfo *),
*DestroyKernelInfo(KernelInfo *);
-extern MagickExport void
- ShowKernelInfo(KernelInfo *);
-
extern MagickExport Image
*MorphologyImage(const Image *,const MorphologyMethod,const long,
const KernelInfo *,ExceptionInfo *),
*MorphologyImageChannel(const Image *,const ChannelType,
- const MorphologyMethod,const long,const KernelInfo *,ExceptionInfo *);
+ const MorphologyMethod,const long,const KernelInfo *,ExceptionInfo *);
+
+extern MagickExport void
+ ScaleKernelInfo(KernelInfo *,const double,const GeometryFlags),
+ ShowKernelInfo(KernelInfo *);
#if defined(__cplusplus) || defined(c_plusplus)
}
% %
% %
% %
-% M a x i m u m I n t e n s i t y P r o j e c t i o n I m a g e s %
+% I n t e n s i t y P r o j e c t i o n I m a g e s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MaximumIntensityProjectionImages() returns the maximum intensity projection
-% of an image sequence.
+% IntensityProjectionImages() returns the maximum (or minimum) intensity
+% projection of an image sequence.
%
-% The format of the MaximumIntensityProjectionImages method is:
+% The format of the IntensityProjectionImages method is:
%
-% Image *MaximumIntensityProjectionImages(Image *images,
-% ExceptionInfo *exception)
+% Image *IntensityProjectionImages(Image *images,
+% const MagickBooleanType projection,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o images: the image sequence.
%
+% o projection: compute the minimum intensity projection for a value
+% other than 0, otherwise compute the maximum.
+%
% o exception: return any errors or warnings in this structure.
%
*/
-MagickExport Image *MaximumIntensityProjectionImages(const Image *images,
- ExceptionInfo *exception)
+MagickExport Image *IntensityProjectionImages(const Image *images,
+ const MagickBooleanType projection,ExceptionInfo *exception)
{
-#define MaximumIntensityProjectionImageTag "MaximumIntensityProjection/Image"
+#define MIPImageTag "MIP/Image"
const Image
*next;
Image
- *mip_image;
+ *projection_image;
MagickBooleanType
status;
return((Image *) NULL);
}
/*
- Initialize mip_image next attributes.
+ Initialize projection_image next attributes.
*/
- mip_image=CloneImage(images,0,0,MagickTrue,exception);
- if (mip_image == (Image *) NULL)
+ projection_image=CloneImage(images,0,0,MagickTrue,exception);
+ if (projection_image == (Image *) NULL)
return((Image *) NULL);
- if (SetImageStorageClass(mip_image,DirectClass) == MagickFalse)
+ if (SetImageStorageClass(projection_image,DirectClass) == MagickFalse)
{
- InheritException(exception,&mip_image->exception);
- mip_image=DestroyImage(mip_image);
+ InheritException(exception,&projection_image->exception);
+ projection_image=DestroyImage(projection_image);
return((Image *) NULL);
}
/*
- Compute the maximum intensity projection.
+ Compute the maximum (or minimim) intensity projection.
*/
i=0;
number_images=GetImageListLength(images);
for (next=images; next != (Image *) NULL; next=GetNextImageInList(next))
{
- status=CompositeImage(mip_image,LightenCompositeOp,next,0,0);
+ status=CompositeImage(projection_image,projection != MagickFalse ?
+ DarkenCompositeOp : LightenCompositeOp,next,0,0);
if (status == MagickFalse)
{
- InheritException(exception,&mip_image->exception);
- mip_image=DestroyImage(mip_image);
+ InheritException(exception,&projection_image->exception);
+ projection_image=DestroyImage(projection_image);
break;
}
if (images->progress_monitor != (MagickProgressMonitor) NULL)
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_MaximumIntensityProjectionImages)
+ #pragma omp critical (MagickCore_IntensityProjectionImages)
#endif
- proceed=SetImageProgress(images,MaximumIntensityProjectionImageTag,i++,
+ proceed=SetImageProgress(images,MIPImageTag,i++,
number_images);
}
}
- return(mip_image);
+ return(projection_image);
}
extern MagickExport Image
*AverageImages(const Image *,ExceptionInfo *),
- *MaximumIntensityProjectionImages(const Image *,ExceptionInfo *);
+ *IntensityProjectionImages(const Image *,const MagickBooleanType,
+ ExceptionInfo *);
extern MagickExport MagickBooleanType
GetImageChannelExtrema(const Image *,const ChannelType,unsigned long *,
"-flatten flatten a sequence of images",
"-fx expression apply mathematical expression to an image channel(s)",
"-hald-clut apply a Hald color lookup table to the image",
- "-mip return the maximum intensity projection for an image sequence",
+ "-intensity-projection",
+ " the maximum (or minimum) intensity projection",
"-morph value morph an image sequence",
"-mosaic create a mosaic from an image sequence",
"-process arguments process the image with a custom image filter",
ThrowConvertInvalidArgumentException(option,argv[i]);
break;
}
+ if (LocaleCompare("intensity-projection",option+1) == 0)
+ break;
if (LocaleCompare("intent",option+1) == 0)
{
long
ThrowConvertException(OptionError,"MissingArgument",option);
break;
}
- if (LocaleCompare("mip",option+1) == 0)
- break;
if (LocaleCompare("median",option+1) == 0)
{
if (*option == '+')
% %
% %
% %
-% M a g i c k M a x i m u m I n t e n s i t y P r o j e c t i o n I m a g e %
+% M a g i c k I n t e n s i t y P r o j e c t i o n I m a g e s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MagickMaximumIntensityProjectionImages() returns the maximum intensity
+% MagickIntensityProjectionImages() returns the maximum (or minimum) intensity
% projection of an image sequence.
%
-% The format of the MagickMaximumIntensityProjectionImages method is:
+% The format of the MagickIntensityProjectionImages method is:
%
-% MagickWand *MagickMaximumIntensityProjectionImages(MagickWand *wand)
+% MagickWand *MagickIntensityProjectionImages(MagickWand *wand,
+% const MagickBooleanType projection)
%
% A description of each parameter follows:
%
% o wand: the magick wand.
%
+% o projection: compute the minimum intensity projection for a value
+% other than 0, otherwise compute the maximum.
+%
*/
-WandExport MagickWand *MagickMaximumIntensityProjectionImages(MagickWand *wand)
+WandExport MagickWand *MagickIntensityProjectionImages(MagickWand *wand,
+ const MagickBooleanType projection)
{
Image
- *mip_image;
+ *projection_image;
assert(wand != (MagickWand *) NULL);
assert(wand->signature == WandSignature);
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
return((MagickWand *) NULL);
- mip_image=MaximumIntensityProjectionImages(wand->images,wand->exception);
- if (mip_image == (Image *) NULL)
+ projection_image=IntensityProjectionImages(wand->images,projection,
+ wand->exception);
+ if (projection_image == (Image *) NULL)
return((MagickWand *) NULL);
- return(CloneMagickWandFromImages(wand,mip_image));
+ return(CloneMagickWandFromImages(wand,projection_image));
}
\f
/*
*MagickGetImageClipMask(MagickWand *),
*MagickGetImageRegion(MagickWand *,const unsigned long,const unsigned long,
const long,const long),
- *MagickMaximumIntensityProjectionImages(MagickWand *),
+ *MagickIntensityProjectionImages(MagickWand *,const MagickBooleanType),
*MagickMergeImageLayers(MagickWand *,const ImageLayerMethod),
*MagickMorphImages(MagickWand *,const unsigned long),
*MagickMontageImage(MagickWand *,const DrawingWand *,const char *,
kernel=AcquireKernelInfo(argv[i+1]);
if (kernel == (KernelInfo *) NULL)
break;
- convolve_image=ConvoleImageChannel(*image,channel,kernel,exception);
+ convolve_image=FilterImageChannel(*image,channel,kernel,exception);
kernel=DestroyKernelInfo(kernel);
if (convolve_image == (Image *) NULL)
break;
"-flatten flatten a sequence of images",
"-fx expression apply mathematical expression to an image channel(s)",
"-hald-clut apply a Hald color lookup table to the image",
- "-mip return the maximum intensity projection for an image sequence",
+ "-intensity-projection",
+ " the maximum (or minimum) intensity projection",
"-morph value morph an image sequence",
"-mosaic create a mosaic from an image sequence",
"-process arguments process the image with a custom image filter",
ThrowMogrifyInvalidArgumentException(option,argv[i]);
break;
}
+ if (LocaleCompare("intensity-projection",option+1) == 0)
+ break;
if (LocaleCompare("intent",option+1) == 0)
{
long
ThrowMogrifyException(OptionError,"MissingArgument",option);
break;
}
- if (LocaleCompare("mip",option+1) == 0)
- break;
if (LocaleCompare("modulate",option+1) == 0)
{
if (*option == '+')
*images=GetFirstImageInList(q);
break;
}
+ if (LocaleCompare("intensity-projection",option+1) == 0)
+ {
+ Image
+ *projection_image;
+
+ (void) SyncImagesSettings(image_info,*images);
+ projection_image=IntensityProjectionImages(*images,*option == '+' ?
+ MagickTrue : MagickFalse,exception);
+ if (projection_image == (Image *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ *images=DestroyImageList(*images);
+ *images=projection_image;
+ break;
+ }
break;
}
case 'l':
i++;
break;
}
- if (LocaleCompare("mip",option+1) == 0)
- {
- Image
- *morph_image;
-
- (void) SyncImagesSettings(image_info,*images);
- morph_image=MorphImages(*images,StringToUnsignedLong(argv[i+1]),
- exception);
- if (morph_image == (Image *) NULL)
- {
- status=MagickFalse;
- break;
- }
- *images=DestroyImageList(*images);
- *images=morph_image;
- break;
- }
if (LocaleCompare("morph",option+1) == 0)
{
Image
projects / imagemagick / commitdiff