(no commit message)

diff --git a/MagickCore/effect.c b/MagickCore/effect.c
index 826d9877768a9b2430b90d879a6a0b171eb01e13..92239c584615ee78f9a6c2995c8117db6c89b42d 100644 (file)
--- a/MagickCore/effect.c
+++ b/MagickCore/effect.c
@@ -1191,6 +1191,7 @@ MagickExport Image *BlurImage(const Image *image,const double radius,
 %
 %      Image *ConvolveImage(const Image *image,const size_t order,
 %        const double *kernel,ExceptionInfo *exception)
+%
 %  A description of each parameter follows:
 %
 %    o image: the image.
@@ -1223,9 +1224,6 @@ MagickExport Image *ConvolveImage(const Image *image,const size_t order,
   MagickOffsetType
     progress;
 
-  PixelInfo
-    bias;
-
   MagickRealType
     gamma;
 
@@ -1233,6 +1231,8 @@ MagickExport Image *ConvolveImage(const Image *image,const size_t order,
     i;
 
   size_t
+    convolve_components,
+    image_components,
     width;
 
   ssize_t
@@ -1312,18 +1312,15 @@ MagickExport Image *ConvolveImage(const Image *image,const size_t order,
   */
   status=MagickTrue;
   progress=0;
-  GetPixelInfo(image,&bias);
-  SetPixelInfoBias(image,&bias);
+  image_components=GetPixelComponents(image);
+  convolve_components=GetPixelComponents(convolve_image);
   image_view=AcquireCacheView(image);
   convolve_view=AcquireCacheView(convolve_image);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
-  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
+  #pragma omp parallel for schedule(dynamic,8) shared(progress,status)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
-    MagickBooleanType
-      sync;
-
     register const Quantum
       *restrict p;
 
@@ -1346,128 +1343,97 @@ MagickExport Image *ConvolveImage(const Image *image,const size_t order,
       }
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      PixelInfo
-        pixel;
+      const Quantum
+        *restrict kernel_pixels;
+
+      MagickRealType
+        pixel[MaxPixelComponents];
 
       register const double
         *restrict k;
 
-      register const Quantum
-        *restrict kernel_pixels;
-
       register ssize_t
         u;
 
       ssize_t
         v;
 
-      pixel=bias;
-      k=normal_kernel;
+      for (i=0; i < (ssize_t) image_components; i++)
+        pixel[i]=image->bias;
       kernel_pixels=p;
+      k=normal_kernel;
       if (((GetPixelAlphaTraits(image) & ActivePixelTrait) == 0) ||
           (image->matte == MagickFalse))
         {
+          /*
+            Convolve without blending alpha (optimization).
+          */
           for (v=0; v < (ssize_t) width; v++)
           {
             for (u=0; u < (ssize_t) width; u++)
             {
-              pixel.red+=(*k)*GetPixelRed(image,kernel_pixels+u*
-                GetPixelComponents(image));
-              pixel.green+=(*k)*GetPixelGreen(image,kernel_pixels+u*
-                GetPixelComponents(image));
-              pixel.blue+=(*k)*GetPixelBlue(image,kernel_pixels+u*
-                GetPixelComponents(image));
-              if (image->colorspace == CMYKColorspace)
-                pixel.black+=(*k)*GetPixelBlack(image,kernel_pixels+u*
-                  GetPixelComponents(image));
+              for (i=0; i < (ssize_t) image_components; i++)
+                if ((GetPixelTraits(image,i) & ActivePixelTrait) != 0)
+                  pixel[i]+=(*k)*kernel_pixels[u*image_components+i];
               k++;
             }
-            kernel_pixels+=(image->columns+width)*GetPixelComponents(image);
+            kernel_pixels+=(image->columns+width)*image_components;
+          }
+          for (i=0; i < (ssize_t) image_components; i++)
+          {
+            if (((GetPixelTraits(image,i) & ActivePixelTrait) != 0) &&
+                ((GetPixelTraits(convolve_image,i) & ActivePixelTrait) != 0))
+              q[i]=ClampToQuantum(pixel[i]);
           }
-          if ((GetPixelRedTraits(image) & ActivePixelTrait) != 0)
-            SetPixelRed(convolve_image,ClampToQuantum(pixel.red),q);
-          if ((GetPixelGreenTraits(image) & ActivePixelTrait) != 0)
-            SetPixelGreen(convolve_image,ClampToQuantum(pixel.green),q);
-          if ((GetPixelBlueTraits(image) & ActivePixelTrait) != 0)
-            SetPixelBlue(convolve_image,ClampToQuantum(pixel.blue),q);
-          if (((GetPixelBlackTraits(image) & ActivePixelTrait) != 0) &&
-              (image->colorspace == CMYKColorspace))
-            SetPixelBlack(convolve_image,ClampToQuantum(pixel.black),q);
-          if ((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0)
-            {
-              k=normal_kernel;
-              kernel_pixels=p;
-              for (v=0; v < (ssize_t) width; v++)
-              {
-                for (u=0; u < (ssize_t) width; u++)
-                {
-                  pixel.alpha+=(*k)*GetPixelAlpha(image,kernel_pixels+u*
-                    GetPixelComponents(image));
-                  k++;
-                }
-                kernel_pixels+=(image->columns+width)*GetPixelComponents(image);
-              }
-              SetPixelAlpha(convolve_image,ClampToQuantum(pixel.alpha),q);
-            }
         }
       else
         {
           MagickRealType
-            alpha,
             gamma;
 
+          /*
+            Convolve while blending alpha.
+          */
           gamma=0.0;
           for (v=0; v < (ssize_t) width; v++)
           {
             for (u=0; u < (ssize_t) width; u++)
             {
+              MagickRealType
+                alpha;
+
               alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(image,
-                kernel_pixels+u*GetPixelComponents(image)));
-              pixel.red+=(*k)*alpha*GetPixelRed(image,kernel_pixels+u*
-                GetPixelComponents(image));
-              pixel.green+=(*k)*alpha*GetPixelGreen(image,kernel_pixels+u*
-                GetPixelComponents(image));
-              pixel.blue+=(*k)*alpha*GetPixelBlue(image,kernel_pixels+u*
-                GetPixelComponents(image));
-              if (image->colorspace == CMYKColorspace)
-                pixel.black+=(*k)*alpha*GetPixelBlack(image,kernel_pixels+u*
-                  GetPixelComponents(image));
+                kernel_pixels+u*image_components));
+              for (i=0; i < (ssize_t) image_components; i++)
+                if ((GetPixelTraits(image,i) & ActivePixelTrait) != 0)
+                  {
+                    if ((GetPixelTraits(image,i) & BlendPixelTrait) == 0)
+                      pixel[i]+=(*k)*kernel_pixels[u*image_components+i];
+                    else
+                      pixel[i]+=(*k)*alpha*kernel_pixels[u*image_components+i];
+                  }
               gamma+=(*k)*alpha;
               k++;
             }
-            kernel_pixels+=(image->columns+width)*GetPixelComponents(image);
+            kernel_pixels+=(image->columns+width)*image_components;
           }
           gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
-          if ((GetPixelRedTraits(image) & ActivePixelTrait) != 0)
-            SetPixelRed(convolve_image,ClampToQuantum(gamma*pixel.red),q);
-          if ((GetPixelGreenTraits(image) & ActivePixelTrait) != 0)
-            SetPixelGreen(convolve_image,ClampToQuantum(gamma*pixel.green),q);
-          if ((GetPixelBlueTraits(image) & ActivePixelTrait) != 0)
-            SetPixelBlue(convolve_image,ClampToQuantum(gamma*pixel.blue),q);
-          if (((GetPixelBlackTraits(image) & ActivePixelTrait) != 0) &&
-              (image->colorspace == CMYKColorspace))
-            SetPixelBlack(convolve_image,ClampToQuantum(gamma*pixel.black),q);
-          if ((GetPixelAlphaTraits(image) & ActivePixelTrait) != 0)
-            {
-              k=normal_kernel;
-              kernel_pixels=p;
-              for (v=0; v < (ssize_t) width; v++)
+          for (i=0; i < (ssize_t) image_components; i++)
+          {
+            if (((GetPixelTraits(image,i) & ActivePixelTrait) != 0) &&
+                ((GetPixelTraits(convolve_image,i) & ActivePixelTrait) != 0))
               {
-                for (u=0; u < (ssize_t) width; u++)
-                {
-                  pixel.alpha+=(*k)*GetPixelAlpha(image,kernel_pixels+u);
-                  k++;
-                }
-                kernel_pixels+=(image->columns+width)*GetPixelComponents(image);
+                if ((GetPixelTraits(image,i) & BlendPixelTrait) != 0)
+                  q[i]=ClampToQuantum(gamma*pixel[i]);
+                else
+                  q[i]=ClampToQuantum(pixel[i]);
               }
-              SetPixelAlpha(convolve_image,ClampToQuantum(pixel.alpha),q);
-            }
+          }
         }
-      p+=GetPixelComponents(image);
-      q+=GetPixelComponents(convolve_image);
+      p+=image_components;
+      q+=convolve_components;
     }
-    sync=SyncCacheViewAuthenticPixels(convolve_view,exception);
-    if (sync == MagickFalse)
+    if (SyncCacheViewAuthenticPixels(convolve_view,exception) == MagickFalse)
       status=MagickFalse;
     if (image->progress_monitor != (MagickProgressMonitor) NULL)
       {

diff --git a/MagickCore/pixel-accessor.h b/MagickCore/pixel-accessor.h
index 6159c1fec7c419ac48378765745c739255e30001..5efc446950d7341ed3fddf561c543d1dc30b91da 100644 (file)
--- a/MagickCore/pixel-accessor.h
+++ b/MagickCore/pixel-accessor.h
@@ -208,7 +208,7 @@ static inline Quantum GetPixelPacketIntensity(const PixelPacket *pixel)
 #endif
 }
 
-static inline PixelTrait GetPixelComponentTraits(const Image *image,
+static inline PixelTrait GetPixelTraits(const Image *image,
   const PixelComponent component)
 {
   return(image->component_map[image->map][component].traits);

diff --git a/MagickCore/pixel.c b/MagickCore/pixel.c
index 26a1da053c8262b550d43986c5799da77f27b755..49c2f35691e169b3ab46ebc38d02b0d5428f7102 100644 (file)
--- a/MagickCore/pixel.c
+++ b/MagickCore/pixel.c
@@ -4579,23 +4579,27 @@ MagickExport void StandardPixelComponentMap(Image *image)
 {
   image->pixel_components=4;
   SetPixelComponent(image,RedPixelComponent,RedPixelComponent);
-  SetPixelComponentTraits(image,RedPixelComponent,ActivePixelTrait);
+  SetPixelComponentTraits(image,RedPixelComponent,ActivePixelTrait |
+    BlendPixelTrait);
   SetPixelComponent(image,GreenPixelComponent,GreenPixelComponent);
-  SetPixelComponentTraits(image,GreenPixelComponent,ActivePixelTrait);
+  SetPixelComponentTraits(image,GreenPixelComponent,ActivePixelTrait |
+    BlendPixelTrait);
   SetPixelComponent(image,BluePixelComponent,BluePixelComponent);
-  SetPixelComponentTraits(image,BluePixelComponent,ActivePixelTrait);
+  SetPixelComponentTraits(image,BluePixelComponent,ActivePixelTrait |
+    BlendPixelTrait);
   SetPixelComponent(image,AlphaPixelComponent,AlphaPixelComponent);
   SetPixelComponentTraits(image,AlphaPixelComponent,ActivePixelTrait);
   if (image->colorspace == CMYKColorspace)
     {
       image->pixel_components++;
       SetPixelComponent(image,BlackPixelComponent,BlackPixelComponent);
-      SetPixelComponentTraits(image,BlackPixelComponent,ActivePixelTrait);
+      SetPixelComponentTraits(image,BlackPixelComponent,ActivePixelTrait |
+        BlendPixelTrait);
     }
   if (image->storage_class == PseudoClass)
     {
       image->pixel_components++;
       SetPixelComponent(image,IndexPixelComponent,IndexPixelComponent);
-      SetPixelComponentTraits(image,IndexPixelComponent,ActivePixelTrait);
+      SetPixelComponentTraits(image,IndexPixelComponent,UndefinedPixelTrait);
     }
 }