Commit ccc9b3278 for imagemagick.org

commit ccc9b32783bedbbb9891a9d72942e2b5f4a6d629
Author: Cristy <urban-warrior@imagemagick.org>
Date:   Sun Nov 15 17:01:31 2026 -0500

    support non-square images

diff --git a/MagickCore/fourier.c b/MagickCore/fourier.c
index 2f3c6eea8..246776061 100644
--- a/MagickCore/fourier.c
+++ b/MagickCore/fourier.c
@@ -412,97 +412,52 @@ MagickExport Image *ComplexImages(const Image *images,const ComplexOperator op,

 #if defined(ENABLE_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)
+static MagickBooleanType ForwardQuadrantSwap(const size_t width,
+  const size_t height,const MagickBooleanType conjugate,
+  const double *source_pixels,double *forward_pixels)
 {
-  double
-    *source_pixels;
+  size_t
+    center;

-  MemoryInfo
-    *source_info;
+  double
+    value;

   ssize_t
-    i,
-    u,
-    v,
+    source_x,
+    source_y,
+    target_x,
+    target_y,
     x,
     y;

   /*
-    Move zero frequency (DC, average color) from (0,0) to (width/2,height/2).
+    Expand the Hermitian half-spectrum and center the zero-frequency pixel.
   */
-  source_info=AcquireVirtualMemory(width,height*sizeof(*source_pixels));
-  if (source_info == (MemoryInfo *) NULL)
-    return(MagickFalse);
-  source_pixels=(double *) GetVirtualMemoryBlob(source_info);
-  i=0L;
+  center=width/2+1;
   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;
+      if (x < (ssize_t) center)
+        {
+          source_x=x;
+          source_y=y;
+          value=source_pixels[source_y*(ssize_t) center+source_x];
+        }
       else
-        u=((x+x_offset) > ((ssize_t) width-1L)) ? x+x_offset-(ssize_t) width :
-          x+x_offset;
-      source_pixels[v*(ssize_t) width+u]=roll_pixels[i++];
+        {
+          source_x=(ssize_t) width-x;
+          source_y=((ssize_t) height-y) % (ssize_t) height;
+          value=source_pixels[source_y*(ssize_t) center+source_x];
+          if (conjugate != MagickFalse)
+            value=(-value);
+        }
+      target_x=(x+(ssize_t) (width/2)) % (ssize_t) width;
+      target_y=(y+(ssize_t) (height/2)) % (ssize_t) height;
+      forward_pixels[target_y*(ssize_t) width+target_x]=value;
     }
-  }
-  (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;
-
-  size_t
-    center;
-
-  ssize_t
-    x,
-    y;
-
-  /*
-    Swap quadrants.
-  */
-  center=width/2+1;
-  status=RollFourier(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*(ssize_t) width+x+(ssize_t) width/2L]=
-        source_pixels[y*(ssize_t) center+x];
-  for (y=1; y < (ssize_t) height; y++)
-    for (x=0L; x < (ssize_t) (width/2L); x++)
-      forward_pixels[((ssize_t) height-y)*(ssize_t) width+(ssize_t) width/2L-x-1L]=
-        source_pixels[y*(ssize_t) center+x+1L];
-  for (x=0L; x < (ssize_t) (width/2L); x++)
-    forward_pixels[(ssize_t) 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,
-    y;
-
-  for (y=0L; y < (ssize_t) height; y++)
-    for (x=0L; x < (ssize_t) (width/2L); x++)
-      fourier_pixels[y*(ssize_t) width+x]*=(-1.0);
-}
-
 static MagickBooleanType ForwardFourier(const FourierInfo *fourier_info,
   Image *image,double *magnitude,double *phase,ExceptionInfo *exception)
 {
@@ -566,11 +521,16 @@ static MagickBooleanType ForwardFourier(const FourierInfo *fourier_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);
+    MagickFalse,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);
+    status=ForwardQuadrantSwap(fourier_info->width,fourier_info->height,
+      MagickTrue,phase,phase_pixels);
+  if (status == MagickFalse)
+    {
+      phase_info=RelinquishVirtualMemory(phase_info);
+      magnitude_info=RelinquishVirtualMemory(magnitude_info);
+      return(MagickFalse);
+    }
   if (fourier_info->modulus != MagickFalse)
     {
       i=0L;
@@ -742,52 +702,58 @@ static MagickBooleanType ForwardFourierTransform(FourierInfo *fourier_info,
   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++)
+  for (y=0L; y < (ssize_t) image->rows; y++)
   {
-    p=GetCacheViewVirtualPixels(image_view,0L,y,fourier_info->width,1UL,
-      exception);
+    p=GetCacheViewVirtualPixels(image_view,0L,y,image->columns,1UL,exception);
     if (p == (const Quantum *) NULL)
-      break;
-    for (x=0L; x < (ssize_t) fourier_info->width; x++)
+      {
+        image_view=DestroyCacheView(image_view);
+        source_info=RelinquishVirtualMemory(source_info);
+        return(MagickFalse);
+      }
+    for (x=0L; x < (ssize_t) image->columns; x++)
     {
       switch (fourier_info->channel)
       {
         case RedPixelChannel:
         default:
         {
-          source_pixels[i]=QuantumScale*(double) GetPixelRed(image,p);
+          source_pixels[y*(ssize_t) fourier_info->width+x]=QuantumScale*
+            (double) GetPixelRed(image,p);
           break;
         }
         case GreenPixelChannel:
         {
-          source_pixels[i]=QuantumScale*(double) GetPixelGreen(image,p);
+          source_pixels[y*(ssize_t) fourier_info->width+x]=QuantumScale*
+            (double) GetPixelGreen(image,p);
           break;
         }
         case BluePixelChannel:
         {
-          source_pixels[i]=QuantumScale*(double) GetPixelBlue(image,p);
+          source_pixels[y*(ssize_t) fourier_info->width+x]=QuantumScale*
+            (double) GetPixelBlue(image,p);
           break;
         }
         case BlackPixelChannel:
         {
-          source_pixels[i]=QuantumScale*(double) GetPixelBlack(image,p);
+          source_pixels[y*(ssize_t) fourier_info->width+x]=QuantumScale*
+            (double) GetPixelBlack(image,p);
           break;
         }
         case AlphaPixelChannel:
         {
-          source_pixels[i]=QuantumScale*(double) GetPixelAlpha(image,p);
+          source_pixels[y*(ssize_t) fourier_info->width+x]=QuantumScale*
+            (double) GetPixelAlpha(image,p);
           break;
         }
       }
-      i++;
       p+=(ptrdiff_t) GetPixelChannels(image);
     }
   }
   image_view=DestroyCacheView(image_view);
-  forward_info=AcquireVirtualMemory(fourier_info->width,(fourier_info->height/2+
-    1)*sizeof(*forward_pixels));
+  forward_info=AcquireVirtualMemory(fourier_info->height,fourier_info->center*
+    sizeof(*forward_pixels));
   if (forward_info == (MemoryInfo *) NULL)
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
@@ -799,8 +765,8 @@ static MagickBooleanType ForwardFourierTransform(FourierInfo *fourier_info,
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickCore_ForwardFourierTransform)
 #endif
-  fftw_r2c_plan=fftw_plan_dft_r2c_2d((int) fourier_info->width,
-    (int) fourier_info->height,source_pixels,forward_pixels,FFTW_ESTIMATE);
+  fftw_r2c_plan=fftw_plan_dft_r2c_2d((int) fourier_info->height,
+    (int) fourier_info->width,source_pixels,forward_pixels,FFTW_ESTIMATE);
   if (fftw_r2c_plan == (fftw_plan) NULL)
     {
       forward_info=RelinquishVirtualMemory(forward_info);
@@ -878,21 +844,14 @@ static MagickBooleanType ForwardFourierTransformChannel(const Image *image,
     *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.width=image->columns+(image->columns & 0x01);
+  fourier_info.height=image->rows+(image->rows & 0x01);
   fourier_info.center=fourier_info.width/2+1;
   fourier_info.channel=channel;
   fourier_info.modulus=modulus;
-  magnitude_info=AcquireVirtualMemory(fourier_info.width,(fourier_info.height/2+
-    1)*sizeof(*magnitude_pixels));
-  phase_info=AcquireVirtualMemory(fourier_info.width,(fourier_info.height/2+1)*
+  magnitude_info=AcquireVirtualMemory(fourier_info.height,
+    fourier_info.center*sizeof(*magnitude_pixels));
+  phase_info=AcquireVirtualMemory(fourier_info.height,fourier_info.center*
     sizeof(*phase_pixels));
   if ((magnitude_info == (MemoryInfo *) NULL) ||
       (phase_info == (MemoryInfo *) NULL))
@@ -939,16 +898,8 @@ MagickExport Image *ForwardFourierTransformImage(const Image *image,
       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;
+    width=image->columns+(image->columns & 0x01);
+    height=image->rows+(image->rows & 0x01);
     magnitude_image=CloneImage(image,width,height,MagickTrue,exception);
     if (magnitude_image != (Image *) NULL)
       {
@@ -1094,32 +1045,6 @@ MagickExport Image *ForwardFourierTransformImage(const Image *image,
 */

 #if defined(ENABLE_FFTW_DELEGATE)
-static MagickBooleanType InverseQuadrantSwap(const size_t width,
-  const size_t height,const double *source,double *destination)
-{
-  size_t
-    center;
-
-  ssize_t
-    x,
-    y;
-
-  /*
-    Swap quadrants.
-  */
-  center=width/2+1;
-  for (y=1L; y < (ssize_t) height; y++)
-    for (x=0L; x < (ssize_t) (width/2L+1L); x++)
-      destination[((ssize_t) height-y)*(ssize_t) center-x+(ssize_t) width/2L]=
-        source[y*(ssize_t) width+x];
-  for (y=0L; y < (ssize_t) height; y++)
-    destination[y*(ssize_t) center]=
-      source[y*(ssize_t) width+(ssize_t) width/2L];
-  for (x=0L; x < (ssize_t) center; x++)
-    destination[x]=source[(ssize_t) 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)
@@ -1146,18 +1071,21 @@ static MagickBooleanType InverseFourier(FourierInfo *fourier_info,

   ssize_t
     i,
+    source_x,
+    source_y,
     x,
     y;

   /*
     Inverse fourier - read image and break down into a double array.
   */
+  status=MagickTrue;
   magnitude_info=AcquireVirtualMemory(fourier_info->width,fourier_info->height*
     sizeof(*magnitude_pixels));
   phase_info=AcquireVirtualMemory(fourier_info->width,fourier_info->height*
     sizeof(*phase_pixels));
-  inverse_info=AcquireVirtualMemory(fourier_info->width,(fourier_info->height/2+
-    1)*sizeof(*inverse_pixels));
+  inverse_info=AcquireVirtualMemory(fourier_info->height,
+    fourier_info->center*sizeof(*inverse_pixels));
   if ((magnitude_info == (MemoryInfo *) NULL) ||
       (phase_info == (MemoryInfo *) NULL) ||
       (inverse_info == (MemoryInfo *) NULL))
@@ -1183,7 +1111,10 @@ static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
     p=GetCacheViewVirtualPixels(magnitude_view,0L,y,fourier_info->width,1UL,
       exception);
     if (p == (const Quantum *) NULL)
-      break;
+      {
+        status=MagickFalse;
+        break;
+      }
     for (x=0L; x < (ssize_t) fourier_info->width; x++)
     {
       switch (fourier_info->channel)
@@ -1225,8 +1156,23 @@ static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
     }
   }
   magnitude_view=DestroyCacheView(magnitude_view);
-  status=InverseQuadrantSwap(fourier_info->width,fourier_info->height,
-    magnitude_pixels,inverse_pixels);
+  if (status == MagickFalse)
+    {
+      inverse_info=RelinquishVirtualMemory(inverse_info);
+      phase_info=RelinquishVirtualMemory(phase_info);
+      magnitude_info=RelinquishVirtualMemory(magnitude_info);
+      return(MagickFalse);
+    }
+  for (y=0L; y < (ssize_t) fourier_info->height; y++)
+    for (x=0L; x < (ssize_t) fourier_info->center; x++)
+    {
+      source_x=(x+(ssize_t) (fourier_info->width/2)) %
+        (ssize_t) fourier_info->width;
+      source_y=(y+(ssize_t) (fourier_info->height/2)) %
+        (ssize_t) fourier_info->height;
+      inverse_pixels[y*(ssize_t) fourier_info->center+x]=
+        magnitude_pixels[source_y*(ssize_t) fourier_info->width+source_x];
+    }
   (void) memcpy(magnitude_pixels,inverse_pixels,fourier_info->height*
     fourier_info->center*sizeof(*magnitude_pixels));
   i=0L;
@@ -1236,7 +1182,10 @@ static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
     p=GetCacheViewVirtualPixels(phase_view,0,y,fourier_info->width,1,
       exception);
     if (p == (const Quantum *) NULL)
-      break;
+      {
+        status=MagickFalse;
+        break;
+      }
     for (x=0L; x < (ssize_t) fourier_info->width; x++)
     {
       switch (fourier_info->channel)
@@ -1272,6 +1221,14 @@ static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
       p+=(ptrdiff_t) GetPixelChannels(phase_image);
     }
   }
+  phase_view=DestroyCacheView(phase_view);
+  if (status == MagickFalse)
+    {
+      inverse_info=RelinquishVirtualMemory(inverse_info);
+      phase_info=RelinquishVirtualMemory(phase_info);
+      magnitude_info=RelinquishVirtualMemory(magnitude_info);
+      return(MagickFalse);
+    }
   if (fourier_info->modulus != MagickFalse)
     {
       i=0L;
@@ -1283,11 +1240,16 @@ static MagickBooleanType InverseFourier(FourierInfo *fourier_info,
           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);
+  for (y=0L; y < (ssize_t) fourier_info->height; y++)
+    for (x=0L; x < (ssize_t) fourier_info->center; x++)
+    {
+      source_x=(x+(ssize_t) (fourier_info->width/2)) %
+        (ssize_t) fourier_info->width;
+      source_y=(y+(ssize_t) (fourier_info->height/2)) %
+        (ssize_t) fourier_info->height;
+      inverse_pixels[y*(ssize_t) fourier_info->center+x]=
+        phase_pixels[source_y*(ssize_t) fourier_info->width+source_x];
+    }
   (void) memcpy(phase_pixels,inverse_pixels,fourier_info->height*
     fourier_info->center*sizeof(*phase_pixels));
   inverse_info=RelinquishVirtualMemory(inverse_info);
@@ -1396,8 +1358,8 @@ static MagickBooleanType InverseFourierTransform(FourierInfo *fourier_info,
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickCore_InverseFourierTransform)
 #endif
-  fftw_c2r_plan=fftw_plan_dft_c2r_2d((int) fourier_info->width,
-    (int) fourier_info->height,fourier_pixels,source_pixels,FFTW_ESTIMATE);
+  fftw_c2r_plan=fftw_plan_dft_c2r_2d((int) fourier_info->height,
+    (int) fourier_info->width,fourier_pixels,source_pixels,FFTW_ESTIMATE);
   if (fftw_c2r_plan == (fftw_plan) NULL)
     {
       source_info=RelinquishVirtualMemory(source_info);
@@ -1484,20 +1446,11 @@ static MagickBooleanType InverseFourierTransformChannel(

   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=fourier_info.width/2+1;
   fourier_info.channel=channel;
   fourier_info.modulus=modulus;
-  inverse_info=AcquireVirtualMemory(fourier_info.width,(fourier_info.height/2+
-    1)*sizeof(*inverse_pixels));
+  inverse_info=AcquireVirtualMemory(fourier_info.height,
+    fourier_info.center*sizeof(*inverse_pixels));
   if (inverse_info == (MemoryInfo *) NULL)
     {
       (void) ThrowMagickException(exception,GetMagickModule(),
@@ -1534,6 +1487,13 @@ MagickExport Image *InverseFourierTransformImage(const Image *magnitude_image,
         "ImageSequenceRequired","`%s'",magnitude_image->filename);
       return((Image *) NULL);
     }
+  if ((magnitude_image->columns != phase_image->columns) ||
+      (magnitude_image->rows != phase_image->rows))
+    {
+      (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+        "ImageSizeDiffers","`%s'",magnitude_image->filename);
+      return((Image *) NULL);
+    }
 #if !defined(ENABLE_FFTW_DELEGATE)
   fourier_image=(Image *) NULL;
   (void) modulus;