ExceptionInfo exceptionInfo;
GetExceptionInfo( &exceptionInfo );
MagickCore::Image* newImage =
- ImplodeImage( image(), factor_, &exceptionInfo );
+ ImplodeImage( image(), factor_, image()->interpolate, &exceptionInfo );
replaceImage( newImage );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
ExceptionInfo exceptionInfo;
GetExceptionInfo( &exceptionInfo );
MagickCore::Image* newImage =
- SwirlImage( image(), degrees_,
+ SwirlImage( image(), degrees_, image()->interpolate,
&exceptionInfo);
replaceImage( newImage );
throwException( exceptionInfo );
XSetCursorState(display,windows,MagickTrue);
XCheckRefreshWindows(display,windows);
flags=ParseGeometry(degrees,&geometry_info);
- swirl_image=SwirlImage(*image,geometry_info.rho,exception);
+ swirl_image=SwirlImage(*image,geometry_info.rho,(*image)->interpolate,
+ exception);
if (swirl_image != (Image *) NULL)
{
*image=DestroyImage(*image);
XSetCursorState(display,windows,MagickTrue);
XCheckRefreshWindows(display,windows);
flags=ParseGeometry(factor,&geometry_info);
- implode_image=ImplodeImage(*image,geometry_info.rho,exception);
+ implode_image=ImplodeImage(*image,geometry_info.rho,(*image)->interpolate,
+ exception);
if (implode_image != (Image *) NULL)
{
*image=DestroyImage(*image);
}
case SwirlPreview:
{
- preview_image=SwirlImage(thumbnail,degrees,exception);
+ preview_image=SwirlImage(thumbnail,degrees,image->interpolate,
+ exception);
(void) FormatLocaleString(label,MaxTextExtent,"swirl %g",degrees);
degrees+=45.0;
break;
case ImplodePreview:
{
degrees+=0.1f;
- preview_image=ImplodeImage(thumbnail,degrees,exception);
+ preview_image=ImplodeImage(thumbnail,degrees,image->interpolate,
+ exception);
(void) FormatLocaleString(label,MaxTextExtent,"implode %g",degrees);
break;
}
% The format of the ImplodeImage method is:
%
% Image *ImplodeImage(const Image *image,const double amount,
-% ExceptionInfo *exception)
+% const PixelInterpolateMethod method,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o amount: Define the extent of the implosion.
%
+% o method: the pixel interpolation method.
+%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *ImplodeImage(const Image *image,const double amount,
- ExceptionInfo *exception)
+ const PixelInterpolateMethod method,ExceptionInfo *exception)
{
#define ImplodeImageTag "Implode/Image"
MagickOffsetType
progress;
- PixelInfo
- zero;
-
MagickRealType
radius;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- implode_image=CloneImage(image,0,0,MagickTrue,exception);
+ implode_image=CloneImage(image,image->columns,image->rows,MagickTrue,
+ exception);
if (implode_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(implode_image,DirectClass,exception) == MagickFalse)
*/
status=MagickTrue;
progress=0;
- GetPixelInfo(implode_image,&zero);
image_view=AcquireCacheView(image);
implode_view=AcquireCacheView(implode_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
- PixelInfo
- pixel;
-
MagickRealType
distance;
continue;
}
delta.y=scale.y*(double) (y-center.y);
- pixel=zero;
for (x=0; x < (ssize_t) image->columns; x++)
{
/*
if (distance > 0.0)
factor=pow(sin((double) (MagickPI*sqrt((double) distance)/
radius/2)),-amount);
- (void) InterpolatePixelInfo(image,image_view,
- UndefinedInterpolatePixel,(double) (factor*delta.x/scale.x+
- center.x),(double) (factor*delta.y/scale.y+center.y),&pixel,
- exception);
- SetPixelPixelInfo(implode_image,&pixel,q);
+ status=InterpolatePixelChannels(image,image_view,implode_image,method,
+ (double) (factor*delta.x/scale.x+center.x),(double) (factor*delta.y/
+ scale.y+center.y),q,exception);
}
q+=GetPixelChannels(implode_image);
}
MagickBooleanType
status;
- PixelInfo
- zero;
-
RandomInfo
**restrict random_info;
if (random_image == (Image *) NULL)
return((Image *) NULL);
status=MagickTrue;
- GetPixelInfo(random_image,&zero);
random_info=AcquireRandomInfoThreadSet();
random_view=AcquireCacheView(random_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
const int
id = GetOpenMPThreadId();
- PixelInfo
- pixel;
-
register ssize_t
x;
status=MagickFalse;
continue;
}
- pixel=zero;
for (x=0; x < (ssize_t) random_image->columns; x++)
{
- pixel.red=(MagickRealType) (QuantumRange*
- GetPseudoRandomValue(random_info[id]));
- pixel.green=pixel.red;
- pixel.blue=pixel.red;
- if (image->colorspace == CMYKColorspace)
- pixel.black=pixel.red;
- SetPixelPixelInfo(random_image,&pixel,q);
+ MagickRealType
+ value;
+
+ register ssize_t
+ i;
+
+ value=GetPseudoRandomValue(random_info[id]);
+ for (i=0; i < (ssize_t) GetPixelChannels(random_image); i++)
+ {
+ PixelTrait
+ traits;
+
+ traits=GetPixelChannelMapTraits(random_image,(PixelChannel) i);
+ if (traits == UndefinedPixelTrait)
+ continue;
+ q[i]=ClampToQuantum(QuantumRange*value);
+ }
q+=GetPixelChannels(random_image);
}
if (SyncCacheViewAuthenticPixels(random_view,exception) == MagickFalse)
}
for (x=0; x < (ssize_t) image->columns; x++)
{
- if ((MagickRealType) GetPixelRed(image,q) > threshold)
- SetPixelRed(image,QuantumRange-GetPixelRed(image,q),q);
- if ((MagickRealType) GetPixelGreen(image,q) > threshold)
- SetPixelGreen(image,QuantumRange-GetPixelGreen(image,q),q);
- if ((MagickRealType) GetPixelBlue(image,q) > threshold)
- SetPixelBlue(image,QuantumRange-GetPixelBlue(image,q),q);
+ register ssize_t
+ i;
+
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelTrait
+ traits;
+
+ traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+ if ((traits == UndefinedPixelTrait) ||
+ ((traits & CopyPixelTrait) != 0))
+ continue;
+ if ((MagickRealType) q[i] > threshold)
+ q[i]=QuantumRange-q[i];
+ }
q+=GetPixelChannels(image);
}
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
exception);
q=GetVirtualPixels(right_image,0,y,right_image->columns,1,exception);
r=QueueAuthenticPixels(stereo_image,0,y,stereo_image->columns,1,exception);
- if ((p == (const Quantum *) NULL) ||
- (q == (Quantum *) NULL) || (r == (Quantum *) NULL))
+ if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL) ||
+ (r == (Quantum *) NULL))
break;
for (x=0; x < (ssize_t) stereo_image->columns; x++)
{
SetPixelRed(image,GetPixelRed(left_image,p),r);
- SetPixelGreen(image,GetPixelGreen(left_image,q),r);
- SetPixelBlue(image,GetPixelBlue(left_image,q),r);
- SetPixelAlpha(image,(GetPixelAlpha(left_image,p)+
- GetPixelAlpha(left_image,q))/2,r);
+ SetPixelGreen(image,GetPixelGreen(right_image,q),r);
+ SetPixelBlue(image,GetPixelBlue(right_image,q),r);
+ if ((GetPixelAlphaTraits(stereo_image) & CopyPixelTrait) != 0)
+ SetPixelAlpha(image,(GetPixelAlpha(left_image,p)+
+ GetPixelAlpha(right_image,q))/2,r);
p+=GetPixelChannels(left_image);
- q++;
- r++;
+ q+=GetPixelChannels(right_image);
+ r+=GetPixelChannels(stereo_image);
}
if (SyncAuthenticPixels(stereo_image,exception) == MagickFalse)
break;
% The format of the SwirlImage method is:
%
% Image *SwirlImage(const Image *image,double degrees,
-% ExceptionInfo *exception)
+% const PixelInterpolateMethod method,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o degrees: Define the tightness of the swirling effect.
%
+% o method: the pixel interpolation method.
+%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *SwirlImage(const Image *image,double degrees,
- ExceptionInfo *exception)
+ const PixelInterpolateMethod method,ExceptionInfo *exception)
{
#define SwirlImageTag "Swirl/Image"
MagickOffsetType
progress;
- PixelInfo
- zero;
-
MagickRealType
radius;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- swirl_image=CloneImage(image,0,0,MagickTrue,exception);
+ swirl_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
if (swirl_image == (Image *) NULL)
return((Image *) NULL);
if (SetImageStorageClass(swirl_image,DirectClass,exception) == MagickFalse)
*/
status=MagickTrue;
progress=0;
- GetPixelInfo(swirl_image,&zero);
image_view=AcquireCacheView(image);
swirl_view=AcquireCacheView(swirl_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
- PixelInfo
- pixel;
-
MagickRealType
distance;
continue;
}
delta.y=scale.y*(double) (y-center.y);
- pixel=zero;
for (x=0; x < (ssize_t) image->columns; x++)
{
/*
factor=1.0-sqrt((double) distance)/radius;
sine=sin((double) (degrees*factor*factor));
cosine=cos((double) (degrees*factor*factor));
- (void) InterpolatePixelInfo(image,image_view,
- UndefinedInterpolatePixel,(double) ((cosine*delta.x-sine*delta.y)/
- scale.x+center.x),(double) ((sine*delta.x+cosine*delta.y)/scale.y+
- center.y),&pixel,exception);
- SetPixelPixelInfo(swirl_image,&pixel,q);
+ status=InterpolatePixelChannels(image,image_view,swirl_image,method,
+ ((cosine*delta.x-sine*delta.y)/scale.x+center.x),(double)
+ ((sine*delta.x+cosine*delta.y)/scale.y+center.y),q,exception);
}
q+=GetPixelChannels(swirl_image);
}
GetPixelInfo(image,&pixel);
flags=ParseGeometry(opacity,&geometry_info);
pixel.red=geometry_info.rho;
+ pixel.green=geometry_info.rho;
+ pixel.blue=geometry_info.rho;
+ pixel.black=geometry_info.rho;
+ pixel.alpha=OpaqueAlpha;
if ((flags & SigmaValue) != 0)
pixel.green=geometry_info.sigma;
- else
- pixel.green=pixel.red;
if ((flags & XiValue) != 0)
pixel.blue=geometry_info.xi;
+ if (image->colorspace == CMYKColorspace)
+ {
+ if ((flags & PsiValue) != 0)
+ pixel.black=geometry_info.psi;
+ if ((flags & ChiValue) != 0)
+ pixel.alpha=geometry_info.chi;
+ }
else
- pixel.blue=pixel.red;
- if ((flags & PsiValue) != 0)
- pixel.alpha=geometry_info.psi;
- else
- pixel.alpha=(MagickRealType) OpaqueAlpha;
+ if ((flags & PsiValue) != 0)
+ pixel.alpha=geometry_info.psi;
intensity=(MagickRealType) GetPixelInfoIntensity(tint);
color_vector.red=(MagickRealType) (pixel.red*tint->red/100.0-intensity);
color_vector.green=(MagickRealType) (pixel.green*tint->green/100.0-intensity);
MagickRealType
weight;
- if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
+ if ((GetPixelRedTraits(tint_image) & UpdatePixelTrait) != 0)
{
weight=QuantumScale*GetPixelRed(image,p)-0.5;
pixel.red=(MagickRealType) GetPixelRed(image,p)+
color_vector.red*(1.0-(4.0*(weight*weight)));
SetPixelRed(tint_image,ClampToQuantum(pixel.red),q);
}
- if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
+ if ((GetPixelGreenTraits(tint_image) & UpdatePixelTrait) != 0)
{
weight=QuantumScale*GetPixelGreen(image,p)-0.5;
pixel.green=(MagickRealType) GetPixelGreen(image,p)+
color_vector.green*(1.0-(4.0*(weight*weight)));
SetPixelGreen(tint_image,ClampToQuantum(pixel.green),q);
}
- if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
+ if ((GetPixelBlueTraits(tint_image) & UpdatePixelTrait) != 0)
{
weight=QuantumScale*GetPixelBlue(image,p)-0.5;
pixel.blue=(MagickRealType) GetPixelBlue(image,p)+
color_vector.blue*(1.0-(4.0*(weight*weight)));
SetPixelBlue(tint_image,ClampToQuantum(pixel.blue),q);
}
- if ((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0)
+ if ((GetPixelBlackTraits(tint_image) & UpdatePixelTrait) != 0)
{
weight=QuantumScale*GetPixelBlack(image,p)-0.5;
pixel.black=(MagickRealType) GetPixelBlack(image,p)+
color_vector.black*(1.0-(4.0*(weight*weight)));
SetPixelBlack(tint_image,ClampToQuantum(pixel.black),q);
}
- if ((GetPixelAlphaTraits(image) & CopyPixelTrait) != 0)
+ if ((GetPixelAlphaTraits(tint_image) & CopyPixelTrait) != 0)
SetPixelAlpha(tint_image,GetPixelAlpha(image,p),q);
p+=GetPixelChannels(image);
q+=GetPixelChannels(tint_image);
*ColorizeImage(const Image *,const char *,const PixelPacket,ExceptionInfo *),
*ColorMatrixImage(const Image *,const KernelInfo *kernel,ExceptionInfo *),
*FxImage(const Image *,const char *,ExceptionInfo *),
- *ImplodeImage(const Image *,const double,ExceptionInfo *),
+ *ImplodeImage(const Image *,const double,const PixelInterpolateMethod,
+ ExceptionInfo *),
*MorphImages(const Image *,const size_t,ExceptionInfo *),
*PolaroidImage(const Image *,const DrawInfo *,const double,
const PixelInterpolateMethod,ExceptionInfo *),
*StereoImage(const Image *,const Image *,ExceptionInfo *),
*StereoAnaglyphImage(const Image *,const Image *,const ssize_t,const ssize_t,
ExceptionInfo *),
- *SwirlImage(const Image *,double,ExceptionInfo *),
+ *SwirlImage(const Image *,double,const PixelInterpolateMethod,
+ ExceptionInfo *),
*TintImage(const Image *,const char *,const PixelInfo *,ExceptionInfo *),
*VignetteImage(const Image *,const double,const double,const ssize_t,
const ssize_t,ExceptionInfo *),
% The format of the MagickImplodeImage method is:
%
% MagickBooleanType MagickImplodeImage(MagickWand *wand,
-% const double radius)
+% const double radius,const PixelInterpolateMethod method)
%
% A description of each parameter follows:
%
%
% o amount: Define the extent of the implosion.
%
+% o method: the pixel interpolation method.
+%
*/
WandExport MagickBooleanType MagickImplodeImage(MagickWand *wand,
- const double amount)
+ const double amount,const PixelInterpolateMethod method)
{
Image
*implode_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- implode_image=ImplodeImage(wand->images,amount,wand->exception);
+ implode_image=ImplodeImage(wand->images,amount,method,wand->exception);
if (implode_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,implode_image);
%
% The format of the MagickSwirlImage method is:
%
-% MagickBooleanType MagickSwirlImage(MagickWand *wand,const double degrees)
+% MagickBooleanType MagickSwirlImage(MagickWand *wand,const double degrees,
+% const PixelInterpolateMethod method)
%
% A description of each parameter follows:
%
%
% o degrees: Define the tightness of the swirling effect.
%
+% o method: the pixel interpolation method.
+%
*/
WandExport MagickBooleanType MagickSwirlImage(MagickWand *wand,
- const double degrees)
+ const double degrees,const PixelInterpolateMethod method)
{
Image
*swirl_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- swirl_image=SwirlImage(wand->images,degrees,wand->exception);
+ swirl_image=SwirlImage(wand->images,degrees,method,wand->exception);
if (swirl_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,swirl_image);
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- (void) FormatLocaleString(percent_opaque,MaxTextExtent,
- "%g,%g,%g,%g",(double) (100.0*QuantumScale*
- PixelGetRedQuantum(opacity)),(double) (100.0*QuantumScale*
- PixelGetGreenQuantum(opacity)),(double) (100.0*QuantumScale*
- PixelGetBlueQuantum(opacity)),(double) (100.0*QuantumScale*
- PixelGetOpacityQuantum(opacity)));
+ if (wand->images->colorspace != CMYKColorspace)
+ (void) FormatLocaleString(percent_opaque,MaxTextExtent,
+ "%g,%g,%g,%g",(double) (100.0*QuantumScale*
+ PixelGetRedQuantum(opacity)),(double) (100.0*QuantumScale*
+ PixelGetGreenQuantum(opacity)),(double) (100.0*QuantumScale*
+ PixelGetBlueQuantum(opacity)),(double) (100.0*QuantumScale*
+ PixelGetOpacityQuantum(opacity)));
+ else
+ (void) FormatLocaleString(percent_opaque,MaxTextExtent,
+ "%g,%g,%g,%g,%g",(double) (100.0*QuantumScale*
+ PixelGetCyanQuantum(opacity)),(double) (100.0*QuantumScale*
+ PixelGetMagentaQuantum(opacity)),(double) (100.0*QuantumScale*
+ PixelGetYellowQuantum(opacity)),(double) (100.0*QuantumScale*
+ PixelGetBlackQuantum(opacity)),(double) (100.0*QuantumScale*
+ PixelGetOpacityQuantum(opacity)));
target=PixelGetPixel(tint);
tint_image=TintImage(wand->images,percent_opaque,&target,wand->exception);
if (tint_image == (Image *) NULL)
MagickHaldClutImage(MagickWand *,const MagickWand *),
MagickHasNextImage(MagickWand *),
MagickHasPreviousImage(MagickWand *),
- MagickImplodeImage(MagickWand *,const double),
+ MagickImplodeImage(MagickWand *,const double,const PixelInterpolateMethod),
MagickImportImagePixels(MagickWand *,const ssize_t,const ssize_t,const size_t,
const size_t,const char *,const StorageType,const void *),
MagickInverseFourierTransformImage(MagickWand *,MagickWand *,
MagickStatisticImage(MagickWand *,const StatisticType,const size_t,
const size_t),
MagickStripImage(MagickWand *),
- MagickSwirlImage(MagickWand *,const double),
+ MagickSwirlImage(MagickWand *,const double,const PixelInterpolateMethod),
MagickTintImage(MagickWand *,const PixelWand *,const PixelWand *),
MagickTransformImageColorspace(MagickWand *,const ColorspaceType),
MagickTransposeImage(MagickWand *),
*/
(void) SyncImageSettings(mogrify_info,*image);
(void) ParseGeometry(argv[i+1],&geometry_info);
- mogrify_image=ImplodeImage(*image,geometry_info.rho,exception);
+ mogrify_image=ImplodeImage(*image,geometry_info.rho,
+ interpolate_method,exception);
break;
}
if (LocaleCompare("interline-spacing",option+1) == 0)
*/
(void) SyncImageSettings(mogrify_info,*image);
(void) ParseGeometry(argv[i+1],&geometry_info);
- mogrify_image=SwirlImage(*image,geometry_info.rho,exception);
+ mogrify_image=SwirlImage(*image,geometry_info.rho,
+ interpolate_method,exception);
break;
}
break;
if ((attribute_flag[5] != 0) || (attribute_flag[6] != 0))
image->matte_color=fill_color;
if (attribute_flag[7] != 0)
- image->compose=(CompositeOperator) argument_list[7].integer_reference;
+ image->compose=(CompositeOperator)
+ argument_list[7].integer_reference;
image=FrameImage(image,&frame_info,exception);
break;
}
case 16: /* Implode */
{
+ PixelInterpolateMethod
+ method;
+
if (attribute_flag[0] == 0)
argument_list[0].real_reference=0.5;
+ method=UndefinedInterpolatePixel;
if (attribute_flag[1] != 0)
- image->interpolate=(PixelInterpolateMethod)
- argument_list[1].integer_reference;
+ method=(PixelInterpolateMethod) argument_list[1].integer_reference;
image=ImplodeImage(image,argument_list[0].real_reference,
- exception);
+ method,exception);
break;
}
case 17: /* Magnify */
}
case 30: /* Swirl */
{
+ PixelInterpolateMethod
+ method;
+
if (attribute_flag[0] == 0)
argument_list[0].real_reference=50.0;
+ method=UndefinedInterpolatePixel;
if (attribute_flag[1] != 0)
- image->interpolate=(PixelInterpolateMethod)
- argument_list[1].integer_reference;
- image=SwirlImage(image,argument_list[0].real_reference,exception);
+ method=(PixelInterpolateMethod) argument_list[1].integer_reference;
+ image=SwirlImage(image,argument_list[0].real_reference,
+ method,exception);
break;
}
case 31: /* Resize */
}
}
implode_image=ImplodeImage(msl_info->image[n],geometry_info.rho,
- &msl_info->image[n]->exception);
+ msl_info->image[n]->interpolate,&msl_info->image[n]->exception);
if (implode_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
}
swirl_image=SwirlImage(msl_info->image[n],geometry_info.rho,
- &msl_info->image[n]->exception);
+ msl_info->image[n]->interpolate,&msl_info->image[n]->exception);
if (swirl_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
projects / imagemagick / commitdiff