|
|
/*
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
% %
|
|
|
% %
|
|
|
% %
|
|
|
% FFFFF OOO U U RRRR IIIII EEEEE RRRR %
|
|
|
% F O O U U R R I E R R %
|
|
|
% FFF O O U U RRRR I EEE RRRR %
|
|
|
% F O O U U R R I E R R %
|
|
|
% F OOO UUU R R IIIII EEEEE R R %
|
|
|
% %
|
|
|
% %
|
|
|
% MagickCore Discrete Fourier Transform Methods %
|
|
|
% %
|
|
|
% Software Design %
|
|
|
% Sean Burke %
|
|
|
% Fred Weinhaus %
|
|
|
% Cristy %
|
|
|
% July 2009 %
|
|
|
% %
|
|
|
% %
|
|
|
% Copyright 1999-2021 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 %
|
|
|
% obtain a copy of the License at %
|
|
|
% %
|
|
|
% https://imagemagick.org/script/license.php %
|
|
|
% %
|
|
|
% Unless required by applicable law or agreed to in writing, software %
|
|
|
% distributed under the License is distributed on an "AS IS" BASIS, %
|
|
|
% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
|
|
|
% See the License for the specific language governing permissions and %
|
|
|
% limitations under the License. %
|
|
|
% %
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
%
|
|
|
%
|
|
|
%
|
|
|
*/
|
|
|
|
|
|
/*
|
|
|
Include declarations.
|
|
|
*/
|
|
|
#include "MagickCore/studio.h"
|
|
|
#include "MagickCore/artifact.h"
|
|
|
#include "MagickCore/attribute.h"
|
|
|
#include "MagickCore/blob.h"
|
|
|
#include "MagickCore/cache.h"
|
|
|
#include "MagickCore/image.h"
|
|
|
#include "MagickCore/image-private.h"
|
|
|
#include "MagickCore/list.h"
|
|
|
#include "MagickCore/fourier.h"
|
|
|
#include "MagickCore/log.h"
|
|
|
#include "MagickCore/memory_.h"
|
|
|
#include "MagickCore/monitor.h"
|
|
|
#include "MagickCore/monitor-private.h"
|
|
|
#include "MagickCore/pixel-accessor.h"
|
|
|
#include "MagickCore/pixel-private.h"
|
|
|
#include "MagickCore/property.h"
|
|
|
#include "MagickCore/quantum-private.h"
|
|
|
#include "MagickCore/resource_.h"
|
|
|
#include "MagickCore/string-private.h"
|
|
|
#include "MagickCore/thread-private.h"
|
|
|
#if defined(MAGICKCORE_FFTW_DELEGATE)
|
|
|
#if defined(MAGICKCORE_HAVE_COMPLEX_H)
|
|
|
#include <complex.h>
|
|
|
#endif
|
|
|
#include <fftw3.h>
|
|
|
#if !defined(MAGICKCORE_HAVE_CABS)
|
|
|
#define cabs(z) (sqrt(z[0]*z[0]+z[1]*z[1]))
|
|
|
#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
|
|
|
#if !defined(MAGICKCORE_HAVE_CREAL)
|
|
|
#define creal(z) (z[0])
|
|
|
#endif
|
|
|
#endif
|
|
|
|
|
|
/*
|
|
|
Typedef declarations.
|
|
|
*/
|
|
|
typedef struct _FourierInfo
|
|
|
{
|
|
|
PixelChannel
|
|
|
channel;
|
|
|
|
|
|
MagickBooleanType
|
|
|
modulus;
|
|
|
|
|
|
size_t
|
|
|
width,
|
|
|
height;
|
|
|
|
|
|
ssize_t
|
|
|
center;
|
|
|
} FourierInfo;
|
|
|
|
|
|
/*
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
% %
|
|
|
% %
|
|
|
% %
|
|
|
% C o m p l e x I m a g e s %
|
|
|
% %
|
|
|
% %
|
|
|
% %
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
%
|
|
|
% ComplexImages() performs complex mathematics on an image sequence.
|
|
|
%
|
|
|
% The format of the ComplexImages method is:
|
|
|
%
|
|
|
% MagickBooleanType ComplexImages(Image *images,const ComplexOperator op,
|
|
|
% ExceptionInfo *exception)
|
|
|
%
|
|
|
% A description of each parameter follows:
|
|
|
%
|
|
|
% o image: the image.
|
|
|
%
|
|
|
% o op: A complex operator.
|
|
|
%
|
|
|
% o exception: return any errors or warnings in this structure.
|
|
|
%
|
|
|
*/
|
|
|
MagickExport Image *ComplexImages(const Image *images,const ComplexOperator op,
|
|
|
ExceptionInfo *exception)
|
|
|
{
|
|
|
#define ComplexImageTag "Complex/Image"
|
|
|
|
|
|
CacheView
|
|
|
*Ai_view,
|
|
|
*Ar_view,
|
|
|
*Bi_view,
|
|
|
*Br_view,
|
|
|
*Ci_view,
|
|
|
*Cr_view;
|
|
|
|
|
|
const char
|
|
|
*artifact;
|
|
|
|
|
|
const Image
|
|
|
*Ai_image,
|
|
|
*Ar_image,
|
|
|
*Bi_image,
|
|
|
*Br_image;
|
|
|
|
|
|
double
|
|
|
snr;
|
|
|
|
|
|
Image
|
|
|
*Ci_image,
|
|
|
*complex_images,
|
|
|
*Cr_image,
|
|
|
*image;
|
|
|
|
|
|
MagickBooleanType
|
|
|
status;
|
|
|
|
|
|
MagickOffsetType
|
|
|
progress;
|
|
|
|
|
|
size_t
|
|
|
columns,
|
|
|
number_channels,
|
|
|
rows;
|
|
|
|
|
|
ssize_t
|
|
|
y;
|
|
|
|
|
|
assert(images != (Image *) NULL);
|
|
|
assert(images->signature == MagickCoreSignature);
|
|
|
if (images->debug != MagickFalse)
|
|
|
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
|
|
|
assert(exception != (ExceptionInfo *) NULL);
|
|
|
assert(exception->signature == MagickCoreSignature);
|
|
|
if (images->next == (Image *) NULL)
|
|
|
{
|
|
|
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
|
|
|
"ImageSequenceRequired","`%s'",images->filename);
|
|
|
return((Image *) NULL);
|
|
|
}
|
|
|
image=CloneImage(images,0,0,MagickTrue,exception);
|
|
|
if (image == (Image *) NULL)
|
|
|
return((Image *) NULL);
|
|
|
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
|
|
|
{
|
|
|
image=DestroyImageList(image);
|
|
|
return(image);
|
|
|
}
|
|
|
image->depth=32UL;
|
|
|
complex_images=NewImageList();
|
|
|
AppendImageToList(&complex_images,image);
|
|
|
image=CloneImage(images->next,0,0,MagickTrue,exception);
|
|
|
if (image == (Image *) NULL)
|
|
|
{
|
|
|
complex_images=DestroyImageList(complex_images);
|
|
|
return(complex_images);
|
|
|
}
|
|
|
image->depth=32UL;
|
|
|
AppendImageToList(&complex_images,image);
|
|
|
if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
|
|
|
{
|
|
|
complex_images=DestroyImageList(complex_images);
|
|
|
return(complex_images);
|
|
|
}
|
|
|
/*
|
|
|
Apply complex mathematics to image pixels.
|
|
|
*/
|
|
|
artifact=GetImageArtifact(images,"complex:snr");
|
|
|
snr=0.0;
|
|
|
if (artifact != (const char *) NULL)
|
|
|
snr=StringToDouble(artifact,(char **) NULL);
|
|
|
Ar_image=images;
|
|
|
Ai_image=images->next;
|
|
|
Br_image=images;
|
|
|
Bi_image=images->next;
|
|
|
if ((images->next->next != (Image *) NULL) &&
|
|
|
(images->next->next->next != (Image *) NULL))
|
|
|
{
|
|
|
Br_image=images->next->next;
|
|
|
Bi_image=images->next->next->next;
|
|
|
}
|
|
|
Cr_image=complex_images;
|
|
|
Ci_image=complex_images->next;
|
|
|
number_channels=MagickMin(MagickMin(MagickMin(
|
|
|
Ar_image->number_channels,Ai_image->number_channels),MagickMin(
|
|
|
Br_image->number_channels,Bi_image->number_channels)),MagickMin(
|
|
|
Cr_image->number_channels,Ci_image->number_channels));
|
|
|
Ar_view=AcquireVirtualCacheView(Ar_image,exception);
|
|
|
Ai_view=AcquireVirtualCacheView(Ai_image,exception);
|
|
|
Br_view=AcquireVirtualCacheView(Br_image,exception);
|
|
|
Bi_view=AcquireVirtualCacheView(Bi_image,exception);
|
|
|
Cr_view=AcquireAuthenticCacheView(Cr_image,exception);
|
|
|
Ci_view=AcquireAuthenticCacheView(Ci_image,exception);
|
|
|
status=MagickTrue;
|
|
|
progress=0;
|
|
|
columns=MagickMin(Cr_image->columns,Ci_image->columns);
|
|
|
rows=MagickMin(Cr_image->rows,Ci_image->rows);
|
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT)
|
|
|
#pragma omp parallel for schedule(static) shared(progress,status) \
|
|
|
magick_number_threads(Cr_image,complex_images,rows,1L)
|
|
|
#endif
|
|
|
for (y=0; y < (ssize_t) rows; y++)
|
|
|
{
|
|
|
const Quantum
|
|
|
*magick_restrict Ai,
|
|
|
*magick_restrict Ar,
|
|
|
*magick_restrict Bi,
|
|
|
*magick_restrict Br;
|
|
|
|
|
|
Quantum
|
|
|
*magick_restrict Ci,
|
|
|
*magick_restrict Cr;
|
|
|
|
|
|
ssize_t
|
|
|
x;
|
|
|
|
|
|
if (status == MagickFalse)
|
|
|
continue;
|
|
|
Ar=GetCacheViewVirtualPixels(Ar_view,0,y,columns,1,exception);
|
|
|
Ai=GetCacheViewVirtualPixels(Ai_view,0,y,columns,1,exception);
|
|
|
Br=GetCacheViewVirtualPixels(Br_view,0,y,columns,1,exception);
|
|
|
Bi=GetCacheViewVirtualPixels(Bi_view,0,y,columns,1,exception);
|
|
|
Cr=QueueCacheViewAuthenticPixels(Cr_view,0,y,columns,1,exception);
|
|
|
Ci=QueueCacheViewAuthenticPixels(Ci_view,0,y,columns,1,exception);
|
|
|
if ((Ar == (const Quantum *) NULL) || (Ai == (const Quantum *) NULL) ||
|
|
|
(Br == (const Quantum *) NULL) || (Bi == (const Quantum *) NULL) ||
|
|
|
(Cr == (Quantum *) NULL) || (Ci == (Quantum *) NULL))
|
|
|
{
|
|
|
status=MagickFalse;
|
|
|
continue;
|
|
|
}
|
|
|
for (x=0; x < (ssize_t) columns; x++)
|
|
|
{
|
|
|
ssize_t
|
|
|
i;
|
|
|
|
|
|
for (i=0; i < (ssize_t) number_channels; i++)
|
|
|
{
|
|
|
switch (op)
|
|
|
{
|
|
|
case AddComplexOperator:
|
|
|
{
|
|
|
Cr[i]=Ar[i]+Br[i];
|
|
|
Ci[i]=Ai[i]+Bi[i];
|
|
|
break;
|
|
|
}
|
|
|
case ConjugateComplexOperator:
|
|
|
default:
|
|
|
{
|
|
|
Cr[i]=Ar[i];
|
|
|
Ci[i]=(-Bi[i]);
|
|
|
break;
|
|
|
}
|
|
|
case DivideComplexOperator:
|
|
|
{
|
|
|
double
|
|
|
gamma;
|
|
|
|
|
|
gamma=QuantumRange*PerceptibleReciprocal(QuantumScale*Br[i]*Br[i]+
|
|
|
QuantumScale*Bi[i]*Bi[i]+snr);
|
|
|
Cr[i]=gamma*(QuantumScale*Ar[i]*Br[i]+QuantumScale*Ai[i]*Bi[i]);
|
|
|
Ci[i]=gamma*(QuantumScale*Ai[i]*Br[i]-QuantumScale*Ar[i]*Bi[i]);
|
|
|
break;
|
|
|
}
|
|
|
case MagnitudePhaseComplexOperator:
|
|
|
{
|
|
|
Cr[i]=sqrt(QuantumScale*Ar[i]*Ar[i]+QuantumScale*Ai[i]*Ai[i]);
|
|
|
Ci[i]=atan2((double) Ai[i],(double) Ar[i])/(2.0*MagickPI)+0.5;
|
|
|
break;
|
|
|
}
|
|
|
case MultiplyComplexOperator:
|
|
|
{
|
|
|
Cr[i]=(QuantumScale*Ar[i]*Br[i]-QuantumScale*Ai[i]*Bi[i]);
|
|
|
Ci[i]=(QuantumScale*Ai[i]*Br[i]+QuantumScale*Ar[i]*Bi[i]);
|
|
|
break;
|
|
|
}
|
|
|
case RealImaginaryComplexOperator:
|
|
|
{
|
|
|
Cr[i]=Ar[i]*cos(2.0*MagickPI*(Ai[i]-0.5));
|
|
|
Ci[i]=Ar[i]*sin(2.0*MagickPI*(Ai[i]-0.5));
|
|
|
break;
|
|
|
}
|
|
|
case SubtractComplexOperator:
|
|
|
{
|
|
|
Cr[i]=Ar[i]-Br[i];
|
|
|
Ci[i]=Ai[i]-Bi[i];
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
Ar+=GetPixelChannels(Ar_image);
|
|
|
Ai+=GetPixelChannels(Ai_image);
|
|
|
Br+=GetPixelChannels(Br_image);
|
|
|
Bi+=GetPixelChannels(Bi_image);
|
|
|
Cr+=GetPixelChannels(Cr_image);
|
|
|
Ci+=GetPixelChannels(Ci_image);
|
|
|
}
|
|
|
if (SyncCacheViewAuthenticPixels(Ci_view,exception) == MagickFalse)
|
|
|
status=MagickFalse;
|
|
|
if (SyncCacheViewAuthenticPixels(Cr_view,exception) == MagickFalse)
|
|
|
status=MagickFalse;
|
|
|
if (images->progress_monitor != (MagickProgressMonitor) NULL)
|
|
|
{
|
|
|
MagickBooleanType
|
|
|
proceed;
|
|
|
|
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT)
|
|
|
#pragma omp atomic
|
|
|
#endif
|
|
|
progress++;
|
|
|
proceed=SetImageProgress(images,ComplexImageTag,progress,images->rows);
|
|
|
if (proceed == MagickFalse)
|
|
|
status=MagickFalse;
|
|
|
}
|
|
|
}
|
|
|
Cr_view=DestroyCacheView(Cr_view);
|
|
|
Ci_view=DestroyCacheView(Ci_view);
|
|
|
Br_view=DestroyCacheView(Br_view);
|
|
|
Bi_view=DestroyCacheView(Bi_view);
|
|
|
Ar_view=DestroyCacheView(Ar_view);
|
|
|
Ai_view=DestroyCacheView(Ai_view);
|
|
|
if (status == MagickFalse)
|
|
|
complex_images=DestroyImageList(complex_images);
|
|
|
return(complex_images);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
% %
|
|
|
% %
|
|
|
% %
|
|
|
% F o r w a r d F o u r i e r T r a n s f o r m I m a g e %
|
|
|
% %
|
|
|
% %
|
|
|
% %
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
%
|
|
|
% ForwardFourierTransformImage() implements the discrete Fourier transform
|
|
|
% (DFT) of the image either as a magnitude / phase or real / imaginary image
|
|
|
% pair.
|
|
|
%
|
|
|
% The format of the ForwadFourierTransformImage method is:
|
|
|
%
|
|
|
% Image *ForwardFourierTransformImage(const Image *image,
|
|
|
% const MagickBooleanType modulus,ExceptionInfo *exception)
|
|
|
%
|
|
|
% A description of each parameter follows:
|
|
|
%
|
|
|
% o image: the image.
|
|
|
%
|
|
|
% o modulus: if true, return as transform as a magnitude / phase pair
|
|
|
% otherwise a real / imaginary image pair.
|
|
|
%
|
|
|
% o exception: return any errors or warnings in this structure.
|
|
|
%
|
|
|
*/
|
|
|
|
|
|
#if defined(MAGICKCORE_FFTW_DELEGATE)
|
|
|
|
|
|
static MagickBooleanType RollFourier(const size_t width,const size_t height,
|
|
|
const ssize_t x_offset,const ssize_t y_offset,double *roll_pixels)
|
|
|
{
|
|
|
double
|
|
|
*source_pixels;
|
|
|
|
|
|
MemoryInfo
|
|
|
*source_info;
|
|
|
|
|
|
ssize_t
|
|
|
i,
|
|
|
x;
|
|
|
|
|
|
ssize_t
|
|
|
u,
|
|
|
v,
|
|
|
y;
|
|
|
|
|
|
/*
|
|
|
Move zero frequency (DC, average color) from (0,0) to (width/2,height/2).
|
|
|
*/
|
|
|
source_info=AcquireVirtualMemory(width,height*sizeof(*source_pixels));
|
|
|
if (source_info == (MemoryInfo *) NULL)
|
|
|
return(MagickFalse);
|
|
|
source_pixels=(double *) GetVirtualMemoryBlob(source_info);
|
|
|
i=0L;
|
|
|
for (y=0L; y < (ssize_t) height; y++)
|
|
|
{
|
|
|
if (y_offset < 0L)
|
|
|
v=((y+y_offset) < 0L) ? y+y_offset+(ssize_t) height : y+y_offset;
|
|
|
else
|
|
|
v=((y+y_offset) > ((ssize_t) height-1L)) ? y+y_offset-(ssize_t) height :
|
|
|
y+y_offset;
|
|
|
for (x=0L; x < (ssize_t) width; x++)
|
|
|
{
|
|
|
if (x_offset < 0L)
|
|
|
u=((x+x_offset) < 0L) ? x+x_offset+(ssize_t) width : x+x_offset;
|
|
|
else
|
|
|
u=((x+x_offset) > ((ssize_t) width-1L)) ? x+x_offset-(ssize_t) width :
|
|
|
x+x_offset;
|
|
|
source_pixels[v*width+u]=roll_pixels[i++];
|
|
|
}
|
|
|
}
|
|
|
(void) memcpy(roll_pixels,source_pixels,height*width*
|
|
|
sizeof(*source_pixels));
|
|
|
source_info=RelinquishVirtualMemory(source_info);
|
|
|
return(MagickTrue);
|
|
|
}
|
|
|
|
|
|
static MagickBooleanType ForwardQuadrantSwap(const size_t width,
|
|
|
const size_t height,double *source_pixels,double *forward_pixels)
|
|
|
{
|
|
|
MagickBooleanType
|
|
|
status;
|
|
|
|
|
|
ssize_t
|
|
|
x;
|
|
|
|
|
|
ssize_t
|
|
|
center,
|
|
|
y;
|
|
|
|
|
|
/*
|
|
|
Swap quadrants.
|
|
|
*/
|
|
|
center=(ssize_t) (width/2L)+1L;
|
|
|
status=RollFourier((size_t) center,height,0L,(ssize_t) height/2L,
|
|
|
source_pixels);
|
|
|
if (status == MagickFalse)
|
|
|
return(MagickFalse);
|
|
|
for (y=0L; y < (ssize_t) height; y++)
|
|
|
for (x=0L; x < (ssize_t) (width/2L); x++)
|
|
|
forward_pixels[y*width+x+width/2L]=source_pixels[y*center+x];
|
|
|
for (y=1; y < (ssize_t) height; y++)
|
|
|
for (x=0L; x < (ssize_t) (width/2L); x++)
|
|
|
forward_pixels[(height-y)*width+width/2L-x-1L]=
|
|
|
source_pixels[y*center+x+1L];
|
|
|
for (x=0L; x < (ssize_t) (width/2L); x++)
|
|
|
forward_pixels[width/2L-x-1L]=source_pixels[x+1L];
|
|
|
return(MagickTrue);
|
|
|
}
|
|
|
|
|
|
static void CorrectPhaseLHS(const size_t width,const size_t height,
|
|
|
double *fourier_pixels)
|
|
|
{
|
|
|
ssize_t
|
|
|
x;
|
|
|
|
|
|
ssize_t
|
|
|
y;
|
|
|
|
|
|
for (y=0L; y < (ssize_t) height; y++)
|
|
|
for (x=0L; x < (ssize_t) (width/2L); x++)
|
|
|
fourier_pixels[y*width+x]*=(-1.0);
|
|
|
}
|
|
|
|
|
|
static MagickBooleanType ForwardFourier(const FourierInfo *fourier_info,
|
|
|
Image *image,double *magnitude,double *phase,ExceptionInfo *exception)
|
|
|
{
|
|
|
CacheView
|
|
|
*magnitude_view,
|
|
|
*phase_view;
|
|
|
|
|
|
double
|
|
|
*magnitude_pixels,
|
|
|
*phase_pixels;
|
|
|
|
|
|
Image
|
|
|
*magnitude_image,
|
|
|
*phase_image;
|
|
|
|
|
|
MagickBooleanType
|
|
|
status;
|
|
|
|
|
|
MemoryInfo
|
|
|
*magnitude_info,
|
|
|
*phase_info;
|
|
|
|
|
|
Quantum
|
|
|
*q;
|
|
|
|
|
|
ssize_t
|
|
|
x;
|
|
|
|
|
|
ssize_t
|
|
|
i,
|
|
|
y;
|
|
|
|
|
|
magnitude_image=GetFirstImageInList(image);
|
|
|
phase_image=GetNextImageInList(image);
|
|
|
if (phase_image == (Image *) NULL)
|
|
|
{
|
|
|
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
|
|
|
"ImageSequenceRequired","`%s'",image->filename);
|
|
|
return(MagickFalse);
|
|
|
}
|
|
|
/*
|
|
|
Create "Fourier Transform" image from constituent arrays.
|
|
|
*/
|
|
|
magnitude_info=AcquireVirtualMemory((size_t) fourier_info->width,
|
|
|
fourier_info->height*sizeof(*magnitude_pixels));
|
|
|
phase_info=AcquireVirtualMemory((size_t) fourier_info->width,
|
|
|
fourier_info->height*sizeof(*phase_pixels));
|
|
|
if ((magnitude_info == (MemoryInfo *) NULL) ||
|
|
|
(phase_info == (MemoryInfo *) NULL))
|
|
|
{
|
|
|
if (phase_info != (MemoryInfo *) NULL)
|
|
|
phase_info=RelinquishVirtualMemory(phase_info);
|
|
|
if (magnitude_info != (MemoryInfo *) NULL)
|
|
|
magnitude_info=RelinquishVirtualMemory(magnitude_info);
|
|
|
(void) ThrowMagickException(exception,GetMagickModule(),
|
|
|
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
|
|
|
return(MagickFalse);
|
|
|
}
|
|
|
magnitude_pixels=(double *) GetVirtualMemoryBlob(magnitude_info);
|
|
|
(void) memset(magnitude_pixels,0,fourier_info->width*
|
|
|
fourier_info->height*sizeof(*magnitude_pixels));
|
|
|
phase_pixels=(double *) GetVirtualMemoryBlob(phase_info);
|
|
|
(void) memset(phase_pixels,0,fourier_info->width*
|
|
|
fourier_info->height*sizeof(*phase_pixels));
|
|
|
status=ForwardQuadrantSwap(fourier_info->width,fourier_info->height,
|
|
|
magnitude,magnitude_pixels);
|
|
|
if (status != MagickFalse)
|
|
|
status=ForwardQuadrantSwap(fourier_info->width,fourier_info->height,phase,
|
|
|
phase_pixels);
|
|
|
CorrectPhaseLHS(fourier_info->width,fourier_info->height,phase_pixels);
|
|
|
if (fourier_info->modulus != MagickFalse)
|
|
|
{
|
|
|
i=0L;
|
|
|
for (y=0L; y < (ssize_t) fourier_info->height; y++)
|
|
|
for (x=0L; x < (ssize_t) fourier_info->width; x++)
|
|
|
{
|
|
|
phase_pixels[i]/=(2.0*MagickPI);
|
|
|
phase_pixels[i]+=0.5;
|
|
|
i++;
|
|
|
}
|
|
|
}
|
|
|
magnitude_view=AcquireAuthenticCacheView(magnitude_image,exception);
|
|
|
i=0L;
|
|
|
for (y=0L; y < (ssize_t) fourier_info->height; y++)
|
|
|
{
|
|
|
q=GetCacheViewAuthenticPixels(magnitude_view,0L,y,fourier_info->width,1UL,
|
|
|
exception);
|
|
|
if (q == (Quantum *) NULL)
|
|
|
break;
|
|
|
for (x=0L; x < (ssize_t) fourier_info->width; x++)
|
|
|
{
|
|
|
switch (fourier_info->channel)
|
|
|
{
|
|
|
case RedPixelChannel:
|
|
|
default:
|
|
|
{
|
|
|
SetPixelRed(magnitude_image,ClampToQuantum(QuantumRange*
|
|
|
magnitude_pixels[i]),q);
|
|
|
break;
|
|
|
}
|
|
|
case GreenPixelChannel:
|
|
|
{
|
|
|
SetPixelGreen(magnitude_image,ClampToQuantum(QuantumRange*
|
|
|
magnitude_pixels[i]),q);
|
|
|
break;
|
|
|
}
|
|
|
case BluePixelChannel:
|
|
|
{
|
|
|
SetPixelBlue(magnitude_image,ClampToQuantum(QuantumRange*
|
|
|
magnitude_pixels[i]),q);
|
|
|
break;
|
|
|
}
|
|
|
case BlackPixelChannel:
|
|
|
{
|
|
|
SetPixelBlack(magnitude_image,ClampToQuantum(QuantumRange*
|
|
|
magnitude_pixels[i]),q);
|
|
|
break;
|
|
|
}
|
|
|
case AlphaPixelChannel:
|
|
|
{
|
|
|
SetPixelAlpha(magnitude_image,ClampToQuantum(QuantumRange*
|
|
|
magnitude_pixels[i]),q);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
i++;
|
|
|
q+=GetPixelChannels(magnitude_image);
|
|
|
}
|
|
|
status=SyncCacheViewAuthenticPixels(magnitude_view,exception);
|
|
|
if (status == MagickFalse)
|
|
|
break;
|
|
|
}
|
|
|
magnitude_view=DestroyCacheView(magnitude_view);
|
|
|
i=0L;
|
|
|
phase_view=AcquireAuthenticCacheView(phase_image,exception);
|
|
|
for (y=0L; y < (ssize_t) fourier_info->height; y++)
|
|
|
{
|
|
|
q=GetCacheViewAuthenticPixels(phase_view,0L,y,fourier_info->width,1UL,
|
|
|
exception);
|
|
|
if (q == (Quantum *) NULL)
|
|
|
break;
|
|
|
for (x=0L; x < (ssize_t) fourier_info->width; x++)
|
|
|
{
|
|
|
switch (fourier_info->channel)
|
|
|
{
|
|
|
case RedPixelChannel:
|
|
|
default:
|
|
|
{
|
|
|
SetPixelRed(phase_image,ClampToQuantum(QuantumRange*
|
|
|
phase_pixels[i]),q);
|
|
|
break;
|
|
|
}
|
|
|
case GreenPixelChannel:
|
|
|
{
|
|
|
SetPixelGreen(phase_image,ClampToQuantum(QuantumRange*
|
|
|
phase_pixels[i]),q);
|
|
|
break;
|
|
|
}
|
|
|
case BluePixelChannel:
|
|
|
{
|
|
|
SetPixelBlue(phase_image,ClampToQuantum(QuantumRange*
|
|
|
phase_pixels[i]),q);
|
|
|
break;
|
|
|
}
|
|
|
case BlackPixelChannel:
|
|
|
{
|
|
|
SetPixelBlack(phase_image,ClampToQuantum(QuantumRange*
|
|
|
phase_pixels[i]),q);
|
|
|
break;
|
|
|
}
|
|
|
case AlphaPixelChannel:
|
|
|
{
|
|
|
SetPixelAlpha(phase_image,ClampToQuantum(QuantumRange*
|
|
|
phase_pixels[i]),q);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
i++;
|
|
|
q+=GetPixelChannels(phase_image);
|
|
|
}
|
|
|
status=SyncCacheViewAuthenticPixels(phase_view,exception);
|
|
|
if (status == MagickFalse)
|
|
|
break;
|
|
|
}
|
|
|
phase_view=DestroyCacheView(phase_view);
|
|
|
phase_info=RelinquishVirtualMemory(phase_info);
|
|
|
magnitude_info=RelinquishVirtualMemory(magnitude_info);
|
|
|
return(status);
|
|
|
}
|
|
|
|
|
|
static MagickBooleanType ForwardFourierTransform(FourierInfo *fourier_info,
|
|
|
const Image *image,double *magnitude_pixels,double *phase_pixels,
|
|
|
ExceptionInfo *exception)
|
|
|
{
|
|
|
CacheView
|
|
|
*image_view;
|
|
|
|
|
|
const char
|
|
|
*value;
|
|
|
|
|
|
double
|
|
|
*source_pixels;
|
|
|
|
|
|
fftw_complex
|
|
|
*forward_pixels;
|
|
|
|
|
|
fftw_plan
|
|
|
fftw_r2c_plan;
|
|
|
|
|
|
MemoryInfo
|
|
|
*forward_info,
|
|
|
*source_info;
|
|
|
|
|
|
const Quantum
|
|
|
*p;
|
|
|
|
|
|
ssize_t
|
|
|
i,
|
|
|
x;
|
|
|
|
|
|
ssize_t
|
|
|
y;
|
|
|
|
|
|
/*
|
|
|
Generate the forward Fourier transform.
|
|
|
*/
|
|
|
source_info=AcquireVirtualMemory((size_t) fourier_info->width,
|
|
|
fourier_info->height*sizeof(*source_pixels));
|
|
|
if (source_info == (MemoryInfo *) NULL)
|
|
|
{
|
|
|
(void) ThrowMagickException(exception,GetMagickModule(),
|
|
|
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
|
|
|
return(MagickFalse);
|
|
|
}
|
|
|
source_pixels=(double *) GetVirtualMemoryBlob(source_info);
|
|
|
memset(source_pixels,0,fourier_info->width*fourier_info->height*
|
|
|
sizeof(*source_pixels));
|
|
|
i=0L;
|
|
|
image_view=AcquireVirtualCacheView(image,exception);
|
|
|
for (y=0L; y < (ssize_t) fourier_info->height; y++)
|
|
|
{
|
|
|
p=GetCacheViewVirtualPixels(image_view,0L,y,fourier_info->width,1UL,
|
|
|
exception);
|
|
|
if (p == (const Quantum *) NULL)
|
|
|
break;
|
|
|
for (x=0L; x < (ssize_t) fourier_info->width; x++)
|
|
|
{
|
|
|
switch (fourier_info->channel)
|
|
|
{
|
|
|
case RedPixelChannel:
|
|
|
default:
|
|
|
{
|
|
|
source_pixels[i]=QuantumScale*GetPixelRed(image,p);
|
|
|
break;
|
|
|
}
|
|
|
case GreenPixelChannel:
|
|
|
{
|
|
|
source_pixels[i]=QuantumScale*GetPixelGreen(image,p);
|
|
|
break;
|
|
|
}
|
|
|
case BluePixelChannel:
|
|
|
{
|
|
|
source_pixels[i]=QuantumScale*GetPixelBlue(image,p);
|
|
|
break;
|
|
|
}
|
|
|
case BlackPixelChannel:
|
|
|
{
|
|
|
source_pixels[i]=QuantumScale*GetPixelBlack(image,p);
|
|
|
break;
|
|
|
}
|
|
|
case AlphaPixelChannel:
|
|
|
{
|
|
|
source_pixels[i]=QuantumScale*GetPixelAlpha(image,p);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
i++;
|
|
|
p+=GetPixelChannels(image);
|
|
|
}
|
|
|
}
|
|
|
image_view=DestroyCacheView(image_view);
|
|
|
forward_info=AcquireVirtualMemory((size_t) fourier_info->width,
|
|
|
(fourier_info->height/2+1)*sizeof(*forward_pixels));
|
|
|
if (forward_info == (MemoryInfo *) NULL)
|
|
|
{
|
|
|
(void) ThrowMagickException(exception,GetMagickModule(),
|
|
|
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
|
|
|
source_info=(MemoryInfo *) RelinquishVirtualMemory(source_info);
|
|
|
return(MagickFalse);
|
|
|
}
|
|
|
forward_pixels=(fftw_complex *) GetVirtualMemoryBlob(forward_info);
|
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT)
|
|
|
#pragma omp critical (MagickCore_ForwardFourierTransform)
|
|
|
#endif
|
|
|
fftw_r2c_plan=fftw_plan_dft_r2c_2d(fourier_info->width,fourier_info->height,
|
|
|
source_pixels,forward_pixels,FFTW_ESTIMATE);
|
|
|
fftw_execute_dft_r2c(fftw_r2c_plan,source_pixels,forward_pixels);
|
|
|
fftw_destroy_plan(fftw_r2c_plan);
|
|
|
source_info=(MemoryInfo *) RelinquishVirtualMemory(source_info);
|
|
|
value=GetImageArtifact(image,"fourier:normalize");
|
|
|
if ((value == (const char *) NULL) || (LocaleCompare(value,"forward") == 0))
|
|
|
{
|
|
|
double
|
|
|
gamma;
|
|
|
|
|
|
/*
|
|
|
Normalize forward transform.
|
|
|
*/
|
|
|
i=0L;
|
|
|
gamma=PerceptibleReciprocal((double) fourier_info->width*
|
|
|
fourier_info->height);
|
|
|
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)
|
|
|
forward_pixels[i]*=gamma;
|
|
|
#else
|
|
|
forward_pixels[i][0]*=gamma;
|
|
|
forward_pixels[i][1]*=gamma;
|
|
|
#endif
|
|
|
i++;
|
|
|
}
|
|
|
}
|
|
|
/*
|
|
|
Generate magnitude and phase (or real and imaginary).
|
|
|
*/
|
|
|
i=0L;
|
|
|
if (fourier_info->modulus != MagickFalse)
|
|
|
for (y=0L; y < (ssize_t) fourier_info->height; y++)
|
|
|
for (x=0L; x < (ssize_t) fourier_info->center; x++)
|
|
|
{
|
|
|
magnitude_pixels[i]=cabs(forward_pixels[i]);
|
|
|
phase_pixels[i]=carg(forward_pixels[i]);
|
|
|
i++;
|
|
|
}
|
|
|
else
|
|
|
for (y=0L; y < (ssize_t) fourier_info->height; y++)
|
|
|
for (x=0L; x < (ssize_t) fourier_info->center; x++)
|
|
|
{
|
|
|
magnitude_pixels[i]=creal(forward_pixels[i]);
|
|
|
phase_pixels[i]=cimag(forward_pixels[i]);
|
|
|
i++;
|
|
|
}
|
|
|
forward_info=(MemoryInfo *) RelinquishVirtualMemory(forward_info);
|
|
|
return(MagickTrue);
|
|
|
}
|
|
|
|
|
|
static MagickBooleanType ForwardFourierTransformChannel(const Image *image,
|
|
|
const PixelChannel channel,const MagickBooleanType modulus,
|
|
|
Image *fourier_image,ExceptionInfo *exception)
|
|
|
{
|
|
|
double
|
|
|
*magnitude_pixels,
|
|
|
*phase_pixels;
|
|
|
|
|
|
FourierInfo
|
|
|
fourier_info;
|
|
|
|
|
|
MagickBooleanType
|
|
|
status;
|
|
|
|
|
|
MemoryInfo
|
|
|
*magnitude_info,
|
|
|
*phase_info;
|
|
|
|
|
|
fourier_info.width=image->columns;
|
|
|
fourier_info.height=image->rows;
|
|
|
if ((image->columns != image->rows) || ((image->columns % 2) != 0) ||
|
|
|
((image->rows % 2) != 0))
|
|
|
{
|
|
|
size_t extent=image->columns < image->rows ? image->rows : image->columns;
|
|
|
fourier_info.width=(extent & 0x01) == 1 ? extent+1UL : extent;
|
|
|
}
|
|
|
fourier_info.height=fourier_info.width;
|
|
|
fourier_info.center=(ssize_t) (fourier_info.width/2L)+1L;
|
|
|
fourier_info.channel=channel;
|
|
|
fourier_info.modulus=modulus;
|
|
|
magnitude_info=AcquireVirtualMemory((size_t) fourier_info.width,
|
|
|
(fourier_info.height/2+1)*sizeof(*magnitude_pixels));
|
|
|
phase_info=AcquireVirtualMemory((size_t) fourier_info.width,
|
|
|
(fourier_info.height/2+1)*sizeof(*phase_pixels));
|
|
|
if ((magnitude_info == (MemoryInfo *) NULL) ||
|
|
|
(phase_info == (MemoryInfo *) NULL))
|
|
|
{
|
|
|
if (phase_info != (MemoryInfo *) NULL)
|
|
|
phase_info=RelinquishVirtualMemory(phase_info);
|
|
|
if (magnitude_info == (MemoryInfo *) NULL)
|
|
|
magnitude_info=RelinquishVirtualMemory(magnitude_info);
|
|
|
(void) ThrowMagickException(exception,GetMagickModule(),
|
|
|
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
|
|
|
return(MagickFalse);
|
|
|
}
|
|
|
magnitude_pixels=(double *) GetVirtualMemoryBlob(magnitude_info);
|
|
|
phase_pixels=(double *) GetVirtualMemoryBlob(phase_info);
|
|
|
status=ForwardFourierTransform(&fourier_info,image,magnitude_pixels,
|
|
|
phase_pixels,exception);
|
|
|
if (status != MagickFalse)
|
|
|
status=ForwardFourier(&fourier_info,fourier_image,magnitude_pixels,
|
|
|
phase_pixels,exception);
|
|
|
phase_info=RelinquishVirtualMemory(phase_info);
|
|
|
magnitude_info=RelinquishVirtualMemory(magnitude_info);
|
|
|
return(status);
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
MagickExport Image *ForwardFourierTransformImage(const Image *image,
|
|
|
const MagickBooleanType modulus,ExceptionInfo *exception)
|
|
|
{
|
|
|
Image
|
|
|
*fourier_image;
|
|
|
|
|
|
fourier_image=NewImageList();
|
|
|
#if !defined(MAGICKCORE_FFTW_DELEGATE)
|
|
|
(void) modulus;
|
|
|
(void) ThrowMagickException(exception,GetMagickModule(),
|
|
|
MissingDelegateWarning,"DelegateLibrarySupportNotBuiltIn","`%s' (FFTW)",
|
|
|
image->filename);
|
|
|
#else
|
|
|
{
|
|
|
Image
|
|
|
*magnitude_image;
|
|
|
|
|
|
size_t
|
|
|
height,
|
|
|
width;
|
|
|
|
|
|
width=image->columns;
|
|
|
height=image->rows;
|
|
|
if ((image->columns != image->rows) || ((image->columns % 2) != 0) ||
|
|
|
((image->rows % 2) != 0))
|
|
|
{
|
|
|
size_t extent=image->columns < image->rows ? image->rows :
|
|
|
image->columns;
|
|
|
width=(extent & 0x01) == 1 ? extent+1UL : extent;
|
|
|
}
|
|
|
height=width;
|
|
|
magnitude_image=CloneImage(image,width,height,MagickTrue,exception);
|
|
|
if (magnitude_image != (Image *) NULL)
|
|
|
{
|
|
|
Image
|
|
|
*phase_image;
|
|
|
|
|
|
magnitude_image->storage_class=DirectClass;
|
|
|
magnitude_image->depth=32UL;
|
|
|
phase_image=CloneImage(image,width,height,MagickTrue,exception);
|
|
|
if (phase_image == (Image *) NULL)
|
|
|
magnitude_image=DestroyImage(magnitude_image);
|
|
|
else
|
|
|
{
|
|
|
MagickBooleanType
|
|
|
is_gray,
|
|
|
status;
|
|
|
|
|
|
phase_image->storage_class=DirectClass;
|
|
|
phase_image->depth=32UL;
|
|
|
AppendImageToList(&fourier_image,magnitude_image);
|
|
|
AppendImageToList(&fourier_image,phase_image);
|
|
|
status=MagickTrue;
|
|
|
is_gray=IsImageGray(image);
|
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT)
|
|
|
#pragma omp parallel sections
|
|
|
#endif
|
|
|
{
|
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT)
|
|
|
#pragma omp section
|
|
|
#endif
|
|
|
{
|
|
|
MagickBooleanType
|
|
|
thread_status;
|
|
|
|
|
|
if (is_gray != MagickFalse)
|
|
|
thread_status=ForwardFourierTransformChannel(image,
|
|
|
GrayPixelChannel,modulus,fourier_image,exception);
|
|
|
else
|
|
|
thread_status=ForwardFourierTransformChannel(image,
|
|
|
RedPixelChannel,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,
|
|
|
GreenPixelChannel,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,
|
|
|
BluePixelChannel,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,
|
|
|
BlackPixelChannel,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->alpha_trait != UndefinedPixelTrait)
|
|
|
thread_status=ForwardFourierTransformChannel(image,
|
|
|
AlphaPixelChannel,modulus,fourier_image,exception);
|
|
|
if (thread_status == MagickFalse)
|
|
|
status=thread_status;
|
|
|
}
|
|
|
}
|
|
|
if (status == MagickFalse)
|
|
|
fourier_image=DestroyImageList(fourier_image);
|
|
|
fftw_cleanup();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
#endif
|
|
|
return(fourier_image);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
% %
|
|
|
% %
|
|
|
% %
|
|
|
% I n v e r s e F o u r i e r T r a n s f o r m I m a g e %
|
|
|
% %
|
|
|
% %
|
|
|
% %
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
%
|
|
|
% InverseFourierTransformImage() implements the inverse discrete Fourier
|
|
|
% transform (DFT) of the image either as a magnitude / phase or real /
|
|
|
% imaginary image pair.
|
|
|
%
|
|
|
% The format of the InverseFourierTransformImage method is:
|
|
|
%
|
|
|
% Image *InverseFourierTransformImage(const Image *magnitude_image,
|
|
|
% const Image *phase_image,const MagickBooleanType modulus,
|
|
|
% ExceptionInfo *exception)
|
|
|
%
|
|
|
% A description of each parameter follows:
|
|
|
%
|
|
|
% o magnitude_image: the magnitude or real image.
|
|
|
%
|
|
|
% o phase_image: the phase or imaginary image.
|
|
|
%
|
|
|
% o modulus: if true, return transform as a magnitude / phase pair
|
|
|
% otherwise a real / imaginary image pair.
|
|
|
%
|
|
|
% o exception: return any errors or warnings in this structure.
|
|
|
%
|
|
|
*/
|
|
|
|
|
|
#if defined(MAGICKCORE_FFTW_DELEGATE)
|
|
|
static MagickBooleanType InverseQuadrantSwap(const size_t width,
|
|
|
const size_t height,const double *source,double *destination)
|
|
|
{
|
|
|
ssize_t
|
|
|
x;
|
|
|
|
|
|
ssize_t
|
|
|
center,
|
|
|
y;
|
|
|
|
|
|
/*
|
|
|
Swap quadrants.
|
|
|
*/
|
|
|
center=(ssize_t) (width/2L)+1L;
|
|
|
for (y=1L; y < (ssize_t) height; y++)
|
|
|
for (x=0L; x < (ssize_t) (width/2L+1L); x++)
|
|
|
destination[(height-y)*center-x+width/2L]=source[y*width+x];
|
|
|
for (y=0L; y < (ssize_t) height; y++)
|
|
|
destination[y*center]=source[y*width+width/2L];
|
|
|
for (x=0L; x < center; x++)
|
|
|
destination[x]=source[center-x-1L];
|
|
|
return(RollFourier(center,height,0L,(ssize_t) height/-2L,destination));
|
|
|
}
|
|
|
|
|
|
static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
|
|
|
const Image *magnitude_image,const Image *phase_image,
|
|
|
fftw_complex *fourier_pixels,ExceptionInfo *exception)
|
|
|
{
|
|
|
CacheView
|
|
|
*magnitude_view,
|
|
|
*phase_view;
|
|
|
|
|
|
double
|
|
|
*inverse_pixels,
|
|
|
*magnitude_pixels,
|
|
|
*phase_pixels;
|
|
|
|
|
|
MagickBooleanType
|
|
|
status;
|
|
|
|
|
|
MemoryInfo
|
|
|
*inverse_info,
|
|
|
*magnitude_info,
|
|
|
*phase_info;
|
|
|
|
|
|
const Quantum
|
|
|
*p;
|
|
|
|
|
|
ssize_t
|
|
|
i,
|
|
|
x;
|
|
|
|
|
|
ssize_t
|
|
|
y;
|
|
|
|
|
|
/*
|
|
|
Inverse fourier - read image and break down into a double array.
|
|
|
*/
|
|
|
magnitude_info=AcquireVirtualMemory((size_t) fourier_info->width,
|
|
|
fourier_info->height*sizeof(*magnitude_pixels));
|
|
|
phase_info=AcquireVirtualMemory((size_t) fourier_info->width,
|
|
|
fourier_info->height*sizeof(*phase_pixels));
|
|
|
inverse_info=AcquireVirtualMemory((size_t) fourier_info->width,
|
|
|
(fourier_info->height/2+1)*sizeof(*inverse_pixels));
|
|
|
if ((magnitude_info == (MemoryInfo *) NULL) ||
|
|
|
(phase_info == (MemoryInfo *) NULL) ||
|
|
|
(inverse_info == (MemoryInfo *) NULL))
|
|
|
{
|
|
|
if (magnitude_info != (MemoryInfo *) NULL)
|
|
|
magnitude_info=RelinquishVirtualMemory(magnitude_info);
|
|
|
if (phase_info != (MemoryInfo *) NULL)
|
|
|
phase_info=RelinquishVirtualMemory(phase_info);
|
|
|
if (inverse_info != (MemoryInfo *) NULL)
|
|
|
inverse_info=RelinquishVirtualMemory(inverse_info);
|
|
|
(void) ThrowMagickException(exception,GetMagickModule(),
|
|
|
ResourceLimitError,"MemoryAllocationFailed","`%s'",
|
|
|
magnitude_image->filename);
|
|
|
return(MagickFalse);
|
|
|
}
|
|
|
magnitude_pixels=(double *) GetVirtualMemoryBlob(magnitude_info);
|
|
|
phase_pixels=(double *) GetVirtualMemoryBlob(phase_info);
|
|
|
inverse_pixels=(double *) GetVirtualMemoryBlob(inverse_info);
|
|
|
i=0L;
|
|
|
magnitude_view=AcquireVirtualCacheView(magnitude_image,exception);
|
|
|
for (y=0L; y < (ssize_t) fourier_info->height; y++)
|
|
|
{
|
|
|
p=GetCacheViewVirtualPixels(magnitude_view,0L,y,fourier_info->width,1UL,
|
|
|
exception);
|
|
|
if (p == (const Quantum *) NULL)
|
|
|
break;
|
|
|
for (x=0L; x < (ssize_t) fourier_info->width; x++)
|
|
|
{
|
|
|
switch (fourier_info->channel)
|
|
|
{
|
|
|
case RedPixelChannel:
|
|
|
default:
|
|
|
{
|
|
|
magnitude_pixels[i]=QuantumScale*GetPixelRed(magnitude_image,p);
|
|
|
break;
|
|
|
}
|
|
|
case GreenPixelChannel:
|
|
|
{
|
|
|
magnitude_pixels[i]=QuantumScale*GetPixelGreen(magnitude_image,p);
|
|
|
break;
|
|
|
}
|
|
|
case BluePixelChannel:
|
|
|
{
|
|
|
magnitude_pixels[i]=QuantumScale*GetPixelBlue(magnitude_image,p);
|
|
|
break;
|
|
|
}
|
|
|
case BlackPixelChannel:
|
|
|
{
|
|
|
magnitude_pixels[i]=QuantumScale*GetPixelBlack(magnitude_image,p);
|
|
|
break;
|
|
|
}
|
|
|
case AlphaPixelChannel:
|
|
|
{
|
|
|
magnitude_pixels[i]=QuantumScale*GetPixelAlpha(magnitude_image,p);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
i++;
|
|
|
p+=GetPixelChannels(magnitude_image);
|
|
|
}
|
|
|
}
|
|
|
magnitude_view=DestroyCacheView(magnitude_view);
|
|
|
status=InverseQuadrantSwap(fourier_info->width,fourier_info->height,
|
|
|
magnitude_pixels,inverse_pixels);
|
|
|
(void) memcpy(magnitude_pixels,inverse_pixels,fourier_info->height*
|
|
|
fourier_info->center*sizeof(*magnitude_pixels));
|
|
|
i=0L;
|
|
|
phase_view=AcquireVirtualCacheView(phase_image,exception);
|
|
|
for (y=0L; y < (ssize_t) fourier_info->height; y++)
|
|
|
{
|
|
|
p=GetCacheViewVirtualPixels(phase_view,0,y,fourier_info->width,1,
|
|
|
exception);
|
|
|
if (p == (const Quantum *) NULL)
|
|
|
break;
|
|
|
for (x=0L; x < (ssize_t) fourier_info->width; x++)
|
|
|
{
|
|
|
switch (fourier_info->channel)
|
|
|
{
|
|
|
case RedPixelChannel:
|
|
|
default:
|
|
|
{
|
|
|
phase_pixels[i]=QuantumScale*GetPixelRed(phase_image,p);
|
|
|
break;
|
|
|
}
|
|
|
case GreenPixelChannel:
|
|
|
{
|
|
|
phase_pixels[i]=QuantumScale*GetPixelGreen(phase_image,p);
|
|
|
break;
|
|
|
}
|
|
|
case BluePixelChannel:
|
|
|
{
|
|
|
phase_pixels[i]=QuantumScale*GetPixelBlue(phase_image,p);
|
|
|
break;
|
|
|
}
|
|
|
case BlackPixelChannel:
|
|
|
{
|
|
|
phase_pixels[i]=QuantumScale*GetPixelBlack(phase_image,p);
|
|
|
break;
|
|
|
}
|
|
|
case AlphaPixelChannel:
|
|
|
{
|
|
|
phase_pixels[i]=QuantumScale*GetPixelAlpha(phase_image,p);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
i++;
|
|
|
p+=GetPixelChannels(phase_image);
|
|
|
}
|
|
|
}
|
|
|
if (fourier_info->modulus != MagickFalse)
|
|
|
{
|
|
|
i=0L;
|
|
|
for (y=0L; y < (ssize_t) fourier_info->height; y++)
|
|
|
for (x=0L; x < (ssize_t) fourier_info->width; x++)
|
|
|
{
|
|
|
phase_pixels[i]-=0.5;
|
|
|
phase_pixels[i]*=(2.0*MagickPI);
|
|
|
i++;
|
|
|
}
|
|
|
}
|
|
|
phase_view=DestroyCacheView(phase_view);
|
|
|
CorrectPhaseLHS(fourier_info->width,fourier_info->height,phase_pixels);
|
|
|
if (status != MagickFalse)
|
|
|
status=InverseQuadrantSwap(fourier_info->width,fourier_info->height,
|
|
|
phase_pixels,inverse_pixels);
|
|
|
(void) memcpy(phase_pixels,inverse_pixels,fourier_info->height*
|
|
|
fourier_info->center*sizeof(*phase_pixels));
|
|
|
inverse_info=RelinquishVirtualMemory(inverse_info);
|
|
|
/*
|
|
|
Merge two sets.
|
|
|
*/
|
|
|
i=0L;
|
|
|
if (fourier_info->modulus != MagickFalse)
|
|
|
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_pixels[i]=magnitude_pixels[i]*cos(phase_pixels[i])+I*
|
|
|
magnitude_pixels[i]*sin(phase_pixels[i]);
|
|
|
#else
|
|
|
fourier_pixels[i][0]=magnitude_pixels[i]*cos(phase_pixels[i]);
|
|
|
fourier_pixels[i][1]=magnitude_pixels[i]*sin(phase_pixels[i]);
|
|
|
#endif
|
|
|
i++;
|
|
|
}
|
|
|
else
|
|
|
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_pixels[i]=magnitude_pixels[i]+I*phase_pixels[i];
|
|
|
#else
|
|
|
fourier_pixels[i][0]=magnitude_pixels[i];
|
|
|
fourier_pixels[i][1]=phase_pixels[i];
|
|
|
#endif
|
|
|
i++;
|
|
|
}
|
|
|
magnitude_info=RelinquishVirtualMemory(magnitude_info);
|
|
|
phase_info=RelinquishVirtualMemory(phase_info);
|
|
|
return(status);
|
|
|
}
|
|
|
|
|
|
static MagickBooleanType InverseFourierTransform(FourierInfo *fourier_info,
|
|
|
fftw_complex *fourier_pixels,Image *image,ExceptionInfo *exception)
|
|
|
{
|
|
|
CacheView
|
|
|
*image_view;
|
|
|
|
|
|
const char
|
|
|
*value;
|
|
|
|
|
|
double
|
|
|
*source_pixels;
|
|
|
|
|
|
fftw_plan
|
|
|
fftw_c2r_plan;
|
|
|
|
|
|
MemoryInfo
|
|
|
*source_info;
|
|
|
|
|
|
Quantum
|
|
|
*q;
|
|
|
|
|
|
ssize_t
|
|
|
i,
|
|
|
x;
|
|
|
|
|
|
ssize_t
|
|
|
y;
|
|
|
|
|
|
source_info=AcquireVirtualMemory((size_t) fourier_info->width,
|
|
|
fourier_info->height*sizeof(*source_pixels));
|
|
|
if (source_info == (MemoryInfo *) NULL)
|
|
|
{
|
|
|
(void) ThrowMagickException(exception,GetMagickModule(),
|
|
|
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
|
|
|
return(MagickFalse);
|
|
|
}
|
|
|
source_pixels=(double *) GetVirtualMemoryBlob(source_info);
|
|
|
value=GetImageArtifact(image,"fourier:normalize");
|
|
|
if (LocaleCompare(value,"inverse") == 0)
|
|
|
{
|
|
|
double
|
|
|
gamma;
|
|
|
|
|
|
/*
|
|
|
Normalize inverse transform.
|
|
|
*/
|
|
|
i=0L;
|
|
|
gamma=PerceptibleReciprocal((double) fourier_info->width*
|
|
|
fourier_info->height);
|
|
|
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_pixels[i]*=gamma;
|
|
|
#else
|
|
|
fourier_pixels[i][0]*=gamma;
|
|
|
fourier_pixels[i][1]*=gamma;
|
|
|
#endif
|
|
|
i++;
|
|
|
}
|
|
|
}
|
|
|
#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_pixels,source_pixels,FFTW_ESTIMATE);
|
|
|
fftw_execute_dft_c2r(fftw_c2r_plan,fourier_pixels,source_pixels);
|
|
|
fftw_destroy_plan(fftw_c2r_plan);
|
|
|
i=0L;
|
|
|
image_view=AcquireAuthenticCacheView(image,exception);
|
|
|
for (y=0L; y < (ssize_t) fourier_info->height; y++)
|
|
|
{
|
|
|
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 == (Quantum *) NULL)
|
|
|
break;
|
|
|
for (x=0L; x < (ssize_t) fourier_info->width; x++)
|
|
|
{
|
|
|
if (x < (ssize_t) image->columns)
|
|
|
switch (fourier_info->channel)
|
|
|
{
|
|
|
case RedPixelChannel:
|
|
|
default:
|
|
|
{
|
|
|
SetPixelRed(image,ClampToQuantum(QuantumRange*source_pixels[i]),q);
|
|
|
break;
|
|
|
}
|
|
|
case GreenPixelChannel:
|
|
|
{
|
|
|
SetPixelGreen(image,ClampToQuantum(QuantumRange*source_pixels[i]),
|
|
|
q);
|
|
|
break;
|
|
|
}
|
|
|
case BluePixelChannel:
|
|
|
{
|
|
|
SetPixelBlue(image,ClampToQuantum(QuantumRange*source_pixels[i]),
|
|
|
q);
|
|
|
break;
|
|
|
}
|
|
|
case BlackPixelChannel:
|
|
|
{
|
|
|
SetPixelBlack(image,ClampToQuantum(QuantumRange*source_pixels[i]),
|
|
|
q);
|
|
|
break;
|
|
|
}
|
|
|
case AlphaPixelChannel:
|
|
|
{
|
|
|
SetPixelAlpha(image,ClampToQuantum(QuantumRange*source_pixels[i]),
|
|
|
q);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
i++;
|
|
|
q+=GetPixelChannels(image);
|
|
|
}
|
|
|
if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
|
|
|
break;
|
|
|
}
|
|
|
image_view=DestroyCacheView(image_view);
|
|
|
source_info=RelinquishVirtualMemory(source_info);
|
|
|
return(MagickTrue);
|
|
|
}
|
|
|
|
|
|
static MagickBooleanType InverseFourierTransformChannel(
|
|
|
const Image *magnitude_image,const Image *phase_image,
|
|
|
const PixelChannel channel,const MagickBooleanType modulus,
|
|
|
Image *fourier_image,ExceptionInfo *exception)
|
|
|
{
|
|
|
fftw_complex
|
|
|
*inverse_pixels;
|
|
|
|
|
|
FourierInfo
|
|
|
fourier_info;
|
|
|
|
|
|
MagickBooleanType
|
|
|
status;
|
|
|
|
|
|
MemoryInfo
|
|
|
*inverse_info;
|
|
|
|
|
|
fourier_info.width=magnitude_image->columns;
|
|
|
fourier_info.height=magnitude_image->rows;
|
|
|
if ((magnitude_image->columns != magnitude_image->rows) ||
|
|
|
((magnitude_image->columns % 2) != 0) ||
|
|
|
((magnitude_image->rows % 2) != 0))
|
|
|
{
|
|
|
size_t extent=magnitude_image->columns < magnitude_image->rows ?
|
|
|
magnitude_image->rows : magnitude_image->columns;
|
|
|
fourier_info.width=(extent & 0x01) == 1 ? extent+1UL : extent;
|
|
|
}
|
|
|
fourier_info.height=fourier_info.width;
|
|
|
fourier_info.center=(ssize_t) (fourier_info.width/2L)+1L;
|
|
|
fourier_info.channel=channel;
|
|
|
fourier_info.modulus=modulus;
|
|
|
inverse_info=AcquireVirtualMemory((size_t) fourier_info.width,
|
|
|
(fourier_info.height/2+1)*sizeof(*inverse_pixels));
|
|
|
if (inverse_info == (MemoryInfo *) NULL)
|
|
|
{
|
|
|
(void) ThrowMagickException(exception,GetMagickModule(),
|
|
|
ResourceLimitError,"MemoryAllocationFailed","`%s'",
|
|
|
magnitude_image->filename);
|
|
|
return(MagickFalse);
|
|
|
}
|
|
|
inverse_pixels=(fftw_complex *) GetVirtualMemoryBlob(inverse_info);
|
|
|
status=InverseFourier(&fourier_info,magnitude_image,phase_image,
|
|
|
inverse_pixels,exception);
|
|
|
if (status != MagickFalse)
|
|
|
status=InverseFourierTransform(&fourier_info,inverse_pixels,fourier_image,
|
|
|
exception);
|
|
|
inverse_info=RelinquishVirtualMemory(inverse_info);
|
|
|
return(status);
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
MagickExport Image *InverseFourierTransformImage(const Image *magnitude_image,
|
|
|
const Image *phase_image,const MagickBooleanType modulus,
|
|
|
ExceptionInfo *exception)
|
|
|
{
|
|
|
Image
|
|
|
*fourier_image;
|
|
|
|
|
|
assert(magnitude_image != (Image *) NULL);
|
|
|
assert(magnitude_image->signature == MagickCoreSignature);
|
|
|
if (magnitude_image->debug != MagickFalse)
|
|
|
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
|
|
|
magnitude_image->filename);
|
|
|
if (phase_image == (Image *) NULL)
|
|
|
{
|
|
|
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
|
|
|
"ImageSequenceRequired","`%s'",magnitude_image->filename);
|
|
|
return((Image *) NULL);
|
|
|
}
|
|
|
#if !defined(MAGICKCORE_FFTW_DELEGATE)
|
|
|
fourier_image=(Image *) NULL;
|
|
|
(void) modulus;
|
|
|
(void) ThrowMagickException(exception,GetMagickModule(),
|
|
|
MissingDelegateWarning,"DelegateLibrarySupportNotBuiltIn","`%s' (FFTW)",
|
|
|
magnitude_image->filename);
|
|
|
#else
|
|
|
{
|
|
|
fourier_image=CloneImage(magnitude_image,magnitude_image->columns,
|
|
|
magnitude_image->rows,MagickTrue,exception);
|
|
|
if (fourier_image != (Image *) NULL)
|
|
|
{
|
|
|
MagickBooleanType
|
|
|
is_gray,
|
|
|
status;
|
|
|
|
|
|
status=MagickTrue;
|
|
|
is_gray=IsImageGray(magnitude_image);
|
|
|
if (is_gray != MagickFalse)
|
|
|
is_gray=IsImageGray(phase_image);
|
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT)
|
|
|
#pragma omp parallel sections
|
|
|
#endif
|
|
|
{
|
|
|
#if defined(MAGICKCORE_OPENMP_SUPPORT)
|
|
|
#pragma omp section
|
|
|
#endif
|
|
|
{
|
|
|
MagickBooleanType
|
|
|
thread_status;
|
|
|
|
|
|
if (is_gray != MagickFalse)
|
|
|
thread_status=InverseFourierTransformChannel(magnitude_image,
|
|
|
phase_image,GrayPixelChannel,modulus,fourier_image,exception);
|
|
|
else
|
|
|
thread_status=InverseFourierTransformChannel(magnitude_image,
|
|
|
phase_image,RedPixelChannel,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,GreenPixelChannel,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,BluePixelChannel,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,BlackPixelChannel,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->alpha_trait != UndefinedPixelTrait)
|
|
|
thread_status=InverseFourierTransformChannel(magnitude_image,
|
|
|
phase_image,AlphaPixelChannel,modulus,fourier_image,exception);
|
|
|
if (thread_status == MagickFalse)
|
|
|
status=thread_status;
|
|
|
}
|
|
|
}
|
|
|
if (status == MagickFalse)
|
|
|
fourier_image=DestroyImage(fourier_image);
|
|
|
}
|
|
|
fftw_cleanup();
|
|
|
}
|
|
|
#endif
|
|
|
return(fourier_image);
|
|
|
}
|
