diff --git a/MagickCore/effect.c b/MagickCore/effect.c
index 87b31c7..3fdfab1 100644
--- a/MagickCore/effect.c
+++ b/MagickCore/effect.c
@@ -879,7 +879,6 @@
     width;
 
   ssize_t
-    center,
     x,
     y;
 
@@ -892,7 +891,7 @@
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   assert(exception != (ExceptionInfo *) NULL);
   assert(exception->signature == MagickSignature);
-  blur_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);
+  blur_image=CloneImage(image,0,0,MagickTrue,exception);
   if (blur_image == (Image *) NULL)
     return((Image *) NULL);
   if (fabs(sigma) <= MagickEpsilon)
@@ -938,13 +937,12 @@
   */
   status=MagickTrue;
   progress=0;
-  center=(ssize_t) GetPixelChannels(image)*(width/2L);
   image_view=AcquireCacheView(image);
   blur_view=AcquireCacheView(blur_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++)
+  for (y=0; y < (ssize_t) blur_image->rows; y++)
   {
     register const Quantum
       *restrict p;
@@ -966,77 +964,105 @@
         status=MagickFalse;
         continue;
       }
-    for (x=0; x < (ssize_t) image->columns; x++)
+    for (x=0; x < (ssize_t) blur_image->columns; x++)
     {
+      PixelInfo
+        pixel;
+
+      register const double
+        *restrict k;
+
+      register const Quantum
+        *restrict kernel_pixels;
+
       register ssize_t
         i;
 
-      for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
-      {
-        MagickRealType
-          alpha,
-          gamma,
-          pixel;
-
-        PixelChannel
-          channel;
-
-        PixelTrait
-          blur_traits,
-          traits;
-
-        register const double
-          *restrict k;
-
-        register const Quantum
-          *restrict pixels;
-
-        register ssize_t
-          u;
-
-        traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
-        channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
-        blur_traits=GetPixelChannelMapTraits(blur_image,channel);
-        if ((traits == UndefinedPixelTrait) ||
-            (blur_traits == UndefinedPixelTrait))
-          continue;
-        if ((blur_traits & CopyPixelTrait) != 0)
-          {
-            q[channel]=p[center+i];
-            continue;
-          }
-        k=kernel;
-        pixels=p;
-        pixel=0.0;
-        if ((blur_traits & BlendPixelTrait) == 0)
-          {
-            /*
-              No alpha blending.
-            */
-            for (u=0; u < (ssize_t) width; u++)
-            {
-              pixel+=(*k)*pixels[i];
-              k++;
-              pixels+=GetPixelChannels(image);
-            }
-            q[channel]=ClampToQuantum(pixel);
-            continue;
-          }
-        /*
-          Alpha blending.
-        */
-        gamma=0.0;
-        for (u=0; u < (ssize_t) width; u++)
+      pixel.red=bias;
+      pixel.green=bias;
+      pixel.blue=bias;
+      pixel.black=bias;
+      pixel.alpha=bias;
+      k=kernel;
+      kernel_pixels=p;
+      if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) == 0) ||
+          (image->matte == MagickFalse))
         {
-          alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(image,pixels));
-          pixel+=(*k)*alpha*pixels[i];
-          gamma+=(*k)*alpha;
-          k++;
-          pixels+=GetPixelChannels(image);
+          for (i=0; i < (ssize_t) width; i++)
+          {
+            pixel.red+=(*k)*GetPixelRed(image,kernel_pixels);
+            pixel.green+=(*k)*GetPixelGreen(image,kernel_pixels);
+            pixel.blue+=(*k)*GetPixelBlue(image,kernel_pixels);
+            if (image->colorspace == CMYKColorspace)
+              pixel.black+=(*k)*GetPixelBlack(image,kernel_pixels);
+            k++;
+            kernel_pixels+=GetPixelChannels(image);
+          }
+          if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
+            SetPixelRed(blur_image,ClampToQuantum(pixel.red),q);
+          if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
+            SetPixelGreen(blur_image,ClampToQuantum(pixel.green),q);
+          if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
+            SetPixelBlue(blur_image,ClampToQuantum(pixel.blue),q);
+          if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) &&
+              (blur_image->colorspace == CMYKColorspace))
+            SetPixelBlack(blur_image,ClampToQuantum(pixel.black),q);
+          if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
+            {
+              k=kernel;
+              kernel_pixels=p;
+              for (i=0; i < (ssize_t) width; i++)
+              {
+                pixel.alpha+=(*k)*GetPixelAlpha(image,kernel_pixels);
+                k++;
+                kernel_pixels+=GetPixelChannels(image);
+              }
+              SetPixelAlpha(blur_image,ClampToQuantum(pixel.alpha),q);
+            }
         }
-        gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
-        q[channel]=ClampToQuantum(gamma*pixel);
-      }
+      else
+        {
+          MagickRealType
+            alpha,
+            gamma;
+
+          gamma=0.0;
+          for (i=0; i < (ssize_t) width; i++)
+          {
+            alpha=(MagickRealType) (QuantumScale*
+              GetPixelAlpha(image,kernel_pixels));
+            pixel.red+=(*k)*alpha*GetPixelRed(image,kernel_pixels);
+            pixel.green+=(*k)*alpha*GetPixelGreen(image,kernel_pixels);
+            pixel.blue+=(*k)*alpha*GetPixelBlue(image,kernel_pixels);
+            if (image->colorspace == CMYKColorspace)
+              pixel.black+=(*k)*alpha*GetPixelBlack(image,kernel_pixels);
+            gamma+=(*k)*alpha;
+            k++;
+            kernel_pixels+=GetPixelChannels(image);
+          }
+          gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+          if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
+            SetPixelRed(blur_image,ClampToQuantum(gamma*pixel.red),q);
+          if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
+            SetPixelGreen(blur_image,ClampToQuantum(gamma*pixel.green),q);
+          if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
+            SetPixelBlue(blur_image,ClampToQuantum(gamma*pixel.blue),q);
+          if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) &&
+              (blur_image->colorspace == CMYKColorspace))
+            SetPixelBlack(blur_image,ClampToQuantum(gamma*pixel.black),q);
+          if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
+            {
+              k=kernel;
+              kernel_pixels=p;
+              for (i=0; i < (ssize_t) width; i++)
+              {
+                pixel.alpha+=(*k)*GetPixelAlpha(image,kernel_pixels);
+                k++;
+                kernel_pixels+=GetPixelChannels(image);
+              }
+              SetPixelAlpha(blur_image,ClampToQuantum(pixel.alpha),q);
+            }
+        }
       p+=GetPixelChannels(image);
       q+=GetPixelChannels(blur_image);
     }
@@ -1066,7 +1092,7 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
 #endif
-  for (x=0; x < (ssize_t) image->columns; x++)
+  for (x=0; x < (ssize_t) blur_image->columns; x++)
   {
     register const Quantum
       *restrict p;
@@ -1087,78 +1113,106 @@
         status=MagickFalse;
         continue;
       }
-    for (y=0; y < (ssize_t) image->rows; y++)
+    for (y=0; y < (ssize_t) blur_image->rows; y++)
     {
+      PixelInfo
+        pixel;
+
+      register const double
+        *restrict k;
+
+      register const Quantum
+        *restrict kernel_pixels;
+
       register ssize_t
         i;
 
-      for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
-      {
-        MagickRealType
-          alpha,
-          gamma,
-          pixel;
-
-        PixelChannel
-          channel;
-
-        PixelTrait
-          blur_traits,
-          traits;
-
-        register const double
-          *restrict k;
-
-        register const Quantum
-          *restrict pixels;
-
-        register ssize_t
-          u;
-
-        traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
-        channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
-        blur_traits=GetPixelChannelMapTraits(blur_image,channel);
-        if ((traits == UndefinedPixelTrait) ||
-            (blur_traits == UndefinedPixelTrait))
-          continue;
-        if ((blur_traits & CopyPixelTrait) != 0)
-          {
-            q[channel]=p[center+i];
-            continue;
-          }
-        k=kernel;
-        pixels=p;
-        pixel=0.0;
-        if ((blur_traits & BlendPixelTrait) == 0)
-          {
-            /*
-              No alpha blending.
-            */
-            for (u=0; u < (ssize_t) width; u++)
-            {
-              pixel+=(*k)*pixels[i];
-              k++;
-              pixels+=GetPixelChannels(image);
-            }
-            q[channel]=ClampToQuantum(pixel);
-            continue;
-          }
-        /*
-          Alpha blending.
-        */
-        gamma=0.0;
-        for (u=0; u < (ssize_t) width; u++)
+      pixel.red=bias;
+      pixel.green=bias;
+      pixel.blue=bias;
+      pixel.black=bias;
+      pixel.alpha=bias;
+      k=kernel;
+      kernel_pixels=p;
+      if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) == 0) ||
+          (blur_image->matte == MagickFalse))
         {
-          alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(image,pixels));
-          pixel+=(*k)*alpha*pixels[i];
-          gamma+=(*k)*alpha;
-          k++;
-          pixels+=GetPixelChannels(image);
+          for (i=0; i < (ssize_t) width; i++)
+          {
+            pixel.red+=(*k)*GetPixelRed(blur_image,kernel_pixels);
+            pixel.green+=(*k)*GetPixelGreen(blur_image,kernel_pixels);
+            pixel.blue+=(*k)*GetPixelBlue(blur_image,kernel_pixels);
+            if (blur_image->colorspace == CMYKColorspace)
+              pixel.black+=(*k)*GetPixelBlack(blur_image,kernel_pixels);
+            k++;
+            kernel_pixels+=GetPixelChannels(blur_image);
+          }
+          if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
+            SetPixelRed(blur_image,ClampToQuantum(pixel.red),q);
+          if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
+            SetPixelGreen(blur_image,ClampToQuantum(pixel.green),q);
+          if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
+            SetPixelBlue(blur_image,ClampToQuantum(pixel.blue),q);
+          if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) &&
+              (blur_image->colorspace == CMYKColorspace))
+            SetPixelBlack(blur_image,ClampToQuantum(pixel.black),q);
+          if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
+            {
+              k=kernel;
+              kernel_pixels=p;
+              for (i=0; i < (ssize_t) width; i++)
+              {
+                pixel.alpha+=(*k)*GetPixelAlpha(blur_image,kernel_pixels);
+                k++;
+                kernel_pixels+=GetPixelChannels(blur_image);
+              }
+              SetPixelAlpha(blur_image,ClampToQuantum(pixel.alpha),q);
+            }
         }
-        gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
-        q[channel]=ClampToQuantum(gamma*pixel);
-      }
-      p+=GetPixelChannels(image);
+      else
+        {
+          MagickRealType
+            alpha,
+            gamma;
+
+          gamma=0.0;
+          for (i=0; i < (ssize_t) width; i++)
+          {
+            alpha=(MagickRealType) (QuantumScale*
+              GetPixelAlpha(blur_image,kernel_pixels));
+            pixel.red+=(*k)*alpha*GetPixelRed(blur_image,kernel_pixels);
+            pixel.green+=(*k)*alpha*GetPixelGreen(blur_image,kernel_pixels);
+            pixel.blue+=(*k)*alpha*GetPixelBlue(blur_image,kernel_pixels);
+            if (blur_image->colorspace == CMYKColorspace)
+              pixel.black+=(*k)*alpha*GetPixelBlack(blur_image,kernel_pixels);
+            gamma+=(*k)*alpha;
+            k++;
+            kernel_pixels+=GetPixelChannels(blur_image);
+          }
+          gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+          if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
+            SetPixelRed(blur_image,ClampToQuantum(gamma*pixel.red),q);
+          if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
+            SetPixelGreen(blur_image,ClampToQuantum(gamma*pixel.green),q);
+          if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
+            SetPixelBlue(blur_image,ClampToQuantum(gamma*pixel.blue),q);
+          if (((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0) &&
+              (blur_image->colorspace == CMYKColorspace))
+            SetPixelBlack(blur_image,ClampToQuantum(gamma*pixel.black),q);
+          if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
+            {
+              k=kernel;
+              kernel_pixels=p;
+              for (i=0; i < (ssize_t) width; i++)
+              {
+                pixel.alpha+=(*k)*GetPixelAlpha(blur_image,kernel_pixels);
+                k++;
+                kernel_pixels+=GetPixelChannels(blur_image);
+              }
+              SetPixelAlpha(blur_image,ClampToQuantum(pixel.alpha),q);
+            }
+        }
+      p+=GetPixelChannels(blur_image);
       q+=GetPixelChannels(blur_image);
     }
     if (SyncCacheViewAuthenticPixels(blur_view,exception) == MagickFalse)