45#include "MagickCore/studio.h"
46#include "MagickCore/artifact.h"
47#include "MagickCore/attribute.h"
48#include "MagickCore/blob.h"
49#include "MagickCore/cache.h"
50#include "MagickCore/image.h"
51#include "MagickCore/image-private.h"
52#include "MagickCore/list.h"
53#include "MagickCore/fourier.h"
54#include "MagickCore/log.h"
55#include "MagickCore/memory_.h"
56#include "MagickCore/monitor.h"
57#include "MagickCore/monitor-private.h"
58#include "MagickCore/pixel-accessor.h"
59#include "MagickCore/property.h"
60#include "MagickCore/quantum-private.h"
61#include "MagickCore/resource_.h"
62#include "MagickCore/string-private.h"
63#include "MagickCore/thread-private.h"
64#if defined(MAGICKCORE_FFTW_DELEGATE)
66#define ENABLE_FFTW_DELEGATE
67#elif !defined(__cplusplus) && !defined(c_plusplus)
68#define ENABLE_FFTW_DELEGATE
71#if defined(ENABLE_FFTW_DELEGATE)
72#if defined(MAGICKCORE_HAVE_COMPLEX_H)
76#if !defined(MAGICKCORE_HAVE_CABS)
77#define cabs(z) (sqrt(z[0]*z[0]+z[1]*z[1]))
79#if !defined(MAGICKCORE_HAVE_CARG)
80#define carg(z) (atan2(cimag(z),creal(z)))
82#if !defined(MAGICKCORE_HAVE_CIMAG)
83#define cimag(z) (z[1])
85#if !defined(MAGICKCORE_HAVE_CREAL)
86#define creal(z) (z[0])
134MagickExport Image *ComplexImages(
const Image *images,
const ComplexOperator op,
135 ExceptionInfo *exception)
137#define ComplexImageTag "Complex/Image"
179 assert(images != (Image *) NULL);
180 assert(images->signature == MagickCoreSignature);
181 assert(exception != (ExceptionInfo *) NULL);
182 assert(exception->signature == MagickCoreSignature);
183 if (IsEventLogging() != MagickFalse)
184 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",images->filename);
185 if (images->next == (Image *) NULL)
187 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
188 "ImageSequenceRequired",
"`%s'",images->filename);
189 return((Image *) NULL);
191 image=CloneImage(images,0,0,MagickTrue,exception);
192 if (image == (Image *) NULL)
193 return((Image *) NULL);
194 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
196 image=DestroyImageList(image);
200 complex_images=NewImageList();
201 AppendImageToList(&complex_images,image);
202 image=CloneImage(images->next,0,0,MagickTrue,exception);
203 if (image == (Image *) NULL)
205 complex_images=DestroyImageList(complex_images);
206 return(complex_images);
209 AppendImageToList(&complex_images,image);
210 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
212 complex_images=DestroyImageList(complex_images);
213 return(complex_images);
218 artifact=GetImageArtifact(images,
"complex:snr");
220 if (artifact != (
const char *) NULL)
221 snr=StringToDouble(artifact,(
char **) NULL);
223 Ai_image=images->next;
225 Bi_image=images->next;
226 if ((images->next->next != (Image *) NULL) &&
227 (images->next->next->next != (Image *) NULL))
229 Br_image=images->next->next;
230 Bi_image=images->next->next->next;
232 Cr_image=complex_images;
233 Ci_image=complex_images->next;
234 number_channels=MagickMin(MagickMin(MagickMin(
235 Ar_image->number_channels,Ai_image->number_channels),MagickMin(
236 Br_image->number_channels,Bi_image->number_channels)),MagickMin(
237 Cr_image->number_channels,Ci_image->number_channels));
238 Ar_view=AcquireVirtualCacheView(Ar_image,exception);
239 Ai_view=AcquireVirtualCacheView(Ai_image,exception);
240 Br_view=AcquireVirtualCacheView(Br_image,exception);
241 Bi_view=AcquireVirtualCacheView(Bi_image,exception);
242 Cr_view=AcquireAuthenticCacheView(Cr_image,exception);
243 Ci_view=AcquireAuthenticCacheView(Ci_image,exception);
246 columns=MagickMin(Cr_image->columns,Ci_image->columns);
247 rows=MagickMin(Cr_image->rows,Ci_image->rows);
248#if defined(MAGICKCORE_OPENMP_SUPPORT)
249 #pragma omp parallel for schedule(static) shared(progress,status) \
250 magick_number_threads(Cr_image,complex_images,rows,1L)
252 for (y=0; y < (ssize_t) rows; y++)
267 if (status == MagickFalse)
269 Ar=GetCacheViewVirtualPixels(Ar_view,0,y,columns,1,exception);
270 Ai=GetCacheViewVirtualPixels(Ai_view,0,y,columns,1,exception);
271 Br=GetCacheViewVirtualPixels(Br_view,0,y,columns,1,exception);
272 Bi=GetCacheViewVirtualPixels(Bi_view,0,y,columns,1,exception);
273 Cr=QueueCacheViewAuthenticPixels(Cr_view,0,y,columns,1,exception);
274 Ci=QueueCacheViewAuthenticPixels(Ci_view,0,y,columns,1,exception);
275 if ((Ar == (
const Quantum *) NULL) || (Ai == (
const Quantum *) NULL) ||
276 (Br == (
const Quantum *) NULL) || (Bi == (
const Quantum *) NULL) ||
277 (Cr == (Quantum *) NULL) || (Ci == (Quantum *) NULL))
282 for (x=0; x < (ssize_t) columns; x++)
287 for (i=0; i < (ssize_t) number_channels; i++)
290 ai = QuantumScale*(double) Ai[i],
291 ar = QuantumScale*(
double) Ar[i],
292 bi = QuantumScale*(double) Bi[i],
293 br = QuantumScale*(
double) Br[i],
299 case AddComplexOperator:
305 case ConjugateComplexOperator:
312 case DivideComplexOperator:
314 cr=MagickSafeReciprocal(br*br+bi*bi+snr)*(ar*br+ai*bi);
315 ci=MagickSafeReciprocal(br*br+bi*bi+snr)*(ai*br-ar*bi);
318 case MagnitudePhaseComplexOperator:
320 cr=sqrt(ar*ar+ai*ai);
321 ci=atan2((
double) ai,(
double) ar)/(2.0*MagickPI)+0.5;
324 case MultiplyComplexOperator:
330 case RealImaginaryComplexOperator:
332 cr=ar*cos(2.0*MagickPI*(ai-0.5));
333 ci=ar*sin(2.0*MagickPI*(ai-0.5));
336 case SubtractComplexOperator:
343 Cr[i]=ClampToQuantum((
double) QuantumRange*cr);
344 Ci[i]=ClampToQuantum((
double) QuantumRange*ci);
346 Ar+=(ptrdiff_t) GetPixelChannels(Ar_image);
347 Ai+=(ptrdiff_t) GetPixelChannels(Ai_image);
348 Br+=(ptrdiff_t) GetPixelChannels(Br_image);
349 Bi+=(ptrdiff_t) GetPixelChannels(Bi_image);
350 Cr+=(ptrdiff_t) GetPixelChannels(Cr_image);
351 Ci+=(ptrdiff_t) GetPixelChannels(Ci_image);
353 if (SyncCacheViewAuthenticPixels(Ci_view,exception) == MagickFalse)
355 if (SyncCacheViewAuthenticPixels(Cr_view,exception) == MagickFalse)
357 if (images->progress_monitor != (MagickProgressMonitor) NULL)
362#if defined(MAGICKCORE_OPENMP_SUPPORT)
366 proceed=SetImageProgress(images,ComplexImageTag,progress,images->rows);
367 if (proceed == MagickFalse)
371 Cr_view=DestroyCacheView(Cr_view);
372 Ci_view=DestroyCacheView(Ci_view);
373 Br_view=DestroyCacheView(Br_view);
374 Bi_view=DestroyCacheView(Bi_view);
375 Ar_view=DestroyCacheView(Ar_view);
376 Ai_view=DestroyCacheView(Ai_view);
377 if (status == MagickFalse)
378 complex_images=DestroyImageList(complex_images);
379 return(complex_images);
413#if defined(ENABLE_FFTW_DELEGATE)
415static MagickBooleanType ForwardQuadrantSwap(
const size_t width,
416 const size_t height,
const MagickBooleanType conjugate,
417 const double *source_pixels,
double *forward_pixels)
437 for (y=0L; y < (ssize_t) height; y++)
438 for (x=0L; x < (ssize_t) width; x++)
440 if (x < (ssize_t) center)
444 value=source_pixels[source_y*(ssize_t) center+source_x];
448 source_x=(ssize_t) width-x;
449 source_y=((ssize_t) height-y) % (ssize_t) height;
450 value=source_pixels[source_y*(ssize_t) center+source_x];
451 if (conjugate != MagickFalse)
454 target_x=(x+(ssize_t) (width/2)) % (ssize_t) width;
455 target_y=(y+(ssize_t) (height/2)) % (ssize_t) height;
456 forward_pixels[target_y*(ssize_t) width+target_x]=value;
461static MagickBooleanType ForwardFourier(
const FourierInfo *fourier_info,
462 Image *image,
double *magnitude,
double *phase,ExceptionInfo *exception)
491 magnitude_image=GetFirstImageInList(image);
492 phase_image=GetNextImageInList(image);
493 if (phase_image == (Image *) NULL)
495 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
496 "ImageSequenceRequired",
"`%s'",image->filename);
502 magnitude_info=AcquireVirtualMemory(fourier_info->width,fourier_info->height*
503 sizeof(*magnitude_pixels));
504 phase_info=AcquireVirtualMemory(fourier_info->width,fourier_info->height*
505 sizeof(*phase_pixels));
506 if ((magnitude_info == (MemoryInfo *) NULL) ||
507 (phase_info == (MemoryInfo *) NULL))
509 if (phase_info != (MemoryInfo *) NULL)
510 phase_info=RelinquishVirtualMemory(phase_info);
511 if (magnitude_info != (MemoryInfo *) NULL)
512 magnitude_info=RelinquishVirtualMemory(magnitude_info);
513 (void) ThrowMagickException(exception,GetMagickModule(),
514 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
517 magnitude_pixels=(
double *) GetVirtualMemoryBlob(magnitude_info);
518 (void) memset(magnitude_pixels,0,fourier_info->width*
519 fourier_info->height*
sizeof(*magnitude_pixels));
520 phase_pixels=(
double *) GetVirtualMemoryBlob(phase_info);
521 (void) memset(phase_pixels,0,fourier_info->width*
522 fourier_info->height*
sizeof(*phase_pixels));
523 status=ForwardQuadrantSwap(fourier_info->width,fourier_info->height,
524 MagickFalse,magnitude,magnitude_pixels);
525 if (status != MagickFalse)
526 status=ForwardQuadrantSwap(fourier_info->width,fourier_info->height,
527 MagickTrue,phase,phase_pixels);
528 if (status == MagickFalse)
530 phase_info=RelinquishVirtualMemory(phase_info);
531 magnitude_info=RelinquishVirtualMemory(magnitude_info);
534 if (fourier_info->modulus != MagickFalse)
537 for (y=0L; y < (ssize_t) fourier_info->height; y++)
538 for (x=0L; x < (ssize_t) fourier_info->width; x++)
540 phase_pixels[i]/=(2.0*MagickPI);
541 phase_pixels[i]+=0.5;
545 magnitude_view=AcquireAuthenticCacheView(magnitude_image,exception);
547 for (y=0L; y < (ssize_t) fourier_info->height; y++)
549 q=GetCacheViewAuthenticPixels(magnitude_view,0L,y,fourier_info->width,1UL,
551 if (q == (Quantum *) NULL)
553 for (x=0L; x < (ssize_t) fourier_info->width; x++)
555 switch (fourier_info->channel)
557 case RedPixelChannel:
560 SetPixelRed(magnitude_image,ClampToQuantum((
double) QuantumRange*
561 magnitude_pixels[i]),q);
564 case GreenPixelChannel:
566 SetPixelGreen(magnitude_image,ClampToQuantum((
double) QuantumRange*
567 magnitude_pixels[i]),q);
570 case BluePixelChannel:
572 SetPixelBlue(magnitude_image,ClampToQuantum((
double) QuantumRange*
573 magnitude_pixels[i]),q);
576 case BlackPixelChannel:
578 SetPixelBlack(magnitude_image,ClampToQuantum((
double) QuantumRange*
579 magnitude_pixels[i]),q);
582 case AlphaPixelChannel:
584 SetPixelAlpha(magnitude_image,ClampToQuantum((
double) QuantumRange*
585 magnitude_pixels[i]),q);
590 q+=(ptrdiff_t) GetPixelChannels(magnitude_image);
592 status=SyncCacheViewAuthenticPixels(magnitude_view,exception);
593 if (status == MagickFalse)
596 magnitude_view=DestroyCacheView(magnitude_view);
598 phase_view=AcquireAuthenticCacheView(phase_image,exception);
599 for (y=0L; y < (ssize_t) fourier_info->height; y++)
601 q=GetCacheViewAuthenticPixels(phase_view,0L,y,fourier_info->width,1UL,
603 if (q == (Quantum *) NULL)
605 for (x=0L; x < (ssize_t) fourier_info->width; x++)
607 switch (fourier_info->channel)
609 case RedPixelChannel:
612 SetPixelRed(phase_image,ClampToQuantum((
double) QuantumRange*
616 case GreenPixelChannel:
618 SetPixelGreen(phase_image,ClampToQuantum((
double) QuantumRange*
622 case BluePixelChannel:
624 SetPixelBlue(phase_image,ClampToQuantum((
double) QuantumRange*
628 case BlackPixelChannel:
630 SetPixelBlack(phase_image,ClampToQuantum((
double) QuantumRange*
634 case AlphaPixelChannel:
636 SetPixelAlpha(phase_image,ClampToQuantum((
double) QuantumRange*
642 q+=(ptrdiff_t) GetPixelChannels(phase_image);
644 status=SyncCacheViewAuthenticPixels(phase_view,exception);
645 if (status == MagickFalse)
648 phase_view=DestroyCacheView(phase_view);
649 phase_info=RelinquishVirtualMemory(phase_info);
650 magnitude_info=RelinquishVirtualMemory(magnitude_info);
654static MagickBooleanType ForwardFourierTransform(FourierInfo *fourier_info,
655 const Image *image,
double *magnitude_pixels,
double *phase_pixels,
656 ExceptionInfo *exception)
688 if ((fourier_info->width >= INT_MAX) || (fourier_info->height >= INT_MAX))
690 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
691 "WidthOrHeightExceedsLimit",
"`%s'",image->filename);
694 source_info=AcquireVirtualMemory(fourier_info->width,fourier_info->height*
695 sizeof(*source_pixels));
696 if (source_info == (MemoryInfo *) NULL)
698 (void) ThrowMagickException(exception,GetMagickModule(),
699 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
702 source_pixels=(
double *) GetVirtualMemoryBlob(source_info);
703 memset(source_pixels,0,fourier_info->width*fourier_info->height*
704 sizeof(*source_pixels));
705 image_view=AcquireVirtualCacheView(image,exception);
706 for (y=0L; y < (ssize_t) image->rows; y++)
708 p=GetCacheViewVirtualPixels(image_view,0L,y,image->columns,1UL,exception);
709 if (p == (
const Quantum *) NULL)
711 image_view=DestroyCacheView(image_view);
712 source_info=RelinquishVirtualMemory(source_info);
715 for (x=0L; x < (ssize_t) image->columns; x++)
717 switch (fourier_info->channel)
719 case RedPixelChannel:
722 source_pixels[y*(ssize_t) fourier_info->width+x]=QuantumScale*
723 (
double) GetPixelRed(image,p);
726 case GreenPixelChannel:
728 source_pixels[y*(ssize_t) fourier_info->width+x]=QuantumScale*
729 (
double) GetPixelGreen(image,p);
732 case BluePixelChannel:
734 source_pixels[y*(ssize_t) fourier_info->width+x]=QuantumScale*
735 (
double) GetPixelBlue(image,p);
738 case BlackPixelChannel:
740 source_pixels[y*(ssize_t) fourier_info->width+x]=QuantumScale*
741 (
double) GetPixelBlack(image,p);
744 case AlphaPixelChannel:
746 source_pixels[y*(ssize_t) fourier_info->width+x]=QuantumScale*
747 (
double) GetPixelAlpha(image,p);
751 p+=(ptrdiff_t) GetPixelChannels(image);
754 image_view=DestroyCacheView(image_view);
755 forward_info=AcquireVirtualMemory(fourier_info->height,fourier_info->center*
756 sizeof(*forward_pixels));
757 if (forward_info == (MemoryInfo *) NULL)
759 (void) ThrowMagickException(exception,GetMagickModule(),
760 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
761 source_info=(MemoryInfo *) RelinquishVirtualMemory(source_info);
764 forward_pixels=(fftw_complex *) GetVirtualMemoryBlob(forward_info);
765#if defined(MAGICKCORE_OPENMP_SUPPORT)
766 #pragma omp critical (MagickCore_ForwardFourierTransform)
768 fftw_r2c_plan=fftw_plan_dft_r2c_2d((
int) fourier_info->height,
769 (
int) fourier_info->width,source_pixels,forward_pixels,FFTW_ESTIMATE);
770 if (fftw_r2c_plan == (fftw_plan) NULL)
772 forward_info=RelinquishVirtualMemory(forward_info);
773 source_info=RelinquishVirtualMemory(source_info);
774 (void) ThrowMagickException(exception,GetMagickModule(),
775 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
778 fftw_execute_dft_r2c(fftw_r2c_plan,source_pixels,forward_pixels);
779 fftw_destroy_plan(fftw_r2c_plan);
780 source_info=(MemoryInfo *) RelinquishVirtualMemory(source_info);
781 value=GetImageArtifact(image,
"fourier:normalize");
782 if ((value == (
const char *) NULL) || (LocaleCompare(value,
"forward") == 0))
791 gamma=MagickSafeReciprocal((
double) fourier_info->width*
792 fourier_info->height);
793 for (y=0L; y < (ssize_t) fourier_info->height; y++)
794 for (x=0L; x < (ssize_t) fourier_info->center; x++)
796#if defined(MAGICKCORE_HAVE_COMPLEX_H)
797 forward_pixels[i]*=gamma;
799 forward_pixels[i][0]*=gamma;
800 forward_pixels[i][1]*=gamma;
809 if (fourier_info->modulus != MagickFalse)
810 for (y=0L; y < (ssize_t) fourier_info->height; y++)
811 for (x=0L; x < (ssize_t) fourier_info->center; x++)
813 magnitude_pixels[i]=cabs(forward_pixels[i]);
814 phase_pixels[i]=carg(forward_pixels[i]);
818 for (y=0L; y < (ssize_t) fourier_info->height; y++)
819 for (x=0L; x < (ssize_t) fourier_info->center; x++)
821 magnitude_pixels[i]=creal(forward_pixels[i]);
822 phase_pixels[i]=cimag(forward_pixels[i]);
825 forward_info=(MemoryInfo *) RelinquishVirtualMemory(forward_info);
829static MagickBooleanType ForwardFourierTransformChannel(
const Image *image,
830 const PixelChannel channel,
const MagickBooleanType modulus,
831 Image *fourier_image,ExceptionInfo *exception)
847 fourier_info.width=image->columns+(image->columns & 0x01);
848 fourier_info.height=image->rows+(image->rows & 0x01);
849 fourier_info.center=fourier_info.width/2+1;
850 fourier_info.channel=channel;
851 fourier_info.modulus=modulus;
852 magnitude_info=AcquireVirtualMemory(fourier_info.height,
853 fourier_info.center*
sizeof(*magnitude_pixels));
854 phase_info=AcquireVirtualMemory(fourier_info.height,fourier_info.center*
855 sizeof(*phase_pixels));
856 if ((magnitude_info == (MemoryInfo *) NULL) ||
857 (phase_info == (MemoryInfo *) NULL))
859 if (phase_info != (MemoryInfo *) NULL)
860 phase_info=RelinquishVirtualMemory(phase_info);
861 if (magnitude_info != (MemoryInfo *) NULL)
862 magnitude_info=RelinquishVirtualMemory(magnitude_info);
863 (void) ThrowMagickException(exception,GetMagickModule(),
864 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
867 magnitude_pixels=(
double *) GetVirtualMemoryBlob(magnitude_info);
868 phase_pixels=(
double *) GetVirtualMemoryBlob(phase_info);
869 status=ForwardFourierTransform(&fourier_info,image,magnitude_pixels,
870 phase_pixels,exception);
871 if (status != MagickFalse)
872 status=ForwardFourier(&fourier_info,fourier_image,magnitude_pixels,
873 phase_pixels,exception);
874 phase_info=RelinquishVirtualMemory(phase_info);
875 magnitude_info=RelinquishVirtualMemory(magnitude_info);
880MagickExport Image *ForwardFourierTransformImage(
const Image *image,
881 const MagickBooleanType modulus,ExceptionInfo *exception)
886 fourier_image=NewImageList();
887#if !defined(ENABLE_FFTW_DELEGATE)
889 (void) ThrowMagickException(exception,GetMagickModule(),
890 MissingDelegateWarning,
"DelegateLibrarySupportNotBuiltIn",
"`%s' (FFTW)",
901 width=image->columns+(image->columns & 0x01);
902 height=image->rows+(image->rows & 0x01);
903 magnitude_image=CloneImage(image,width,height,MagickTrue,exception);
904 if (magnitude_image != (Image *) NULL)
909 magnitude_image->storage_class=DirectClass;
910 magnitude_image->depth=32UL;
911 phase_image=CloneImage(image,width,height,MagickTrue,exception);
912 if (phase_image == (Image *) NULL)
913 magnitude_image=DestroyImage(magnitude_image);
920 phase_image->storage_class=DirectClass;
921 phase_image->depth=32UL;
922 AppendImageToList(&fourier_image,magnitude_image);
923 AppendImageToList(&fourier_image,phase_image);
925 is_gray=IsImageGray(image);
926#if defined(MAGICKCORE_OPENMP_SUPPORT)
927 #pragma omp parallel sections
930#if defined(MAGICKCORE_OPENMP_SUPPORT)
937 if (is_gray != MagickFalse)
938 thread_status=ForwardFourierTransformChannel(image,
939 GrayPixelChannel,modulus,fourier_image,exception);
941 thread_status=ForwardFourierTransformChannel(image,
942 RedPixelChannel,modulus,fourier_image,exception);
943 if (thread_status == MagickFalse)
944 status=thread_status;
946#if defined(MAGICKCORE_OPENMP_SUPPORT)
953 thread_status=MagickTrue;
954 if (is_gray == MagickFalse)
955 thread_status=ForwardFourierTransformChannel(image,
956 GreenPixelChannel,modulus,fourier_image,exception);
957 if (thread_status == MagickFalse)
958 status=thread_status;
960#if defined(MAGICKCORE_OPENMP_SUPPORT)
967 thread_status=MagickTrue;
968 if (is_gray == MagickFalse)
969 thread_status=ForwardFourierTransformChannel(image,
970 BluePixelChannel,modulus,fourier_image,exception);
971 if (thread_status == MagickFalse)
972 status=thread_status;
974#if defined(MAGICKCORE_OPENMP_SUPPORT)
981 thread_status=MagickTrue;
982 if (image->colorspace == CMYKColorspace)
983 thread_status=ForwardFourierTransformChannel(image,
984 BlackPixelChannel,modulus,fourier_image,exception);
985 if (thread_status == MagickFalse)
986 status=thread_status;
988#if defined(MAGICKCORE_OPENMP_SUPPORT)
995 thread_status=MagickTrue;
996 if (image->alpha_trait != UndefinedPixelTrait)
997 thread_status=ForwardFourierTransformChannel(image,
998 AlphaPixelChannel,modulus,fourier_image,exception);
999 if (thread_status == MagickFalse)
1000 status=thread_status;
1003 if (status == MagickFalse)
1004 fourier_image=DestroyImageList(fourier_image);
1010 return(fourier_image);
1047#if defined(ENABLE_FFTW_DELEGATE)
1048static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
1049 const Image *magnitude_image,
const Image *phase_image,
1050 fftw_complex *fourier_pixels,ExceptionInfo *exception)
1083 magnitude_info=AcquireVirtualMemory(fourier_info->width,fourier_info->height*
1084 sizeof(*magnitude_pixels));
1085 phase_info=AcquireVirtualMemory(fourier_info->width,fourier_info->height*
1086 sizeof(*phase_pixels));
1087 inverse_info=AcquireVirtualMemory(fourier_info->height,
1088 fourier_info->center*
sizeof(*inverse_pixels));
1089 if ((magnitude_info == (MemoryInfo *) NULL) ||
1090 (phase_info == (MemoryInfo *) NULL) ||
1091 (inverse_info == (MemoryInfo *) NULL))
1093 if (magnitude_info != (MemoryInfo *) NULL)
1094 magnitude_info=RelinquishVirtualMemory(magnitude_info);
1095 if (phase_info != (MemoryInfo *) NULL)
1096 phase_info=RelinquishVirtualMemory(phase_info);
1097 if (inverse_info != (MemoryInfo *) NULL)
1098 inverse_info=RelinquishVirtualMemory(inverse_info);
1099 (void) ThrowMagickException(exception,GetMagickModule(),
1100 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",
1101 magnitude_image->filename);
1102 return(MagickFalse);
1104 magnitude_pixels=(
double *) GetVirtualMemoryBlob(magnitude_info);
1105 phase_pixels=(
double *) GetVirtualMemoryBlob(phase_info);
1106 inverse_pixels=(
double *) GetVirtualMemoryBlob(inverse_info);
1108 magnitude_view=AcquireVirtualCacheView(magnitude_image,exception);
1109 for (y=0L; y < (ssize_t) fourier_info->height; y++)
1111 p=GetCacheViewVirtualPixels(magnitude_view,0L,y,fourier_info->width,1UL,
1113 if (p == (
const Quantum *) NULL)
1118 for (x=0L; x < (ssize_t) fourier_info->width; x++)
1120 switch (fourier_info->channel)
1122 case RedPixelChannel:
1125 magnitude_pixels[i]=QuantumScale*(double)
1126 GetPixelRed(magnitude_image,p);
1129 case GreenPixelChannel:
1131 magnitude_pixels[i]=QuantumScale*(double)
1132 GetPixelGreen(magnitude_image,p);
1135 case BluePixelChannel:
1137 magnitude_pixels[i]=QuantumScale*(double)
1138 GetPixelBlue(magnitude_image,p);
1141 case BlackPixelChannel:
1143 magnitude_pixels[i]=QuantumScale*(double)
1144 GetPixelBlack(magnitude_image,p);
1147 case AlphaPixelChannel:
1149 magnitude_pixels[i]=QuantumScale*(double)
1150 GetPixelAlpha(magnitude_image,p);
1155 p+=(ptrdiff_t) GetPixelChannels(magnitude_image);
1158 magnitude_view=DestroyCacheView(magnitude_view);
1159 if (status == MagickFalse)
1161 inverse_info=RelinquishVirtualMemory(inverse_info);
1162 phase_info=RelinquishVirtualMemory(phase_info);
1163 magnitude_info=RelinquishVirtualMemory(magnitude_info);
1164 return(MagickFalse);
1166 for (y=0L; y < (ssize_t) fourier_info->height; y++)
1167 for (x=0L; x < (ssize_t) fourier_info->center; x++)
1169 source_x=(x+(ssize_t) (fourier_info->width/2)) %
1170 (ssize_t) fourier_info->width;
1171 source_y=(y+(ssize_t) (fourier_info->height/2)) %
1172 (ssize_t) fourier_info->height;
1173 inverse_pixels[y*(ssize_t) fourier_info->center+x]=
1174 magnitude_pixels[source_y*(ssize_t) fourier_info->width+source_x];
1176 (void) memcpy(magnitude_pixels,inverse_pixels,fourier_info->height*
1177 fourier_info->center*
sizeof(*magnitude_pixels));
1179 phase_view=AcquireVirtualCacheView(phase_image,exception);
1180 for (y=0L; y < (ssize_t) fourier_info->height; y++)
1182 p=GetCacheViewVirtualPixels(phase_view,0,y,fourier_info->width,1,
1184 if (p == (
const Quantum *) NULL)
1189 for (x=0L; x < (ssize_t) fourier_info->width; x++)
1191 switch (fourier_info->channel)
1193 case RedPixelChannel:
1196 phase_pixels[i]=QuantumScale*(double) GetPixelRed(phase_image,p);
1199 case GreenPixelChannel:
1201 phase_pixels[i]=QuantumScale*(double) GetPixelGreen(phase_image,p);
1204 case BluePixelChannel:
1206 phase_pixels[i]=QuantumScale*(double) GetPixelBlue(phase_image,p);
1209 case BlackPixelChannel:
1211 phase_pixels[i]=QuantumScale*(double) GetPixelBlack(phase_image,p);
1214 case AlphaPixelChannel:
1216 phase_pixels[i]=QuantumScale*(double) GetPixelAlpha(phase_image,p);
1221 p+=(ptrdiff_t) GetPixelChannels(phase_image);
1224 phase_view=DestroyCacheView(phase_view);
1225 if (status == MagickFalse)
1227 inverse_info=RelinquishVirtualMemory(inverse_info);
1228 phase_info=RelinquishVirtualMemory(phase_info);
1229 magnitude_info=RelinquishVirtualMemory(magnitude_info);
1230 return(MagickFalse);
1232 if (fourier_info->modulus != MagickFalse)
1235 for (y=0L; y < (ssize_t) fourier_info->height; y++)
1236 for (x=0L; x < (ssize_t) fourier_info->width; x++)
1238 phase_pixels[i]-=0.5;
1239 phase_pixels[i]*=(2.0*MagickPI);
1243 for (y=0L; y < (ssize_t) fourier_info->height; y++)
1244 for (x=0L; x < (ssize_t) fourier_info->center; x++)
1246 source_x=(x+(ssize_t) (fourier_info->width/2)) %
1247 (ssize_t) fourier_info->width;
1248 source_y=(y+(ssize_t) (fourier_info->height/2)) %
1249 (ssize_t) fourier_info->height;
1250 inverse_pixels[y*(ssize_t) fourier_info->center+x]=
1251 phase_pixels[source_y*(ssize_t) fourier_info->width+source_x];
1253 (void) memcpy(phase_pixels,inverse_pixels,fourier_info->height*
1254 fourier_info->center*
sizeof(*phase_pixels));
1255 inverse_info=RelinquishVirtualMemory(inverse_info);
1260 if (fourier_info->modulus != MagickFalse)
1261 for (y=0L; y < (ssize_t) fourier_info->height; y++)
1262 for (x=0L; x < (ssize_t) fourier_info->center; x++)
1264#if defined(MAGICKCORE_HAVE_COMPLEX_H)
1265 fourier_pixels[i]=magnitude_pixels[i]*cos(phase_pixels[i])+I*
1266 magnitude_pixels[i]*sin(phase_pixels[i]);
1268 fourier_pixels[i][0]=magnitude_pixels[i]*cos(phase_pixels[i]);
1269 fourier_pixels[i][1]=magnitude_pixels[i]*sin(phase_pixels[i]);
1274 for (y=0L; y < (ssize_t) fourier_info->height; y++)
1275 for (x=0L; x < (ssize_t) fourier_info->center; x++)
1277#if defined(MAGICKCORE_HAVE_COMPLEX_H)
1278 fourier_pixels[i]=magnitude_pixels[i]+I*phase_pixels[i];
1280 fourier_pixels[i][0]=magnitude_pixels[i];
1281 fourier_pixels[i][1]=phase_pixels[i];
1285 magnitude_info=RelinquishVirtualMemory(magnitude_info);
1286 phase_info=RelinquishVirtualMemory(phase_info);
1290static MagickBooleanType InverseFourierTransform(FourierInfo *fourier_info,
1291 fftw_complex *fourier_pixels,Image *image,ExceptionInfo *exception)
1319 if ((fourier_info->width >= INT_MAX) || (fourier_info->height >= INT_MAX))
1321 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1322 "WidthOrHeightExceedsLimit",
"`%s'",image->filename);
1323 return(MagickFalse);
1325 source_info=AcquireVirtualMemory(fourier_info->width,fourier_info->height*
1326 sizeof(*source_pixels));
1327 if (source_info == (MemoryInfo *) NULL)
1329 (void) ThrowMagickException(exception,GetMagickModule(),
1330 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
1331 return(MagickFalse);
1333 source_pixels=(
double *) GetVirtualMemoryBlob(source_info);
1334 value=GetImageArtifact(image,
"fourier:normalize");
1335 if ((value != (
const char *) NULL) && (LocaleCompare(value,
"inverse") == 0))
1344 gamma=MagickSafeReciprocal((
double) fourier_info->width*
1345 fourier_info->height);
1346 for (y=0L; y < (ssize_t) fourier_info->height; y++)
1347 for (x=0L; x < (ssize_t) fourier_info->center; x++)
1349#if defined(MAGICKCORE_HAVE_COMPLEX_H)
1350 fourier_pixels[i]*=gamma;
1352 fourier_pixels[i][0]*=gamma;
1353 fourier_pixels[i][1]*=gamma;
1358#if defined(MAGICKCORE_OPENMP_SUPPORT)
1359 #pragma omp critical (MagickCore_InverseFourierTransform)
1361 fftw_c2r_plan=fftw_plan_dft_c2r_2d((
int) fourier_info->height,
1362 (
int) fourier_info->width,fourier_pixels,source_pixels,FFTW_ESTIMATE);
1363 if (fftw_c2r_plan == (fftw_plan) NULL)
1365 source_info=RelinquishVirtualMemory(source_info);
1366 (void) ThrowMagickException(exception,GetMagickModule(),
1367 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
1368 return(MagickFalse);
1370 fftw_execute_dft_c2r(fftw_c2r_plan,fourier_pixels,source_pixels);
1371 fftw_destroy_plan(fftw_c2r_plan);
1373 image_view=AcquireAuthenticCacheView(image,exception);
1374 for (y=0L; y < (ssize_t) fourier_info->height; y++)
1376 if (y >= (ssize_t) image->rows)
1378 q=GetCacheViewAuthenticPixels(image_view,0L,y,fourier_info->width >
1379 image->columns ? image->columns : fourier_info->width,1UL,exception);
1380 if (q == (Quantum *) NULL)
1382 for (x=0L; x < (ssize_t) fourier_info->width; x++)
1384 if (x < (ssize_t) image->columns)
1385 switch (fourier_info->channel)
1387 case RedPixelChannel:
1390 SetPixelRed(image,ClampToQuantum((
double) QuantumRange*
1391 source_pixels[i]),q);
1394 case GreenPixelChannel:
1396 SetPixelGreen(image,ClampToQuantum((
double) QuantumRange*
1397 source_pixels[i]),q);
1400 case BluePixelChannel:
1402 SetPixelBlue(image,ClampToQuantum((
double) QuantumRange*
1403 source_pixels[i]),q);
1406 case BlackPixelChannel:
1408 SetPixelBlack(image,ClampToQuantum((
double) QuantumRange*
1409 source_pixels[i]),q);
1412 case AlphaPixelChannel:
1414 SetPixelAlpha(image,ClampToQuantum((
double) QuantumRange*
1415 source_pixels[i]),q);
1420 q+=(ptrdiff_t) GetPixelChannels(image);
1422 if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
1425 image_view=DestroyCacheView(image_view);
1426 source_info=RelinquishVirtualMemory(source_info);
1430static MagickBooleanType InverseFourierTransformChannel(
1431 const Image *magnitude_image,
const Image *phase_image,
1432 const PixelChannel channel,
const MagickBooleanType modulus,
1433 Image *fourier_image,ExceptionInfo *exception)
1447 fourier_info.width=magnitude_image->columns;
1448 fourier_info.height=magnitude_image->rows;
1449 fourier_info.center=fourier_info.width/2+1;
1450 fourier_info.channel=channel;
1451 fourier_info.modulus=modulus;
1452 inverse_info=AcquireVirtualMemory(fourier_info.height,
1453 fourier_info.center*
sizeof(*inverse_pixels));
1454 if (inverse_info == (MemoryInfo *) NULL)
1456 (void) ThrowMagickException(exception,GetMagickModule(),
1457 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",
1458 magnitude_image->filename);
1459 return(MagickFalse);
1461 inverse_pixels=(fftw_complex *) GetVirtualMemoryBlob(inverse_info);
1462 status=InverseFourier(&fourier_info,magnitude_image,phase_image,
1463 inverse_pixels,exception);
1464 if (status != MagickFalse)
1465 status=InverseFourierTransform(&fourier_info,inverse_pixels,fourier_image,
1467 inverse_info=RelinquishVirtualMemory(inverse_info);
1472MagickExport Image *InverseFourierTransformImage(
const Image *magnitude_image,
1473 const Image *phase_image,
const MagickBooleanType modulus,
1474 ExceptionInfo *exception)
1479 assert(magnitude_image != (Image *) NULL);
1480 assert(magnitude_image->signature == MagickCoreSignature);
1481 if (IsEventLogging() != MagickFalse)
1482 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
1483 magnitude_image->filename);
1484 if (phase_image == (Image *) NULL)
1486 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1487 "ImageSequenceRequired",
"`%s'",magnitude_image->filename);
1488 return((Image *) NULL);
1490 if ((magnitude_image->columns != phase_image->columns) ||
1491 (magnitude_image->rows != phase_image->rows))
1493 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1494 "ImageSizeDiffers",
"`%s'",magnitude_image->filename);
1495 return((Image *) NULL);
1497#if !defined(ENABLE_FFTW_DELEGATE)
1498 fourier_image=(Image *) NULL;
1500 (void) ThrowMagickException(exception,GetMagickModule(),
1501 MissingDelegateWarning,
"DelegateLibrarySupportNotBuiltIn",
"`%s' (FFTW)",
1502 magnitude_image->filename);
1505 fourier_image=CloneImage(magnitude_image,magnitude_image->columns,
1506 magnitude_image->rows,MagickTrue,exception);
1507 if (fourier_image != (Image *) NULL)
1514 is_gray=IsImageGray(magnitude_image);
1515 if (is_gray != MagickFalse)
1516 is_gray=IsImageGray(phase_image);
1517#if defined(MAGICKCORE_OPENMP_SUPPORT)
1518 #pragma omp parallel sections
1521#if defined(MAGICKCORE_OPENMP_SUPPORT)
1528 if (is_gray != MagickFalse)
1529 thread_status=InverseFourierTransformChannel(magnitude_image,
1530 phase_image,GrayPixelChannel,modulus,fourier_image,exception);
1532 thread_status=InverseFourierTransformChannel(magnitude_image,
1533 phase_image,RedPixelChannel,modulus,fourier_image,exception);
1534 if (thread_status == MagickFalse)
1535 status=thread_status;
1537#if defined(MAGICKCORE_OPENMP_SUPPORT)
1544 thread_status=MagickTrue;
1545 if (is_gray == MagickFalse)
1546 thread_status=InverseFourierTransformChannel(magnitude_image,
1547 phase_image,GreenPixelChannel,modulus,fourier_image,exception);
1548 if (thread_status == MagickFalse)
1549 status=thread_status;
1551#if defined(MAGICKCORE_OPENMP_SUPPORT)
1558 thread_status=MagickTrue;
1559 if (is_gray == MagickFalse)
1560 thread_status=InverseFourierTransformChannel(magnitude_image,
1561 phase_image,BluePixelChannel,modulus,fourier_image,exception);
1562 if (thread_status == MagickFalse)
1563 status=thread_status;
1565#if defined(MAGICKCORE_OPENMP_SUPPORT)
1572 thread_status=MagickTrue;
1573 if (magnitude_image->colorspace == CMYKColorspace)
1574 thread_status=InverseFourierTransformChannel(magnitude_image,
1575 phase_image,BlackPixelChannel,modulus,fourier_image,exception);
1576 if (thread_status == MagickFalse)
1577 status=thread_status;
1579#if defined(MAGICKCORE_OPENMP_SUPPORT)
1586 thread_status=MagickTrue;
1587 if (magnitude_image->alpha_trait != UndefinedPixelTrait)
1588 thread_status=InverseFourierTransformChannel(magnitude_image,
1589 phase_image,AlphaPixelChannel,modulus,fourier_image,exception);
1590 if (thread_status == MagickFalse)
1591 status=thread_status;
1594 if (status == MagickFalse)
1595 fourier_image=DestroyImage(fourier_image);
1600 return(fourier_image);