% July 2009 %
% %
% %
-% Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#if defined(MAGICKCORE_FFTW_DELEGATE)
#if defined(MAGICKCORE_HAVE_COMPLEX_H)
#include <complex.h>
-#else
+#endif
+#include <fftw3.h>
+#if !defined(MAGICKCORE_HAVE_CABS)
#define cabs(z) (sqrt(z[0]*z[0]+z[1]*z[1]))
-#define carg(z) (atan2(z[1],z[0]))
-#define creal(z) (z[0])
+#endif
+#if !defined(MAGICKCORE_HAVE_CARG)
+#define carg(z) (atan2(cimag(z),creal(z)))
+#endif
+#if !defined(MAGICKCORE_HAVE_CIMAG)
#define cimag(z) (z[1])
#endif
-#include <fftw3.h>
+#if !defined(MAGICKCORE_HAVE_CREAL)
+#define creal(z) (z[0])
+#endif
#endif
\f
/*
MagickBooleanType
modulus;
- unsigned long
+ size_t
width,
height;
- long
+ ssize_t
center;
} FourierInfo;
\f
#if defined(MAGICKCORE_FFTW_DELEGATE)
-static MagickBooleanType RollFourier(const unsigned long width,
- const unsigned long height,const long x_offset,const long y_offset,
- double *fourier)
+static MagickBooleanType RollFourier(const size_t width,const size_t height,
+ const ssize_t x_offset,const ssize_t y_offset,double *fourier)
{
double
*roll;
- long
+ register ssize_t
+ i,
+ x;
+
+ ssize_t
u,
v,
y;
- register long
- i,
- x;
-
/*
- Move the zero frequency (DC) from (0,0) to (width/2,height/2).
+ Move zero frequency (DC, average color) from (0,0) to (width/2,height/2).
*/
- roll=(double *) AcquireQuantumMemory((size_t) width,height*sizeof(*roll));
+ roll=(double *) AcquireQuantumMemory((size_t) height,width*sizeof(*roll));
if (roll == (double *) NULL)
return(MagickFalse);
i=0L;
- for (y=0L; y < (long) height; y++)
+ for (y=0L; y < (ssize_t) height; y++)
{
if (y_offset < 0L)
- v=((y+y_offset) < 0L) ? y+y_offset+(long) height : y+y_offset;
+ v=((y+y_offset) < 0L) ? y+y_offset+(ssize_t) height : y+y_offset;
else
- v=((y+y_offset) > ((long) height-1L)) ? y+y_offset-(long) height :
+ v=((y+y_offset) > ((ssize_t) height-1L)) ? y+y_offset-(ssize_t) height :
y+y_offset;
- for (x=0L; x < (long) width; x++)
+ for (x=0L; x < (ssize_t) width; x++)
{
if (x_offset < 0L)
- u=((x+x_offset) < 0L) ? x+x_offset+(long) width : x+x_offset;
+ u=((x+x_offset) < 0L) ? x+x_offset+(ssize_t) width : x+x_offset;
else
- u=((x+x_offset) > ((long) width-1L)) ? x+x_offset-(long) width :
+ u=((x+x_offset) > ((ssize_t) width-1L)) ? x+x_offset-(ssize_t) width :
x+x_offset;
roll[v*width+u]=fourier[i++];
- }
+ }
}
- (void) CopyMagickMemory(fourier,roll,width*height*sizeof(*roll));
+ (void) CopyMagickMemory(fourier,roll,height*width*sizeof(*roll));
roll=(double *) RelinquishMagickMemory(roll);
return(MagickTrue);
}
-static MagickBooleanType ForwardQuadrantSwap(const unsigned long width,
- const unsigned long height,double *source,double *destination)
+static MagickBooleanType ForwardQuadrantSwap(const size_t width,
+ const size_t height,double *source,double *destination)
{
- long
- center,
- y;
-
MagickBooleanType
status;
- register long
+ register ssize_t
x;
+ ssize_t
+ center,
+ y;
+
/*
Swap quadrants.
*/
- center=(long) floor((double) width/2L)+1L;
- status=RollFourier((unsigned long) center,height,0L,(long) height/2L,source);
+ center=(ssize_t) floor((double) width/2L)+1L;
+ status=RollFourier((size_t) center,height,0L,(ssize_t) height/2L,source);
if (status == MagickFalse)
return(MagickFalse);
- for (y=0L; y < (long) height; y++)
- for (x=0L; x < (long) (width/2L-1L); x++)
+ for (y=0L; y < (ssize_t) height; y++)
+ for (x=0L; x < (ssize_t) (width/2L-1L); x++)
destination[width*y+x+width/2L]=source[center*y+x];
- for (y=1; y < (long) height; y++)
- for (x=0L; x < (long) (width/2L-1L); x++)
+ for (y=1; y < (ssize_t) height; y++)
+ for (x=0L; x < (ssize_t) (width/2L-1L); x++)
destination[width*(height-y)+width/2L-x-1L]=source[center*y+x+1L];
- for (x=0L; x < (long) (width/2L); x++)
+ for (x=0L; x < (ssize_t) (width/2L); x++)
destination[-x+width/2L-1L]=destination[x+width/2L+1L];
return(MagickTrue);
}
-static void CorrectPhaseLHS(const unsigned long width,
- const unsigned long height,double *fourier)
+static void CorrectPhaseLHS(const size_t width,const size_t height,
+ double *fourier)
{
- long
- y;
-
- register long
+ register ssize_t
x;
- for (y=0L; y < (long) height; y++)
- for (x=0L; x < (long) (width/2L); x++)
+ ssize_t
+ y;
+
+ for (y=0L; y < (ssize_t) height; y++)
+ for (x=0L; x < (ssize_t) (width/2L); x++)
fourier[y*width+x]*=(-1.0);
}
*magnitude_image,
*phase_image;
- long
- i,
- y;
-
MagickBooleanType
status;
register IndexPacket
*indexes;
- register long
+ register ssize_t
x;
register PixelPacket
*q;
+ ssize_t
+ i,
+ y;
+
magnitude_image=GetFirstImageInList(image);
phase_image=GetNextImageInList(image);
if (phase_image == (Image *) NULL)
fourier_info->height,fourier_info->width*sizeof(*magnitude_source));
if (magnitude_source == (double *) NULL)
return(MagickFalse);
- (void) ResetMagickMemory(magnitude_source,0,fourier_info->width*
- fourier_info->height*sizeof(*magnitude_source));
+ (void) ResetMagickMemory(magnitude_source,0,fourier_info->height*
+ fourier_info->width*sizeof(*magnitude_source));
phase_source=(double *) AcquireQuantumMemory((size_t) fourier_info->height,
fourier_info->width*sizeof(*phase_source));
- if (magnitude_source == (double *) NULL)
+ if (phase_source == (double *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
if (fourier_info->modulus != MagickFalse)
{
i=0L;
- for (y=0L; y < (long) fourier_info->height; y++)
- for (x=0L; x < (long) fourier_info->width; x++)
+ for (y=0L; y < (ssize_t) fourier_info->height; y++)
+ for (x=0L; x < (ssize_t) fourier_info->width; x++)
{
phase_source[i]/=(2.0*MagickPI);
phase_source[i]+=0.5;
magnitude_view=AcquireCacheView(magnitude_image);
phase_view=AcquireCacheView(phase_image);
i=0L;
- for (y=0L; y < (long) fourier_info->height; y++)
+ for (y=0L; y < (ssize_t) fourier_info->height; y++)
{
q=GetCacheViewAuthenticPixels(magnitude_view,0L,y,fourier_info->height,1UL,
exception);
if (q == (PixelPacket *) NULL)
break;
indexes=GetCacheViewAuthenticIndexQueue(magnitude_view);
- for (x=0L; x < (long) fourier_info->width; x++)
+ for (x=0L; x < (ssize_t) fourier_info->width; x++)
{
switch (fourier_info->channel)
{
case RedChannel:
default:
{
- q->red=HDRIClampToQuantum(QuantumRange*magnitude_source[i]);
+ SetRedPixelComponent(q,ClampToQuantum(QuantumRange*
+ magnitude_source[i]));
break;
}
case GreenChannel:
{
- q->green=HDRIClampToQuantum(QuantumRange*magnitude_source[i]);
+ SetGreenPixelComponent(q,ClampToQuantum(QuantumRange*
+ magnitude_source[i]));
break;
}
case BlueChannel:
{
- q->blue=HDRIClampToQuantum(QuantumRange*magnitude_source[i]);
+ SetBluePixelComponent(q,ClampToQuantum(QuantumRange*
+ magnitude_source[i]));
break;
}
case OpacityChannel:
{
- q->opacity=HDRIClampToQuantum(QuantumRange*magnitude_source[i]);
+ SetOpacityPixelComponent(q,ClampToQuantum(QuantumRange*
+ magnitude_source[i]));
break;
}
case IndexChannel:
{
- indexes[x]=HDRIClampToQuantum(QuantumRange*magnitude_source[i]);
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(QuantumRange*
+ magnitude_source[i]));
break;
}
case GrayChannels:
{
- q->red=HDRIClampToQuantum(QuantumRange*magnitude_source[i]);
- q->green=q->red;
- q->blue=q->red;
+ SetGrayPixelComponent(q,ClampToQuantum(QuantumRange*
+ magnitude_source[i]));
break;
}
}
break;
}
i=0L;
- for (y=0L; y < (long) fourier_info->height; y++)
+ for (y=0L; y < (ssize_t) fourier_info->height; y++)
{
q=GetCacheViewAuthenticPixels(phase_view,0L,y,fourier_info->height,1UL,
exception);
if (q == (PixelPacket *) NULL)
break;
indexes=GetCacheViewAuthenticIndexQueue(phase_view);
- for (x=0L; x < (long) fourier_info->width; x++)
+ for (x=0L; x < (ssize_t) fourier_info->width; x++)
{
switch (fourier_info->channel)
{
case RedChannel:
default:
{
- q->red=HDRIClampToQuantum(QuantumRange*phase_source[i]);
+ SetRedPixelComponent(q,ClampToQuantum(QuantumRange*
+ phase_source[i]));
break;
}
case GreenChannel:
{
- q->green=HDRIClampToQuantum(QuantumRange*phase_source[i]);
+ SetGreenPixelComponent(q,ClampToQuantum(QuantumRange*
+ phase_source[i]));
break;
}
case BlueChannel:
{
- q->blue=HDRIClampToQuantum(QuantumRange*phase_source[i]);
+ SetBluePixelComponent(q,ClampToQuantum(QuantumRange*
+ phase_source[i]));
break;
}
case OpacityChannel:
{
- q->opacity=HDRIClampToQuantum(QuantumRange*phase_source[i]);
+ SetOpacityPixelComponent(q,ClampToQuantum(QuantumRange*
+ phase_source[i]));
break;
}
case IndexChannel:
{
- indexes[x]=HDRIClampToQuantum(QuantumRange*phase_source[i]);
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(QuantumRange*
+ phase_source[i]));
break;
}
case GrayChannels:
{
- q->red=HDRIClampToQuantum(QuantumRange*phase_source[i]);
- q->green=q->red;
- q->blue=q->red;
+ SetGrayPixelComponent(q,ClampToQuantum(QuantumRange*phase_source[i]));
break;
}
}
fftw_plan
fftw_r2c_plan;
- long
- y;
-
register const IndexPacket
*indexes;
register const PixelPacket
*p;
- register long
+ register ssize_t
i,
x;
+ ssize_t
+ y;
+
/*
Generate the forward Fourier transform.
*/
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
return(MagickFalse);
}
- ResetMagickMemory(source,0,fourier_info->width*fourier_info->height*
+ ResetMagickMemory(source,0,fourier_info->height*fourier_info->width*
sizeof(*source));
i=0L;
image_view=AcquireCacheView(image);
- for (y=0L; y < (long) fourier_info->height; y++)
+ for (y=0L; y < (ssize_t) fourier_info->height; y++)
{
p=GetCacheViewVirtualPixels(image_view,0L,y,fourier_info->width,1UL,
exception);
if (p == (const PixelPacket *) NULL)
break;
indexes=GetCacheViewVirtualIndexQueue(image_view);
- for (x=0L; x < (long) fourier_info->width; x++)
+ for (x=0L; x < (ssize_t) fourier_info->width; x++)
{
switch (fourier_info->channel)
{
}
case GrayChannels:
{
- source[i]=QuantumScale*GetRedPixelComponent(p);
+ source[i]=QuantumScale*GetGrayPixelComponent(p);
break;
}
}
}
}
image_view=DestroyCacheView(image_view);
- fourier=(fftw_complex *) AcquireAlignedMemory((size_t) fourier_info->height,
+ fourier=(fftw_complex *) AcquireQuantumMemory((size_t) fourier_info->height,
fourier_info->center*sizeof(*fourier));
if (fourier == (fftw_complex *) NULL)
{
*/
n=(double) fourier_info->width*(double) fourier_info->width;
i=0L;
- for (y=0L; y < (long) fourier_info->height; y++)
- for (x=0L; x < (long) fourier_info->center; x++)
+ for (y=0L; y < (ssize_t) fourier_info->height; y++)
+ for (x=0L; x < (ssize_t) fourier_info->center; x++)
{
#if defined(MAGICKCORE_HAVE_COMPLEX_H)
fourier[i]/=n;
*/
i=0L;
if (fourier_info->modulus != MagickFalse)
- for (y=0L; y < (long) fourier_info->height; y++)
- for (x=0L; x < (long) fourier_info->center; x++)
+ for (y=0L; y < (ssize_t) fourier_info->height; y++)
+ for (x=0L; x < (ssize_t) fourier_info->center; x++)
{
magnitude[i]=cabs(fourier[i]);
phase[i]=carg(fourier[i]);
i++;
}
else
- for (y=0L; y < (long) fourier_info->height; y++)
- for (x=0L; x < (long) fourier_info->center; x++)
+ for (y=0L; y < (ssize_t) fourier_info->height; y++)
+ for (x=0L; x < (ssize_t) fourier_info->center; x++)
{
magnitude[i]=creal(fourier[i]);
phase[i]=cimag(fourier[i]);
i++;
}
- fourier=(fftw_complex *) RelinquishAlignedMemory(fourier);
+ fourier=(fftw_complex *) RelinquishMagickMemory(fourier);
return(MagickTrue);
}
fftw_complex
*fourier;
- MagickBooleanType
- status;
-
FourierInfo
fourier_info;
+ MagickBooleanType
+ status;
+
size_t
extent;
fourier_info.width=(extent & 0x01) == 1 ? extent+1UL : extent;
}
fourier_info.height=fourier_info.width;
- fourier_info.center=(long) floor((double) fourier_info.width/2.0)+1L;
+ fourier_info.center=(ssize_t) floor((double) fourier_info.width/2.0)+1L;
fourier_info.channel=channel;
fourier_info.modulus=modulus;
magnitude=(double *) AcquireQuantumMemory((size_t) fourier_info.height,
magnitude=(double *) RelinquishMagickMemory(magnitude);
return(MagickFalse);
}
- fourier=(fftw_complex *) AcquireAlignedMemory((size_t) fourier_info.height,
+ fourier=(fftw_complex *) AcquireQuantumMemory((size_t) fourier_info.height,
fourier_info.center*sizeof(*fourier));
if (fourier == (fftw_complex *) NULL)
{
if (status != MagickFalse)
status=ForwardFourier(&fourier_info,fourier_image,magnitude,phase,
exception);
- fourier=(fftw_complex *) RelinquishAlignedMemory(fourier);
+ fourier=(fftw_complex *) RelinquishMagickMemory(fourier);
phase=(double *) RelinquishMagickMemory(phase);
magnitude=(double *) RelinquishMagickMemory(magnitude);
return(status);
Image
*magnitude_image;
- unsigned long
+ size_t
extent,
width;
is_gray,
status;
- register long
- i;
-
phase_image->storage_class=DirectClass;
phase_image->depth=32UL;
AppendImageToList(&fourier_image,magnitude_image);
status=MagickTrue;
is_gray=IsGrayImage(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(status)
+ #pragma omp parallel sections
#endif
- for (i=0L; i < 5L; i++)
{
- MagickBooleanType
- thread_status;
-
- thread_status=MagickTrue;
- switch (i)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp section
+#endif
{
- case 0:
- {
- if (is_gray != MagickFalse)
- {
- thread_status=ForwardFourierTransformChannel(image,
- GrayChannels,modulus,fourier_image,exception);
- break;
- }
- thread_status=ForwardFourierTransformChannel(image,RedChannel,
- modulus,fourier_image,exception);
- break;
- }
- case 1:
- {
- if (is_gray == MagickFalse)
- thread_status=ForwardFourierTransformChannel(image,
- GreenChannel,modulus,fourier_image,exception);
- break;
- }
- case 2:
- {
- if (is_gray == MagickFalse)
- thread_status=ForwardFourierTransformChannel(image,
- BlueChannel,modulus,fourier_image,exception);
- break;
- }
- case 4:
- {
- if (image->matte != MagickFalse)
- thread_status=ForwardFourierTransformChannel(image,
- OpacityChannel,modulus,fourier_image,exception);
- break;
- }
- case 5:
- {
- if (image->colorspace == CMYKColorspace)
- thread_status=ForwardFourierTransformChannel(image,
- IndexChannel,modulus,fourier_image,exception);
- break;
- }
+ MagickBooleanType
+ thread_status;
+
+ if (is_gray != MagickFalse)
+ thread_status=ForwardFourierTransformChannel(image,
+ GrayChannels,modulus,fourier_image,exception);
+ else
+ thread_status=ForwardFourierTransformChannel(image,
+ RedChannel,modulus,fourier_image,exception);
+ if (thread_status == MagickFalse)
+ status=thread_status;
+ }
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp section
+#endif
+ {
+ MagickBooleanType
+ thread_status;
+
+ thread_status=MagickTrue;
+ if (is_gray == MagickFalse)
+ thread_status=ForwardFourierTransformChannel(image,
+ GreenChannel,modulus,fourier_image,exception);
+ if (thread_status == MagickFalse)
+ status=thread_status;
+ }
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp section
+#endif
+ {
+ MagickBooleanType
+ thread_status;
+
+ thread_status=MagickTrue;
+ if (is_gray == MagickFalse)
+ thread_status=ForwardFourierTransformChannel(image,
+ BlueChannel,modulus,fourier_image,exception);
+ if (thread_status == MagickFalse)
+ status=thread_status;
+ }
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp section
+#endif
+ {
+ MagickBooleanType
+ thread_status;
+
+ thread_status=MagickTrue;
+ if (image->matte != MagickFalse)
+ thread_status=ForwardFourierTransformChannel(image,
+ OpacityChannel,modulus,fourier_image,exception);
+ if (thread_status == MagickFalse)
+ status=thread_status;
+ }
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp section
+#endif
+ {
+ MagickBooleanType
+ thread_status;
+
+ thread_status=MagickTrue;
+ if (image->colorspace == CMYKColorspace)
+ thread_status=ForwardFourierTransformChannel(image,
+ IndexChannel,modulus,fourier_image,exception);
+ if (thread_status == MagickFalse)
+ status=thread_status;
}
- if (thread_status == MagickFalse)
- status=thread_status;
}
if (status == MagickFalse)
fourier_image=DestroyImageList(fourier_image);
*/
#if defined(MAGICKCORE_FFTW_DELEGATE)
-static MagickBooleanType InverseQuadrantSwap(const unsigned long width,
- const unsigned long height,const double *source,double *destination)
+static MagickBooleanType InverseQuadrantSwap(const size_t width,
+ const size_t height,const double *source,double *destination)
{
- long
+ register ssize_t
+ x;
+
+ ssize_t
center,
y;
- register long
- x;
-
/*
Swap quadrants.
*/
- center=(long) floor((double) width/2.0)+1L;
- for (y=1L; y < (long) height; y++)
- for (x=0L; x < (long) (width/2L+1L); x++)
+ center=(ssize_t) floor((double) width/2.0)+1L;
+ for (y=1L; y < (ssize_t) height; y++)
+ for (x=0L; x < (ssize_t) (width/2L+1L); x++)
destination[center*(height-y)-x+width/2L]=source[y*width+x];
- for (y=0L; y < (long) height; y++)
+ for (y=0L; y < (ssize_t) height; y++)
destination[center*y]=source[y*width+width/2L];
for (x=0L; x < center; x++)
destination[x]=source[center-x-1L];
- return(RollFourier(center,height,0L,(long) height/-2L,destination));
+ return(RollFourier(center,height,0L,(ssize_t) height/-2L,destination));
}
static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
*magnitude_source,
*phase_source;
- long
- y;
-
MagickBooleanType
status;
register const PixelPacket
*p;
- register long
+ register ssize_t
i,
x;
+ ssize_t
+ y;
+
/*
Inverse fourier - read image and break down into a double array.
*/
return(MagickFalse);
}
phase_source=(double *) AcquireQuantumMemory((size_t) fourier_info->height,
- fourier_info->height*sizeof(*phase_source));
+ fourier_info->width*sizeof(*phase_source));
if (phase_source == (double *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
}
i=0L;
magnitude_view=AcquireCacheView(magnitude_image);
- for (y=0L; y < (long) fourier_info->height; y++)
+ for (y=0L; y < (ssize_t) fourier_info->height; y++)
{
p=GetCacheViewVirtualPixels(magnitude_view,0L,y,fourier_info->width,1UL,
exception);
if (p == (const PixelPacket *) NULL)
break;
indexes=GetCacheViewAuthenticIndexQueue(magnitude_view);
- for (x=0L; x < (long) fourier_info->width; x++)
+ for (x=0L; x < (ssize_t) fourier_info->width; x++)
{
switch (fourier_info->channel)
{
}
case GrayChannels:
{
- magnitude_source[i]=QuantumScale*GetRedPixelComponent(p);
+ magnitude_source[i]=QuantumScale*GetGrayPixelComponent(p);
break;
}
}
}
i=0L;
phase_view=AcquireCacheView(phase_image);
- for (y=0L; y < (long) fourier_info->height; y++)
+ for (y=0L; y < (ssize_t) fourier_info->height; y++)
{
p=GetCacheViewVirtualPixels(phase_view,0,y,fourier_info->width,1,
exception);
if (p == (const PixelPacket *) NULL)
break;
indexes=GetCacheViewAuthenticIndexQueue(phase_view);
- for (x=0L; x < (long) fourier_info->width; x++)
+ for (x=0L; x < (ssize_t) fourier_info->width; x++)
{
switch (fourier_info->channel)
{
}
case GrayChannels:
{
- phase_source[i]=QuantumScale*GetRedPixelComponent(p);
+ phase_source[i]=QuantumScale*GetGrayPixelComponent(p);
break;
}
}
if (fourier_info->modulus != MagickFalse)
{
i=0L;
- for (y=0L; y < (long) fourier_info->height; y++)
- for (x=0L; x < (long) fourier_info->width; x++)
+ for (y=0L; y < (ssize_t) fourier_info->height; y++)
+ for (x=0L; x < (ssize_t) fourier_info->width; x++)
{
phase_source[i]-=0.5;
phase_source[i]*=(2.0*MagickPI);
status=InverseQuadrantSwap(fourier_info->width,fourier_info->height,
magnitude_source,magnitude);
magnitude_source=(double *) RelinquishMagickMemory(magnitude_source);
- phase=(double *) AcquireQuantumMemory((size_t) fourier_info->width,
- fourier_info->height*sizeof(*phase));
+ phase=(double *) AcquireQuantumMemory((size_t) fourier_info->height,
+ fourier_info->width*sizeof(*phase));
if (phase == (double *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
*/
i=0L;
if (fourier_info->modulus != MagickFalse)
- for (y=0L; y < (long) fourier_info->height; y++)
- for (x=0L; x < (long) fourier_info->center; x++)
+ for (y=0L; y < (ssize_t) fourier_info->height; y++)
+ for (x=0L; x < (ssize_t) fourier_info->center; x++)
{
#if defined(MAGICKCORE_HAVE_COMPLEX_H)
fourier[i]=magnitude[i]*cos(phase[i])+I*magnitude[i]*sin(phase[i]);
i++;
}
else
- for (y=0L; y < (long) fourier_info->height; y++)
- for (x=0L; x < (long) fourier_info->center; x++)
+ for (y=0L; y < (ssize_t) fourier_info->height; y++)
+ for (x=0L; x < (ssize_t) fourier_info->center; x++)
{
#if defined(MAGICKCORE_HAVE_COMPLEX_H)
fourier[i]=magnitude[i]+I*phase[i];
fftw_plan
fftw_c2r_plan;
- long
- y;
-
register IndexPacket
*indexes;
- register long
+ register PixelPacket
+ *q;
+
+ register ssize_t
i,
x;
- register PixelPacket
- *q;
+ ssize_t
+ y;
- source=(double *) AcquireQuantumMemory((size_t) fourier_info->width,
- fourier_info->height*sizeof(double));
+ source=(double *) AcquireQuantumMemory((size_t) fourier_info->height,
+ fourier_info->width*sizeof(*source));
if (source == (double *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp critical (MagickCore_InverseFourierTransform)
#endif
- fftw_c2r_plan=fftw_plan_dft_c2r_2d(fourier_info->width,fourier_info->height,
- fourier,source,FFTW_ESTIMATE);
- fftw_execute(fftw_c2r_plan);
- fftw_destroy_plan(fftw_c2r_plan);
+ {
+ fftw_c2r_plan=fftw_plan_dft_c2r_2d(fourier_info->width,fourier_info->height,
+ fourier,source,FFTW_ESTIMATE);
+ fftw_execute(fftw_c2r_plan);
+ fftw_destroy_plan(fftw_c2r_plan);
+ }
i=0L;
image_view=AcquireCacheView(image);
- for (y=0L; y < (long) fourier_info->height; y++)
+ for (y=0L; y < (ssize_t) fourier_info->height; y++)
{
- q=GetCacheViewAuthenticPixels(image_view,0L,y,fourier_info->width,1UL,
- exception);
+ if (y >= (ssize_t) image->rows)
+ break;
+ q=GetCacheViewAuthenticPixels(image_view,0L,y,fourier_info->width >
+ image->columns ? image->columns : fourier_info->width,1UL,exception);
if (q == (PixelPacket *) NULL)
break;
indexes=GetCacheViewAuthenticIndexQueue(image_view);
- for (x=0L; x < (long) fourier_info->width; x++)
+ for (x=0L; x < (ssize_t) fourier_info->width; x++)
{
switch (fourier_info->channel)
{
case RedChannel:
default:
{
- q->red=HDRIClampToQuantum(QuantumRange*source[i]);
+ SetRedPixelComponent(q,ClampToQuantum(QuantumRange*source[i]));
break;
}
case GreenChannel:
{
- q->green=HDRIClampToQuantum(QuantumRange*source[i]);
+ SetGreenPixelComponent(q,ClampToQuantum(QuantumRange*source[i]));
break;
}
case BlueChannel:
{
- q->blue=HDRIClampToQuantum(QuantumRange*source[i]);
+ SetBluePixelComponent(q,ClampToQuantum(QuantumRange*source[i]));
break;
}
case OpacityChannel:
{
- q->opacity=HDRIClampToQuantum(QuantumRange*source[i]);
+ SetOpacityPixelComponent(q,ClampToQuantum(QuantumRange*source[i]));
break;
}
case IndexChannel:
{
- indexes[x]=HDRIClampToQuantum(QuantumRange*source[i]);
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(QuantumRange*
+ source[i]));
break;
}
case GrayChannels:
{
- q->red=HDRIClampToQuantum(QuantumRange*source[i]);
- q->green=q->red;
- q->blue=q->red;
+ SetGrayPixelComponent(q,ClampToQuantum(QuantumRange*source[i]));
break;
}
}
fourier_info.width=(extent & 0x01) == 1 ? extent+1UL : extent;
}
fourier_info.height=fourier_info.width;
- fourier_info.center=(long) floor((double) fourier_info.width/2.0)+1L;
+ fourier_info.center=(ssize_t) floor((double) fourier_info.width/2.0)+1L;
fourier_info.channel=channel;
fourier_info.modulus=modulus;
magnitude=(double *) AcquireQuantumMemory((size_t) fourier_info.height,
- fourier_info.center*sizeof(double));
+ fourier_info.center*sizeof(*magnitude));
if (magnitude == (double *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
return(MagickFalse);
}
phase=(double *) AcquireQuantumMemory((size_t) fourier_info.height,
- fourier_info.center*sizeof(double));
+ fourier_info.center*sizeof(*phase));
if (phase == (double *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
magnitude=(double *) RelinquishMagickMemory(magnitude);
return(MagickFalse);
}
- fourier=(fftw_complex *) AcquireAlignedMemory((size_t) fourier_info.height,
+ fourier=(fftw_complex *) AcquireQuantumMemory((size_t) fourier_info.height,
fourier_info.center*sizeof(*fourier));
if (fourier == (fftw_complex *) NULL)
{
if (status != MagickFalse)
status=InverseFourierTransform(&fourier_info,fourier,fourier_image,
exception);
- fourier=(fftw_complex *) RelinquishAlignedMemory(fourier);
+ fourier=(fftw_complex *) RelinquishMagickMemory(fourier);
phase=(double *) RelinquishMagickMemory(phase);
magnitude=(double *) RelinquishMagickMemory(magnitude);
return(status);
is_gray,
status;
- register long
- i;
-
status=MagickTrue;
is_gray=IsGrayImage(magnitude_image,exception);
if (is_gray != MagickFalse)
is_gray=IsGrayImage(phase_image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(dynamic,4) shared(status)
+ #pragma omp parallel sections
#endif
- for (i=0L; i < 5L; i++)
{
- MagickBooleanType
- thread_status;
-
- thread_status=MagickTrue;
- switch (i)
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp section
+#endif
{
- case 0:
- {
- if (is_gray != MagickFalse)
- {
- thread_status=InverseFourierTransformChannel(magnitude_image,
- phase_image,GrayChannels,modulus,fourier_image,exception);
- break;
- }
+ MagickBooleanType
+ thread_status;
+
+ if (is_gray != MagickFalse)
+ thread_status=InverseFourierTransformChannel(magnitude_image,
+ phase_image,GrayChannels,modulus,fourier_image,exception);
+ else
thread_status=InverseFourierTransformChannel(magnitude_image,
phase_image,RedChannel,modulus,fourier_image,exception);
- break;
- }
- case 1:
- {
- if (is_gray == MagickFalse)
- thread_status=InverseFourierTransformChannel(magnitude_image,
- phase_image,GreenChannel,modulus,fourier_image,exception);
- break;
- }
- case 2:
- {
- if (is_gray == MagickFalse)
- thread_status=InverseFourierTransformChannel(magnitude_image,
- phase_image,BlueChannel,modulus,fourier_image,exception);
- break;
- }
- case 3:
- {
- if (magnitude_image->matte != MagickFalse)
- thread_status=InverseFourierTransformChannel(magnitude_image,
- phase_image,OpacityChannel,modulus,fourier_image,exception);
- break;
- }
- case 4:
- {
- if (magnitude_image->colorspace == CMYKColorspace)
- thread_status=InverseFourierTransformChannel(magnitude_image,
- phase_image,IndexChannel,modulus,fourier_image,exception);
- break;
- }
+ if (thread_status == MagickFalse)
+ status=thread_status;
+ }
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp section
+#endif
+ {
+ MagickBooleanType
+ thread_status;
+
+ thread_status=MagickTrue;
+ if (is_gray == MagickFalse)
+ thread_status=InverseFourierTransformChannel(magnitude_image,
+ phase_image,GreenChannel,modulus,fourier_image,exception);
+ if (thread_status == MagickFalse)
+ status=thread_status;
+ }
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp section
+#endif
+ {
+ MagickBooleanType
+ thread_status;
+
+ thread_status=MagickTrue;
+ if (is_gray == MagickFalse)
+ thread_status=InverseFourierTransformChannel(magnitude_image,
+ phase_image,BlueChannel,modulus,fourier_image,exception);
+ if (thread_status == MagickFalse)
+ status=thread_status;
+ }
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp section
+#endif
+ {
+ MagickBooleanType
+ thread_status;
+
+ thread_status=MagickTrue;
+ if (magnitude_image->matte != MagickFalse)
+ thread_status=InverseFourierTransformChannel(magnitude_image,
+ phase_image,OpacityChannel,modulus,fourier_image,exception);
+ if (thread_status == MagickFalse)
+ status=thread_status;
+ }
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp section
+#endif
+ {
+ MagickBooleanType
+ thread_status;
+
+ thread_status=MagickTrue;
+ if (magnitude_image->colorspace == CMYKColorspace)
+ thread_status=InverseFourierTransformChannel(magnitude_image,
+ phase_image,IndexChannel,modulus,fourier_image,exception);
+ if (thread_status == MagickFalse)
+ status=thread_status;
}
- if (thread_status == MagickFalse)
- status=thread_status;
}
if (status == MagickFalse)
fourier_image=DestroyImage(fourier_image);
}
- fftw_cleanup();
+ fftw_cleanup();
}
#endif
return(fourier_image);