(no commit message)

diff --git a/MagickCore/effect.c b/MagickCore/effect.c
index cac7e00270fd05808bca850c67f0bf1cd4746eed..53dfba4e8137138a1a7ab41931b83befb775267c 100644 (file)
--- a/MagickCore/effect.c
+++ b/MagickCore/effect.c
@@ -1801,8 +1801,8 @@ MagickExport Image *EdgeImage(const Image *image,const double radius,
   Image
     *edge_image;
 
-  double
-    *kernel;
+  KernelInfo
+    *kernel_info;
 
   register ssize_t
     i;
@@ -1810,6 +1810,11 @@ MagickExport Image *EdgeImage(const Image *image,const double radius,
   size_t
     width;
 
+  ssize_t
+    j,
+    u,
+    v;
+
   assert(image != (const Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
@@ -1817,14 +1822,33 @@ MagickExport Image *EdgeImage(const Image *image,const double radius,
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
   width=GetOptimalKernelWidth1D(radius,0.5);
-  kernel=(double *) AcquireQuantumMemory((size_t) width,width*sizeof(*kernel));
-  if (kernel == (double *) NULL)
+  kernel_info=(KernelInfo *) AcquireMagickMemory(sizeof(*kernel_info));
+  if (kernel_info == (KernelInfo *) NULL)
     ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
-  for (i=0; i < (ssize_t) (width*width); i++)
-    kernel[i]=(-1.0);
-  kernel[i/2]=(double) (width*width-1.0);
-  edge_image=ConvolveImage(image,width,kernel,exception);
-  kernel=(double *) RelinquishMagickMemory(kernel);
+  (void) ResetMagickMemory(kernel_info,0,sizeof(*kernel_info));
+  kernel_info->width=width;
+  kernel_info->height=width;
+  kernel_info->signature=MagickSignature;
+  kernel_info->values=(double *) AcquireAlignedMemory(kernel_info->width,
+    kernel_info->width*sizeof(*kernel_info->values));
+  if (kernel_info->values == (double *) NULL)
+    {
+      kernel_info=DestroyKernelInfo(kernel_info);
+      ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
+    }
+  j=(ssize_t) kernel_info->width/2;
+  i=0;
+  for (v=(-j); v <= j; v++)
+  {
+    for (u=(-j); u <= j; u++)
+    {
+      kernel_info->values[i]=(-1.0);
+      i++;
+    }
+  }
+  kernel_info->values[i/2]=(double) (width*width-1.0);
+  edge_image=FilterImage(image,kernel_info,exception);
+  kernel_info=DestroyKernelInfo(kernel_info);
   return(edge_image);
 }
 \f
@@ -1864,12 +1888,12 @@ MagickExport Image *EdgeImage(const Image *image,const double radius,
 MagickExport Image *EmbossImage(const Image *image,const double radius,
   const double sigma,ExceptionInfo *exception)
 {
-  double
-    *kernel;
-
   Image
     *emboss_image;
 
+  KernelInfo
+    *kernel_info;
+
   register ssize_t
     i;
 
@@ -1882,36 +1906,47 @@ MagickExport Image *EmbossImage(const Image *image,const double radius,
     u,
     v;
 
-  assert(image != (Image *) NULL);
+  assert(image != (const Image *) NULL);
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
   width=GetOptimalKernelWidth2D(radius,sigma);
-  kernel=(double *) AcquireQuantumMemory((size_t) width,width*sizeof(*kernel));
-  if (kernel == (double *) NULL)
+  kernel_info=(KernelInfo *) AcquireMagickMemory(sizeof(*kernel_info));
+  if (kernel_info == (KernelInfo *) NULL)
     ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
-  j=(ssize_t) width/2;
+  (void) ResetMagickMemory(kernel_info,0,sizeof(*kernel_info));
+  kernel_info->width=width;
+  kernel_info->height=width;
+  kernel_info->signature=MagickSignature;
+  kernel_info->values=(double *) AcquireAlignedMemory(kernel_info->width,
+    kernel_info->width*sizeof(*kernel_info->values));
+  if (kernel_info->values == (double *) NULL)
+    {
+      kernel_info=DestroyKernelInfo(kernel_info);
+      ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
+    }
+  j=(ssize_t) kernel_info->width/2;
   k=j;
   i=0;
   for (v=(-j); v <= j; v++)
   {
     for (u=(-j); u <= j; u++)
     {
-      kernel[i]=(double) (((u < 0) || (v < 0) ? -8.0 : 8.0)*
+      kernel_info->values[i]=(double) (((u < 0) || (v < 0) ? -8.0 : 8.0)*
         exp(-((double) u*u+v*v)/(2.0*MagickSigma*MagickSigma))/
         (2.0*MagickPI*MagickSigma*MagickSigma));
       if (u != k)
-        kernel[i]=0.0;
+        kernel_info->values[i]=0.0;
       i++;
     }
     k--;
   }
-  emboss_image=ConvolveImage(image,width,kernel,exception);
+  emboss_image=FilterImage(image,kernel_info,exception);
+  kernel_info=DestroyKernelInfo(kernel_info);
   if (emboss_image != (Image *) NULL)
     (void) EqualizeImage(emboss_image);
-  kernel=(double *) RelinquishMagickMemory(kernel);
   return(emboss_image);
 }
 \f
@@ -1943,16 +1978,16 @@ MagickExport Image *EmbossImage(const Image *image,const double radius,
 %
 */
 MagickExport Image *FilterImage(const Image *image,
-  const KernelInfo *kernel,ExceptionInfo *exception)
+  const KernelInfo *kernel_info,ExceptionInfo *exception)
 {
-#define FilterImageTag  "Filter/Image"
+#define ConvolveImageTag  "Convolve/Image"
 
   CacheView
-    *filter_view,
+    *convolve_view,
     *image_view;
 
   Image
-    *filter_image;
+    *convolve_image;
 
   MagickBooleanType
     status;
@@ -1960,14 +1995,11 @@ MagickExport Image *FilterImage(const Image *image,
   MagickOffsetType
     progress;
 
-  PixelInfo
-    bias;
-
   ssize_t
     y;
 
   /*
-    Initialize filter image attributes.
+    Initialize convolve image attributes.
   */
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
@@ -1975,15 +2007,16 @@ MagickExport Image *FilterImage(const Image *image,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
-  if ((kernel->width % 2) == 0)
+  if ((kernel_info->width % 2) == 0)
     ThrowImageException(OptionError,"KernelWidthMustBeAnOddNumber");
-  filter_image=CloneImage(image,0,0,MagickTrue,exception);
-  if (filter_image == (Image *) NULL)
+  convolve_image=CloneImage(image,image->columns,image->rows,MagickTrue,
+    exception);
+  if (convolve_image == (Image *) NULL)
     return((Image *) NULL);
-  if (SetImageStorageClass(filter_image,DirectClass) == MagickFalse)
+  if (SetImageStorageClass(convolve_image,DirectClass) == MagickFalse)
     {
-      InheritException(exception,&filter_image->exception);
-      filter_image=DestroyImage(filter_image);
+      InheritException(exception,&convolve_image->exception);
+      convolve_image=DestroyImage(convolve_image);
       return((Image *) NULL);
     }
   if (image->debug != MagickFalse)
@@ -1995,21 +2028,23 @@ MagickExport Image *FilterImage(const Image *image,
       register const double
         *k;
 
+      register ssize_t
+        u;
+
       ssize_t
-        u,
         v;
 
       (void) LogMagickEvent(TransformEvent,GetMagickModule(),
-        "  FilterImage with %.20gx%.20g kernel:",(double) kernel->width,(double)
-        kernel->height);
+        "  ConvolveImage with %.20gx%.20g kernel:",(double) kernel_info->width,
+        (double) kernel_info->height);
       message=AcquireString("");
-      k=kernel->values;
-      for (v=0; v < (ssize_t) kernel->height; v++)
+      k=kernel_info->values;
+      for (v=0; v < (ssize_t) kernel_info->width; v++)
       {
         *message='\0';
         (void) FormatLocaleString(format,MaxTextExtent,"%.20g: ",(double) v);
         (void) ConcatenateString(&message,format);
-        for (u=0; u < (ssize_t) kernel->width; u++)
+        for (u=0; u < (ssize_t) kernel_info->height; u++)
         {
           (void) FormatLocaleString(format,MaxTextExtent,"%g ",*k++);
           (void) ConcatenateString(&message,format);
@@ -2018,26 +2053,18 @@ MagickExport Image *FilterImage(const Image *image,
       }
       message=DestroyString(message);
     }
-  status=AccelerateConvolveImage(image,kernel,filter_image,exception);
-  if (status == MagickTrue)
-    return(filter_image);
   /*
-    Filter image.
+    Convolve image.
   */
   status=MagickTrue;
   progress=0;
-  GetPixelInfo(image,&bias);
-  SetPixelInfoBias(image,&bias);
   image_view=AcquireCacheView(image);
-  filter_view=AcquireCacheView(filter_image);
+  convolve_view=AcquireCacheView(convolve_image);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
-    MagickBooleanType
-      sync;
-
     register const Quantum
       *restrict p;
 
@@ -2047,147 +2074,117 @@ MagickExport Image *FilterImage(const Image *image,
     register ssize_t
       x;
 
+    size_t
+      channels,
+      convolve_channels;
+
     if (status == MagickFalse)
       continue;
-    p=GetCacheViewVirtualPixels(image_view,-((ssize_t) kernel->width/2L),
-      y-(ssize_t) (kernel->height/2L),image->columns+kernel->width,
-      kernel->height,exception);
-    q=GetCacheViewAuthenticPixels(filter_view,0,y,filter_image->columns,1,
+    p=GetCacheViewVirtualPixels(image_view,-((ssize_t) kernel_info->width/2L),y-
+      (ssize_t) (kernel_info->height/2L),image->columns+kernel_info->width,
+      kernel_info->height,exception);
+    q=QueueCacheViewAuthenticPixels(convolve_view,0,y,convolve_image->columns,1,
       exception);
     if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
       {
         status=MagickFalse;
         continue;
       }
+    channels=GetPixelChannels(image);
+    convolve_channels=GetPixelChannels(convolve_image);
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      PixelInfo
-        pixel;
+      register ssize_t
+        i;
 
-      register const double
-        *restrict k;
+      for (i=0; i < (ssize_t) channels; i++)
+      {
+        MagickRealType
+          alpha,
+          gamma,
+          pixel;
 
-      register const Quantum
-        *restrict kernel_pixels;
+        PixelChannel
+          channel;
 
-      register ssize_t
-        u;
+        PixelTrait
+          convolve_traits,
+          traits;
 
-      ssize_t
-        v;
+        register const double
+          *restrict k;
 
-      pixel=bias;
-      k=kernel->values;
-      kernel_pixels=p;
-      if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) == 0) ||
-          (image->matte == MagickFalse))
-        {
-          for (v=0; v < (ssize_t) kernel->width; v++)
+        register const Quantum
+          *restrict kernel_pixels;
+
+        register ssize_t
+          u;
+
+        ssize_t
+          v;
+
+        traits=GetPixelChannelMapTraits(image,i);
+        if (traits == UndefinedPixelTrait)
+          continue;
+        channel=GetPixelChannelMapChannel(image,i);
+        convolve_traits=GetPixelChannelMapTraits(convolve_image,channel);
+        if (convolve_traits == UndefinedPixelTrait)
+          continue;
+        if ((convolve_traits & CopyPixelTrait) != 0)
           {
-            for (u=0; u < (ssize_t) kernel->height; u++)
-            {
-              pixel.red+=(*k)*GetPixelRed(image,kernel_pixels+u*
-                GetPixelChannels(image));
-              pixel.green+=(*k)*GetPixelGreen(image,kernel_pixels+u*
-                GetPixelChannels(image));
-              pixel.blue+=(*k)*GetPixelBlue(image,kernel_pixels+u*
-                GetPixelChannels(image));
-              if (image->colorspace == CMYKColorspace)
-                pixel.black+=(*k)*GetPixelBlack(image,kernel_pixels+u*
-                  GetPixelChannels(image));
-              k++;
-            }
-            kernel_pixels+=(image->columns+kernel->width)*
-              GetPixelChannels(image);
+            size_t
+              center;
+
+            center=((image->columns+kernel_info->width)*kernel_info->height/2)*
+              channels+i;
+            SetPixelChannel(convolve_image,channel,p[center],q);
+            continue;
           }
-          if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
-            SetPixelRed(filter_image,ClampToQuantum(pixel.red),q);
-          if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
-            SetPixelGreen(filter_image,ClampToQuantum(pixel.green),q);
-          if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
-            SetPixelBlue(filter_image,ClampToQuantum(pixel.blue),q);
-          if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) &&
-              (image->colorspace == CMYKColorspace))
-            SetPixelBlack(filter_image,ClampToQuantum(pixel.black),q);
-          if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
+        k=kernel_info->values;
+        kernel_pixels=p;
+        pixel=image->bias;
+        if (((convolve_traits & BlendPixelTrait) == 0) ||
+            (GetPixelAlphaTraits(image) == UndefinedPixelTrait) ||
+            (image->matte == MagickFalse))
+          {
+            /*
+              No alpha blending.
+            */
+            for (v=0; v < (ssize_t) kernel_info->width; v++)
             {
-              k=kernel->values;
-              kernel_pixels=p;
-              for (v=0; v < (ssize_t) kernel->width; v++)
+              for (u=0; u < (ssize_t) kernel_info->height; u++)
               {
-                for (u=0; u < (ssize_t) kernel->height; u++)
-                {
-                  pixel.alpha+=(*k)*GetPixelRed(image,kernel_pixels+u*
-                    GetPixelChannels(image));
-                  k++;
-                }
-                kernel_pixels+=(image->columns+kernel->width)*
-                  GetPixelChannels(image);
+                pixel+=(*k)*kernel_pixels[u*channels+i];
+                k++;
               }
-              SetPixelAlpha(filter_image,ClampToQuantum(pixel.alpha),q);
+              kernel_pixels+=(image->columns+kernel_info->width)*channels;
             }
-        }
-      else
+            SetPixelChannel(convolve_image,channel,ClampToQuantum(pixel),q);
+            continue;
+          }
+        /*
+          Alpha blending.
+        */
+        gamma=0.0;
+        for (v=0; v < (ssize_t) kernel_info->width; v++)
         {
-          MagickRealType
-            alpha,
-            gamma;
-
-          gamma=0.0;
-          for (v=0; v < (ssize_t) kernel->width; v++)
+          for (u=0; u < (ssize_t) kernel_info->height; u++)
           {
-            for (u=0; u < (ssize_t) kernel->height; u++)
-            {
-              alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(image,
-                kernel_pixels+u*GetPixelChannels(image)));
-              pixel.red+=(*k)*alpha*GetPixelRed(image,kernel_pixels+u*
-                GetPixelChannels(image));
-              pixel.green+=(*k)*alpha*GetPixelGreen(image,kernel_pixels+u*
-                GetPixelChannels(image));
-              pixel.blue+=(*k)*alpha*GetPixelBlue(image,kernel_pixels+u*
-                GetPixelChannels(image));
-              if (image->colorspace == CMYKColorspace)
-                pixel.black+=(*k)*alpha*GetPixelBlack(image,kernel_pixels+u*
-                  GetPixelChannels(image));
-              gamma+=(*k)*alpha;
-              k++;
-            }
-            kernel_pixels+=(image->columns+kernel->width)*
-              GetPixelChannels(image);
+            alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(image,
+              kernel_pixels+u*channels));
+            pixel+=(*k)*alpha*kernel_pixels[u*channels+i];
+            gamma+=(*k)*alpha;
+            k++;
           }
-          gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
-          if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
-            SetPixelRed(filter_image,ClampToQuantum(gamma*pixel.red),q);
-          if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
-            SetPixelGreen(filter_image,ClampToQuantum(gamma*pixel.green),q);
-          if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
-            SetPixelBlue(filter_image,ClampToQuantum(gamma*pixel.blue),q);
-          if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) &&
-              (image->colorspace == CMYKColorspace))
-            SetPixelBlack(filter_image,ClampToQuantum(gamma*pixel.black),q);
-          if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
-            {
-              k=kernel->values;
-              kernel_pixels=p;
-              for (v=0; v < (ssize_t) kernel->width; v++)
-              {
-                for (u=0; u < (ssize_t) kernel->height; u++)
-                {
-                  pixel.alpha+=(*k)*GetPixelAlpha(image,kernel_pixels+u*
-                    GetPixelChannels(image));
-                  k++;
-                }
-                kernel_pixels+=(image->columns+kernel->width)*
-                  GetPixelChannels(image);
-              }
-              SetPixelAlpha(filter_image,ClampToQuantum(pixel.alpha),q);
-            }
+          kernel_pixels+=(image->columns+kernel_info->width)*channels;
         }
-      p+=GetPixelChannels(image);
-      q+=GetPixelChannels(filter_image);
+        gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+        SetPixelChannel(convolve_image,channel,ClampToQuantum(gamma*pixel),q);
+      }
+      p+=channels;
+      q+=convolve_channels;
     }
-    sync=SyncCacheViewAuthenticPixels(filter_view,exception);
-    if (sync == MagickFalse)
+    if (SyncCacheViewAuthenticPixels(convolve_view,exception) == MagickFalse)
       status=MagickFalse;
     if (image->progress_monitor != (MagickProgressMonitor) NULL)
       {
@@ -2195,19 +2192,19 @@ MagickExport Image *FilterImage(const Image *image,
           proceed;
 
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
-  #pragma omp critical (MagickCore_FilterImage)
+  #pragma omp critical (MagickCore_ConvolveImage)
 #endif
-        proceed=SetImageProgress(image,FilterImageTag,progress++,image->rows);
+        proceed=SetImageProgress(image,ConvolveImageTag,progress++,image->rows);
         if (proceed == MagickFalse)
           status=MagickFalse;
       }
   }
-  filter_image->type=image->type;
-  filter_view=DestroyCacheView(filter_view);
+  convolve_image->type=image->type;
+  convolve_view=DestroyCacheView(convolve_view);
   image_view=DestroyCacheView(image_view);
   if (status == MagickFalse)
-    filter_image=DestroyImage(filter_image);
-  return(filter_image);
+    convolve_image=DestroyImage(convolve_image);
+  return(convolve_image);
 }
 \f
 /*
@@ -2243,15 +2240,15 @@ MagickExport Image *FilterImage(const Image *image,
 %    o exception: return any errors or warnings in this structure.
 %
 */
-MagickExport Image *GaussianBlurImage(const Image *image,
-  const double radius,const double sigma,ExceptionInfo *exception)
+MagickExport Image *GaussianBlurImage(const Image *image,const double radius,
+  const double sigma,ExceptionInfo *exception)
 {
-  double
-    *kernel;
-
   Image
     *blur_image;
 
+  KernelInfo
+    *kernel_info;
+
   register ssize_t
     i;
 
@@ -2270,19 +2267,33 @@ MagickExport Image *GaussianBlurImage(const Image *image,
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
   width=GetOptimalKernelWidth2D(radius,sigma);
-  kernel=(double *) AcquireQuantumMemory((size_t) width,width*sizeof(*kernel));
-  if (kernel == (double *) NULL)
+  kernel_info=(KernelInfo *) AcquireMagickMemory(sizeof(*kernel_info));
+  if (kernel_info == (KernelInfo *) NULL)
     ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
-  j=(ssize_t) width/2;
+  (void) ResetMagickMemory(kernel_info,0,sizeof(*kernel_info));
+  kernel_info->width=width;
+  kernel_info->height=width;
+  kernel_info->signature=MagickSignature;
+  kernel_info->values=(double *) AcquireAlignedMemory(kernel_info->width,
+    kernel_info->width*sizeof(*kernel_info->values));
+  if (kernel_info->values == (double *) NULL)
+    {
+      kernel_info=DestroyKernelInfo(kernel_info);
+      ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
+    }
+  j=(ssize_t) kernel_info->width/2;
   i=0;
   for (v=(-j); v <= j; v++)
   {
     for (u=(-j); u <= j; u++)
-      kernel[i++]=(double) (exp(-((double) u*u+v*v)/(2.0*MagickSigma*
-        MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
+    {
+      kernel_info->values[i]=(double) (exp(-((double) u*u+v*v)/(2.0*
+        MagickSigma*MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
+      i++;
+    }
   }
-  blur_image=ConvolveImage(image,width,kernel,exception);
-  kernel=(double *) RelinquishMagickMemory(kernel);
+  blur_image=FilterImage(image,kernel_info,exception);
+  kernel_info=DestroyKernelInfo(kernel_info);
   return(blur_image);
 }
 \f
@@ -3981,12 +3992,14 @@ MagickExport Image *SharpenImage(const Image *image,const double radius,
   const double sigma,ExceptionInfo *exception)
 {
   double
-    *kernel,
     normalize;
 
   Image
     *sharp_image;
 
+  KernelInfo
+    *kernel_info;
+
   register ssize_t
     i;
 
@@ -4005,25 +4018,36 @@ MagickExport Image *SharpenImage(const Image *image,const double radius,
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
   width=GetOptimalKernelWidth2D(radius,sigma);
-  kernel=(double *) AcquireQuantumMemory((size_t) width*width,sizeof(*kernel));
-  if (kernel == (double *) NULL)
+  kernel_info=(KernelInfo *) AcquireMagickMemory(sizeof(*kernel_info));
+  if (kernel_info == (KernelInfo *) NULL)
     ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
+  (void) ResetMagickMemory(kernel_info,0,sizeof(*kernel_info));
+  kernel_info->width=width;
+  kernel_info->height=width;
+  kernel_info->signature=MagickSignature;
+  kernel_info->values=(double *) AcquireAlignedMemory(kernel_info->width,
+    kernel_info->width*sizeof(*kernel_info->values));
+  if (kernel_info->values == (double *) NULL)
+    {
+      kernel_info=DestroyKernelInfo(kernel_info);
+      ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
+    }
   normalize=0.0;
-  j=(ssize_t) width/2;
+  j=(ssize_t) kernel_info->width/2;
   i=0;
   for (v=(-j); v <= j; v++)
   {
     for (u=(-j); u <= j; u++)
     {
-      kernel[i]=(double) (-exp(-((double) u*u+v*v)/(2.0*MagickSigma*
-        MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
-      normalize+=kernel[i];
+      kernel_info->values[i]=(double) (-exp(-((double) u*u+v*v)/(2.0*
+        MagickSigma*MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
+      normalize+=kernel_info->values[i];
       i++;
     }
   }
-  kernel[i/2]=(double) ((-2.0)*normalize);
-  sharp_image=ConvolveImage(image,width,kernel,exception);
-  kernel=(double *) RelinquishMagickMemory(kernel);
+  kernel_info->values[i/2]=(double) ((-2.0)*normalize);
+  sharp_image=FilterImage(image,kernel_info,exception);
+  kernel_info=DestroyKernelInfo(kernel_info);
   return(sharp_image);
 }
 \f

diff --git a/MagickCore/morphology.h b/MagickCore/morphology.h
index 70652d0f27cf26e798878d344c81788de6aaed30..7a74f1ae2b0dedf1702de917ce260123ca988b86 100644 (file)
--- a/MagickCore/morphology.h
+++ b/MagickCore/morphology.h
@@ -116,7 +116,8 @@ typedef struct KernelInfo
     maximum,
     negative_range,
     positive_range,
-    angle;
+    angle,
+    bias;
 
   struct KernelInfo
     *next;

diff --git a/MagickCore/version.h b/MagickCore/version.h
index 8155df25ebc72e6cb61c22420d8f9da33ac88fd7..db83fac386e68efabaae5e9bfa194a0354548675 100644 (file)
--- a/MagickCore/version.h
+++ b/MagickCore/version.h
@@ -34,7 +34,7 @@ extern "C" {
 #define MagickLibAddendum  "-0"
 #define MagickLibInterface  5
 #define MagickLibMinInterface  5
-#define MagickReleaseDate  "2011-07-11"
+#define MagickReleaseDate  "2011-07-15"
 #define MagickChangeDate   "20110701"
 #define MagickAuthoritativeURL  "http://www.imagemagick.org"
 #if defined(MAGICKCORE_OPENMP_SUPPORT)

diff --git a/MagickWand/mogrify.c b/MagickWand/mogrify.c
index d879a9a57b3a964132944c09ee2a5669854d68d4..d6d5302535a9529088dbd114cf8ac05f7c911b43 100644 (file)
--- a/MagickWand/mogrify.c
+++ b/MagickWand/mogrify.c
@@ -1194,27 +1194,18 @@ WandExport MagickBooleanType MogrifyImage(ImageInfo *image_info,const int argc,
           }
         if (LocaleCompare("convolve",option+1) == 0)
           {
-            double
-              gamma;
-
             KernelInfo
-              *kernel;
+              *kernel_info;
 
             register ssize_t
               j;
 
             (void) SyncImageSettings(mogrify_info,*image);
-            kernel=AcquireKernelInfo(argv[i+1]);
-            if (kernel == (KernelInfo *) NULL)
+            kernel_info=AcquireKernelInfo(argv[i+1]);
+            if (kernel_info == (KernelInfo *) NULL)
               break;
-            gamma=0.0;
-            for (j=0; j < (ssize_t) (kernel->width*kernel->height); j++)
-              gamma+=kernel->values[j];
-            gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
-            for (j=0; j < (ssize_t) (kernel->width*kernel->height); j++)
-              kernel->values[j]*=gamma;
-            mogrify_image=FilterImage(*image,kernel,exception);
-            kernel=DestroyKernelInfo(kernel);
+            mogrify_image=FilterImage(*image,kernel_info,exception);
+            kernel_info=DestroyKernelInfo(kernel_info);
             break;
           }
         if (LocaleCompare("crop",option+1) == 0)