(no commit message)

diff --git a/Magick++/lib/Image.cpp b/Magick++/lib/Image.cpp
index 6444dbf7cd01bf26948a825a7d3a5beb41864419..112321dd572d8a429de5e43cc84dbf8e182d1a11 100644 (file)
--- a/Magick++/lib/Image.cpp
+++ b/Magick++/lib/Image.cpp
@@ -1066,7 +1066,17 @@ void Magick::Image::frame ( const unsigned int width_,
   (void) DestroyExceptionInfo( &exceptionInfo );
 }
 
-// Convolve image.  Applies a mathematical expression to the image.
+// Fx image.  Applies a mathematical expression to the image.
+void Magick::Image::fx ( const std::string expression )
+{
+  ExceptionInfo exceptionInfo;
+  GetExceptionInfo( &exceptionInfo );
+  MagickCore::Image* newImage =
+    FxImageChannel ( image(), DefaultChannels, expression.c_str(), &exceptionInfo );
+  replaceImage( newImage );
+  throwException( exceptionInfo );
+  (void) DestroyExceptionInfo( &exceptionInfo );
+}
 void Magick::Image::fx ( const std::string expression,
                          const Magick::ChannelType channel )
 {

diff --git a/Magick++/lib/Magick++/Image.h b/Magick++/lib/Magick++/Image.h
index ed78f1afff579c9ff6b877c2436678bc45d08e50..26f3006de8c9bba972b34b05b54a06f22a4ac00a 100644 (file)
--- a/Magick++/lib/Magick++/Image.h
+++ b/Magick++/lib/Magick++/Image.h
@@ -360,6 +360,7 @@ namespace Magick
                             const int outerBevel_ = 6 );
 
     // Applies a mathematical expression to the image.
+    void            fx ( const std::string expression );
     void            fx ( const std::string expression,
                          const Magick::ChannelType channel );
     

diff --git a/PerlMagick/Magick.xs b/PerlMagick/Magick.xs
index 185e940ce6882e2e2473f7eed47379b650c94440..f8afb79bb6aaf7fb7411cc4a79bab78351b9a2c4 100644 (file)
--- a/PerlMagick/Magick.xs
+++ b/PerlMagick/Magick.xs
@@ -9933,7 +9933,7 @@ Mogrify(ref,...)
         }
         case 125:  /* InverseFourierTransformImage */
         {
-          image=InverseFourierTransformImage(image,
+          image=InverseFourierTransformImage(image,image->next,
             argument_list[0].long_reference != 0 ? MagickTrue : MagickFalse,
             exception);
           break;

diff --git a/magick/fourier.c b/magick/fourier.c
index 6cac42b09d1db77eae69b284aeab5ef016e3d6f5..0feb32474028db30f29cb5da647071266cb4536b 100644 (file)
--- a/magick/fourier.c
+++ b/magick/fourier.c
@@ -735,12 +735,15 @@ MagickExport Image *ForwardFourierTransformImage(const Image *image,
 %
 %  The format of the InverseFourierTransformImage method is:
 %
-%      Image *InverseFourierTransformImage(const Image *images,
-%        const MagickBooleanType modulus,ExceptionInfo *exception)
+%      Image *InverseFourierTransformImage(const Image *magnitude_image,
+%        const Image *phase_image,const MagickBooleanType modulus,
+%        ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
-%    o images: the image sequence.
+%    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.
@@ -775,7 +778,8 @@ static MagickBooleanType InverseQuadrantSwap(const unsigned long width,
 }
 
 static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
-  const Image *images,fftw_complex *fourier,ExceptionInfo *exception)
+  const Image *magnitude_image,const Image *phase_image,fftw_complex *fourier,
+  ExceptionInfo *exception)
 {
   CacheView
     *magnitude_view,
@@ -787,10 +791,6 @@ static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
     *magnitude_source,
     *phase_source;
 
-  Image
-    *magnitude_image,
-    *phase_image;
-
   long
     y;
 
@@ -810,24 +810,13 @@ static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
   /*
     Inverse fourier - read image and break down into a double array.
   */
-  assert(images != (Image *) NULL);
-  assert(images->signature == MagickSignature);
-  if (images->debug != MagickFalse)
-    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
-  magnitude_image=GetFirstImageInList(images),
-  phase_image=GetNextImageInList(images);
-  if (phase_image == (Image *) NULL)
-    {
-      (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
-        "ImageSequenceRequired","`%s'",images->filename);
-      return(MagickFalse);
-    }
   magnitude_source=(double *) AcquireQuantumMemory((size_t)
     fourier_info->height,fourier_info->width*sizeof(*magnitude_source));
   if (magnitude_source == (double *) NULL)
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
-        ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
+        ResourceLimitError,"MemoryAllocationFailed","`%s'",
+        magnitude_image->filename);
       return(MagickFalse);
     }
   phase_source=(double *) AcquireQuantumMemory((size_t) fourier_info->height,
@@ -835,7 +824,8 @@ static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
   if (phase_source == (double *) NULL)
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
-        ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
+        ResourceLimitError,"MemoryAllocationFailed","`%s'",
+        magnitude_image->filename);
       magnitude_source=(double *) RelinquishMagickMemory(magnitude_source);
       return(MagickFalse);
     }
@@ -955,7 +945,8 @@ static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
   if (magnitude == (double *) NULL)
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
-        ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
+        ResourceLimitError,"MemoryAllocationFailed","`%s'",
+        magnitude_image->filename);
       magnitude_source=(double *) RelinquishMagickMemory(magnitude_source);
       phase_source=(double *) RelinquishMagickMemory(phase_source);
       return(MagickFalse);
@@ -968,7 +959,8 @@ static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
   if (phase == (double *) NULL)
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
-        ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
+        ResourceLimitError,"MemoryAllocationFailed","`%s'",
+        magnitude_image->filename);
       phase_source=(double *) RelinquishMagickMemory(phase_source);
       return(MagickFalse);
     }
@@ -1098,7 +1090,8 @@ static MagickBooleanType InverseFourierTransform(FourierInfo *fourier_info,
   return(MagickTrue);
 }
 
-static MagickBooleanType InverseFourierTransformChannel(const Image *images,
+static MagickBooleanType InverseFourierTransformChannel(
+  const Image *magnitude_image,const Image *phase_image,
   const ChannelType channel,const MagickBooleanType modulus,
   Image *fourier_image,ExceptionInfo *exception)
 {
@@ -1118,11 +1111,13 @@ static MagickBooleanType InverseFourierTransformChannel(const Image *images,
   size_t
     extent;
 
-  fourier_info.width=images->columns;
-  if ((images->columns != images->rows) || ((images->columns % 2) != 0) ||
-      ((images->rows % 2) != 0))
+  fourier_info.width=magnitude_image->columns;
+  if ((magnitude_image->columns != magnitude_image->rows) ||
+      ((magnitude_image->columns % 2) != 0) ||
+      ((magnitude_image->rows % 2) != 0))
     {
-      extent=images->columns < images->rows ? images->rows : images->columns;
+      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;
@@ -1134,7 +1129,8 @@ static MagickBooleanType InverseFourierTransformChannel(const Image *images,
   if (magnitude == (double *) NULL)
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
-        ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
+        ResourceLimitError,"MemoryAllocationFailed","`%s'",
+        magnitude_image->filename);
       return(MagickFalse);
     }
   phase=(double *) AcquireQuantumMemory((size_t) fourier_info.height,
@@ -1142,7 +1138,8 @@ static MagickBooleanType InverseFourierTransformChannel(const Image *images,
   if (phase == (double *) NULL)
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
-        ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
+        ResourceLimitError,"MemoryAllocationFailed","`%s'",
+        magnitude_image->filename);
       magnitude=(double *) RelinquishMagickMemory(magnitude);
       return(MagickFalse);
     }
@@ -1151,12 +1148,14 @@ static MagickBooleanType InverseFourierTransformChannel(const Image *images,
   if (fourier == (fftw_complex *) NULL)
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
-        ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
+        ResourceLimitError,"MemoryAllocationFailed","`%s'",
+        magnitude_image->filename);
       phase=(double *) RelinquishMagickMemory(phase);
       magnitude=(double *) RelinquishMagickMemory(magnitude);
       return(MagickFalse);
     }
-  status=InverseFourier(&fourier_info,images,fourier,exception);
+  status=InverseFourier(&fourier_info,magnitude_image,phase_image,fourier,
+   exception);
   if (status != MagickFalse)
     status=InverseFourierTransform(&fourier_info,fourier,fourier_image,
       exception);
@@ -1167,22 +1166,34 @@ static MagickBooleanType InverseFourierTransformChannel(const Image *images,
 }
 #endif
 
-MagickExport Image *InverseFourierTransformImage(const Image *images,
-  const MagickBooleanType modulus,ExceptionInfo *exception)
+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 == MagickSignature);
+  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(MagickFalse);
+    }
 #if !defined(MAGICKCORE_FFTW_DELEGATE)
   fourier_image=(Image *) NULL;
   (void) modulus;
   (void) ThrowMagickException(exception,GetMagickModule(),
     MissingDelegateWarning,"DelegateLibrarySupportNotBuiltIn","`%s' (FFTW)",
-    images->filename);
+    magnitude_image->filename);
 #else
   {
-    fourier_image=CloneImage(images,images->columns,images->rows,MagickFalse,
-      exception);
+    fourier_image=CloneImage(magnitude_image,magnitude_image->columns,
+      magnitude_image->rows,MagickFalse,exception);
     if (fourier_image != (Image *) NULL)
       {
         MagickBooleanType
@@ -1193,9 +1204,9 @@ MagickExport Image *InverseFourierTransformImage(const Image *images,
           i;
 
         status=MagickTrue;
-        is_gray=IsGrayImage(images,exception);
-        if ((is_gray != MagickFalse) && (images->next != (Image *) NULL))
-          is_gray=IsGrayImage(images->next,exception);
+        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)
 #endif
@@ -1211,40 +1222,40 @@ MagickExport Image *InverseFourierTransformImage(const Image *images,
             {
               if (is_gray != MagickFalse)
                 {
-                  thread_status=InverseFourierTransformChannel(images,
-                    GrayChannels,modulus,fourier_image,exception);
+                  thread_status=InverseFourierTransformChannel(magnitude_image,
+                    phase_image,GrayChannels,modulus,fourier_image,exception);
                   break;
                 }
-              thread_status=InverseFourierTransformChannel(images,RedChannel,
-                modulus,fourier_image,exception);
+              thread_status=InverseFourierTransformChannel(magnitude_image,
+                phase_image,RedChannel,modulus,fourier_image,exception);
               break;
             }
             case 1:
             {
               if (is_gray == MagickFalse)
-                thread_status=InverseFourierTransformChannel(images,
-                  GreenChannel,modulus,fourier_image,exception);
+                thread_status=InverseFourierTransformChannel(magnitude_image,
+                  phase_image,GreenChannel,modulus,fourier_image,exception);
               break;
             }
             case 2:
             {
               if (is_gray == MagickFalse)
-                thread_status=InverseFourierTransformChannel(images,BlueChannel,
-                  modulus,fourier_image,exception);
+                thread_status=InverseFourierTransformChannel(magnitude_image,
+                  phase_image,BlueChannel,modulus,fourier_image,exception);
               break;
             }
             case 3:
             {
-              if (images->matte != MagickFalse)
-                thread_status=InverseFourierTransformChannel(images,
-                  OpacityChannel,modulus,fourier_image,exception);
+              if (magnitude_image->matte != MagickFalse)
+                thread_status=InverseFourierTransformChannel(magnitude_image,
+                  phase_image,OpacityChannel,modulus,fourier_image,exception);
               break;
             }
             case 4:
             {
-              if (images->colorspace == CMYKColorspace)
-                thread_status=InverseFourierTransformChannel(images,
-                  IndexChannel,modulus,fourier_image,exception);
+              if (magnitude_image->colorspace == CMYKColorspace)
+                thread_status=InverseFourierTransformChannel(magnitude_image,
+                  phase_image,IndexChannel,modulus,fourier_image,exception);
               break;
             }
           }

diff --git a/magick/fourier.h b/magick/fourier.h
index 783fbd70f7d5a4ff7602236182f9f4b21a1b1614..0f37d8ae55549d8952e2a0d1fde08c6cc9000d36 100644 (file)
--- a/magick/fourier.h
+++ b/magick/fourier.h
@@ -25,8 +25,8 @@ extern "C" {
 extern MagickExport Image
  *ForwardFourierTransformImage(const Image *,const MagickBooleanType,
    ExceptionInfo *),
- *InverseFourierTransformImage(const Image *,const MagickBooleanType,
-   ExceptionInfo *);
+ *InverseFourierTransformImage(const Image *,const Image *,
+   const MagickBooleanType,ExceptionInfo *);
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }

diff --git a/wand/magick-image.c b/wand/magick-image.c
index 37648df1149f66c3c6483e4e045db3ea156f14e7..d9d02afba9e9c2db68f5caf5d9b93c60afeb0ecd 100644 (file)
--- a/wand/magick-image.c
+++ b/wand/magick-image.c
@@ -6287,30 +6287,42 @@ WandExport MagickBooleanType MagickImportImagePixels(MagickWand *wand,
 %  The format of the MagickInverseFourierTransformImage method is:
 %
 %      MagickBooleanType MagickInverseFourierTransformImage(
-%        MagickWand *wand,const MagickBooleanType magnitude)
+%        MagickWand *magnitude_wand,MagickWand *phase_wand,
+%        const MagickBooleanType magnitude)
 %
 %  A description of each parameter follows:
 %
-%    o wand: the magick wand.
+%    o magnitude_wand: the magnitude or real wand.
+%
+%    o phase_wand: the phase or imaginary wand.
 %
 %    o magnitude: if true, return as magnitude / phase pair otherwise a real /
 %      imaginary image pair.
 %
 */
 WandExport MagickBooleanType MagickInverseFourierTransformImage(
-  MagickWand *wand,const MagickBooleanType magnitude)
+  MagickWand *magnitude_wand,MagickWand *phase_wand,
+  const MagickBooleanType magnitude)
 {
   Image
     *inverse_image;
 
-  assert(wand != (MagickWand *) NULL);
-  assert(wand->signature == WandSignature);
-  if (wand->debug != MagickFalse)
-    (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
-  if (wand->images == (Image *) NULL)
-    ThrowWandException(WandError,"ContainsNoImages",wand->name);
-  inverse_image=InverseFourierTransformImage(wand->images,magnitude,
-    wand->exception);
+  MagickWand
+    *wand;
+
+  assert(magnitude_wand != (MagickWand *) NULL);
+  assert(magnitude_wand->signature == WandSignature);
+  if (magnitude_wand->debug != MagickFalse)
+    (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",
+      magnitude_wand->name);
+  wand=magnitude_wand;
+  if (magnitude_wand->images == (Image *) NULL)
+    ThrowWandException(WandError,"ContainsNoImages",
+      magnitude_wand->name);
+  assert(phase_wand != (MagickWand *) NULL);
+  assert(phase_wand->signature == WandSignature);
+  inverse_image=InverseFourierTransformImage(magnitude_wand->images,
+    phase_wand->images,magnitude,wand->exception);
   if (inverse_image == (Image *) NULL)
     return(MagickFalse);
   ReplaceImageInList(&wand->images,inverse_image);

diff --git a/wand/magick-image.h b/wand/magick-image.h
index f797f1608f0415fc50c33f196d529ae546d55fc4..fa16138aeac87beaf82bedc775611caf589a1b50 100644 (file)
--- a/wand/magick-image.h
+++ b/wand/magick-image.h
@@ -193,7 +193,8 @@ extern WandExport MagickBooleanType
   MagickImportImagePixels(MagickWand *,const long,const long,
     const unsigned long,const unsigned long,const char *,const StorageType,
     const void *),
-  MagickInverseFourierTransformImage(MagickWand *,const MagickBooleanType),
+  MagickInverseFourierTransformImage(MagickWand *,MagickWand *,
+    const MagickBooleanType),
   MagickLabelImage(MagickWand *,const char *),
   MagickLevelImage(MagickWand *,const double,const double,const double),
   MagickLevelImageChannel(MagickWand *,const ChannelType,const double,

diff --git a/wand/mogrify.c b/wand/mogrify.c
index cb288a1ef1ad30d6c42c2a819d2d615ac205239b..c5de9474368589f2e933bb9cf6d2c07d9b90ff3c 100644 (file)
--- a/wand/mogrify.c
+++ b/wand/mogrify.c
@@ -7703,7 +7703,7 @@ WandExport MagickBooleanType MogrifyImageList(ImageInfo *image_info,
               Implements the inverse fourier discrete Fourier transform (DFT).
             */
             (void) SyncImagesSettings(image_info,*images);
-            fourier_image=InverseFourierTransformImage(*images,
+            fourier_image=InverseFourierTransformImage(*images,(*images)->next,
               *option == '-' ? MagickTrue : MagickFalse,exception);
             if (fourier_image == (Image *) NULL)
               break;