Changeset 584 for ImageMagick/trunk

Timestamp:

11/13/09 12:05:42 (4 months ago)

Author:

cristy

Message:

 

Location:

ImageMagick/trunk

Files:

• Magick++/lib/Image.cpp (modified) (1 diff)
• Magick++/lib/Magick++/Image.h (modified) (1 diff)
• PerlMagick/Magick.xs (modified) (1 diff)
• magick/fourier.c (modified) (19 diffs)
• magick/fourier.h (modified) (1 diff)
• wand/magick-image.c (modified) (2 diffs)
• wand/magick-image.h (modified) (1 diff)
• wand/mogrify.c (modified) (1 diff)

ImageMagick/trunk/Magick++/lib/Image.cpp

@@ -1067 +1067 @@
 }
 
-// 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 )

ImageMagick/trunk/Magick++/lib/Magick++/Image.h

@@ -361 +361 @@
 
     // Applies a mathematical expression to the image.
+    void            fx ( const std::string expression );
     void            fx ( const std::string expression,
                          const Magick::ChannelType channel );

ImageMagick/trunk/PerlMagick/Magick.xs

@@ -9934 +9934 @@
         case 125:  /* InverseFourierTransformImage */
         {
-          image=InverseFourierTransformImage(image,
+          image=InverseFourierTransformImage(image,image->next,
             argument_list[0].long_reference != 0 ? MagickTrue : MagickFalse,
             exception);

ImageMagick/trunk/magick/fourier.c

@@ -736 +736 @@
 %  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
@@ -776 +779 @@
 
 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
@@ -788 +792 @@
     *phase_source;
 
-  Image
-    *magnitude_image,
-    *phase_image;
-
   long
     y;
@@ -811 +811 @@
     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));
@@ -828 +816 @@
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
-        ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
+        ResourceLimitError,"MemoryAllocationFailed","`%s'",
+        magnitude_image->filename);
       return(MagickFalse);
     }
@@ -836 +825 @@
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
-        ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
+        ResourceLimitError,"MemoryAllocationFailed","`%s'",
+        magnitude_image->filename);
       magnitude_source=(double *) RelinquishMagickMemory(magnitude_source);
       return(MagickFalse);
@@ -956 +946 @@
     {
       (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);
@@ -969 +960 @@
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
-        ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
+        ResourceLimitError,"MemoryAllocationFailed","`%s'",
+        magnitude_image->filename);
       phase_source=(double *) RelinquishMagickMemory(phase_source);
       return(MagickFalse);
@@ -1099 +1091 @@
 }
 
-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)
@@ -1119 +1112 @@
     extent;
 
-  fourier_info.width=images->columns;
-  if ((images->columns != images->rows) || ((images->columns % 2) != 0) ||
-      ((images->rows % 2) != 0))
-    {
-      extent=images->columns < images->rows ? images->rows : images->columns;
+  fourier_info.width=magnitude_image->columns;
+  if ((magnitude_image->columns != magnitude_image->rows) ||
+      ((magnitude_image->columns % 2) != 0) ||
+      ((magnitude_image->rows % 2) != 0))
+    {
+      extent=magnitude_image->columns < magnitude_image->rows ?
+        magnitude_image->rows : magnitude_image->columns;
       fourier_info.width=(extent & 0x01) == 1 ? extent+1UL : extent;
     }
@@ -1135 +1130 @@
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
-        ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
+        ResourceLimitError,"MemoryAllocationFailed","`%s'",
+        magnitude_image->filename);
       return(MagickFalse);
     }
@@ -1143 +1139 @@
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
-        ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
+        ResourceLimitError,"MemoryAllocationFailed","`%s'",
+        magnitude_image->filename);
       magnitude=(double *) RelinquishMagickMemory(magnitude);
       return(MagickFalse);
@@ -1152 +1149 @@
     {
       (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,
@@ -1168 +1167 @@
 #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;
@@ -1179 +1190 @@
   (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)
       {
@@ -1194 +1205 @@
 
         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)
@@ -1212 +1223 @@
               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;
             }
@@ -1223 +1234 @@
             {
               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;
             }
@@ -1230 +1241 @@
             {
               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;
             }

ImageMagick/trunk/magick/fourier.h

@@ -26 +26 @@
  *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)

ImageMagick/trunk/wand/magick-image.c

@@ -6288 +6288 @@
 %
 %      MagickBooleanType MagickInverseFourierTransformImage(
-%        MagickWand *wand,const MagickBooleanType magnitude)
-%
-%  A description of each parameter follows:
-%
-%    o wand: the magick wand.
+%        MagickWand *magnitude_wand,MagickWand *phase_wand,
+%        const MagickBooleanType magnitude)
+%
+%  A description of each parameter follows:
+%
+%    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 /
@@ -6299 +6302 @@
 */
 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);

ImageMagick/trunk/wand/magick-image.h

@@ -194 +194 @@
     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),

ImageMagick/trunk/wand/mogrify.c

@@ -7704 +7704 @@
             */
             (void) SyncImagesSettings(image_info,*images);
-            fourier_image=InverseFourierTransformImage(*images,
+            fourier_image=InverseFourierTransformImage(*images,(*images)->next,
               *option == '-' ? MagickTrue : MagickFalse,exception);
             if (fourier_image == (Image *) NULL)