]> granicus.if.org Git - imagemagick/blobdiff - MagickCore/decorate.c
projects / imagemagick / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix CLUT interpolation method
[imagemagick] / MagickCore / decorate.c
diff --git a/MagickCore/decorate.c b/MagickCore/decorate.c
index 6f12c2c66799bbeca89a3d1b3cec9024392a5f18..fde090785de95f201a70505a11af2d86170c91e5 100644 (file)
--- a/MagickCore/decorate.c
+++ b/MagickCore/decorate.c
@@ -17,7 +17,7 @@
 %                                   July 1992                                 %
 %                                                                             %
 %                                                                             %
-%  Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization      %
+%  Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization      %
 %  dedicated to making software imaging solutions freely available.           %
 %                                                                             %
 %  You may not use this file except in compliance with the License.  You may  %
@@ -185,7 +185,6 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
 
   PixelInfo
     accentuate,
-    border,
     highlight,
     interior,
     matte,
@@ -230,8 +229,12 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
       frame_image=DestroyImage(frame_image);
       return((Image *) NULL);
     }
-  if (frame_image->matte_color.alpha != OpaqueAlpha)
-    frame_image->matte=MagickTrue;
+  if ((IsGrayColorspace(image->colorspace) != MagickFalse) &&
+      (IsPixelInfoGray(&image->matte_color) == MagickFalse))
+    SetImageColorspace(frame_image,sRGBColorspace,exception);
+  if ((frame_image->border_color.matte != MagickFalse) &&
+      (frame_image->matte == MagickFalse))
+    (void) SetImageAlpha(frame_image,OpaqueAlpha,exception);
   frame_image->page=image->page;
   if ((image->page.width != 0) && (image->page.height != 0))
     {
@@ -241,39 +244,39 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
   /*
     Initialize 3D effects color.
   */
-  GetPixelInfo(frame_image,&interior);
-  SetPixelInfoPacket(frame_image,&image->border_color,&interior);
-  GetPixelInfo(frame_image,&matte);
-  matte.colorspace=RGBColorspace;
-  SetPixelInfoPacket(frame_image,&image->matte_color,&matte);
-  GetPixelInfo(frame_image,&border);
-  border.colorspace=RGBColorspace;
-  SetPixelInfoPacket(frame_image,&image->border_color,&border);
-  GetPixelInfo(frame_image,&accentuate);
+  interior=image->border_color;
+  matte=image->matte_color;
+  accentuate=matte;
   accentuate.red=(MagickRealType) (QuantumScale*((QuantumRange-
     AccentuateModulate)*matte.red+(QuantumRange*AccentuateModulate)));
   accentuate.green=(MagickRealType) (QuantumScale*((QuantumRange-
     AccentuateModulate)*matte.green+(QuantumRange*AccentuateModulate)));
   accentuate.blue=(MagickRealType) (QuantumScale*((QuantumRange-
     AccentuateModulate)*matte.blue+(QuantumRange*AccentuateModulate)));
+  accentuate.black=(MagickRealType) (QuantumScale*((QuantumRange-
+    AccentuateModulate)*matte.black+(QuantumRange*AccentuateModulate)));
   accentuate.alpha=matte.alpha;
-  GetPixelInfo(frame_image,&highlight);
+  highlight=matte;
   highlight.red=(MagickRealType) (QuantumScale*((QuantumRange-
     HighlightModulate)*matte.red+(QuantumRange*HighlightModulate)));
   highlight.green=(MagickRealType) (QuantumScale*((QuantumRange-
     HighlightModulate)*matte.green+(QuantumRange*HighlightModulate)));
   highlight.blue=(MagickRealType) (QuantumScale*((QuantumRange-
     HighlightModulate)*matte.blue+(QuantumRange*HighlightModulate)));
+  highlight.black=(MagickRealType) (QuantumScale*((QuantumRange-
+    HighlightModulate)*matte.black+(QuantumRange*HighlightModulate)));
   highlight.alpha=matte.alpha;
-  GetPixelInfo(frame_image,&shadow);
+  shadow=matte;
   shadow.red=QuantumScale*matte.red*ShadowModulate;
   shadow.green=QuantumScale*matte.green*ShadowModulate;
   shadow.blue=QuantumScale*matte.blue*ShadowModulate;
+  shadow.black=QuantumScale*matte.black*ShadowModulate;
   shadow.alpha=matte.alpha;
-  GetPixelInfo(frame_image,&trough);
+  trough=matte;
   trough.red=QuantumScale*matte.red*TroughModulate;
   trough.green=QuantumScale*matte.green*TroughModulate;
   trough.blue=QuantumScale*matte.blue*TroughModulate;
+  trough.black=QuantumScale*matte.black*TroughModulate;
   trough.alpha=matte.alpha;
   status=MagickTrue;
   progress=0;
@@ -304,14 +307,14 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
             for (x=0; x < (ssize_t) (frame_image->columns-y); x++)
             {
               if (x < y)
-                SetPixelPixelInfo(frame_image,&highlight,q);
+                SetPixelInfoPixel(frame_image,&highlight,q);
               else
-                SetPixelPixelInfo(frame_image,&accentuate,q);
+                SetPixelInfoPixel(frame_image,&accentuate,q);
               q+=GetPixelChannels(frame_image);
             }
             for ( ; x < (ssize_t) frame_image->columns; x++)
             {
-              SetPixelPixelInfo(frame_image,&shadow,q);
+              SetPixelInfoPixel(frame_image,&shadow,q);
               q+=GetPixelChannels(frame_image);
             }
           }
@@ -319,18 +322,18 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
           {
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelPixelInfo(frame_image,&highlight,q);
+              SetPixelInfoPixel(frame_image,&highlight,q);
               q+=GetPixelChannels(frame_image);
             }
             width=frame_image->columns-2*frame_info->outer_bevel;
             for (x=0; x < (ssize_t) width; x++)
             {
-              SetPixelPixelInfo(frame_image,&matte,q);
+              SetPixelInfoPixel(frame_image,&matte,q);
               q+=GetPixelChannels(frame_image);
             }
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelPixelInfo(frame_image,&shadow,q);
+              SetPixelInfoPixel(frame_image,&shadow,q);
               q+=GetPixelChannels(frame_image);
             }
           }
@@ -338,12 +341,12 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
           {
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelPixelInfo(frame_image,&highlight,q);
+              SetPixelInfoPixel(frame_image,&highlight,q);
               q+=GetPixelChannels(frame_image);
             }
             for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
             {
-              SetPixelPixelInfo(frame_image,&matte,q);
+              SetPixelInfoPixel(frame_image,&matte,q);
               q+=GetPixelChannels(frame_image);
             }
             width=image->columns+((size_t) frame_info->inner_bevel << 1)-
@@ -351,25 +354,25 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
             for (x=0; x < (ssize_t) width; x++)
             {
               if (x < y)
-                SetPixelPixelInfo(frame_image,&shadow,q);
+                SetPixelInfoPixel(frame_image,&shadow,q);
               else
-                SetPixelPixelInfo(frame_image,&trough,q);
+                SetPixelInfoPixel(frame_image,&trough,q);
               q+=GetPixelChannels(frame_image);
             }
             for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
             {
-              SetPixelPixelInfo(frame_image,&highlight,q);
+              SetPixelInfoPixel(frame_image,&highlight,q);
               q+=GetPixelChannels(frame_image);
             }
             width=frame_info->width-frame_info->x-image->columns-bevel_width;
             for (x=0; x < (ssize_t) width; x++)
             {
-              SetPixelPixelInfo(frame_image,&matte,q);
+              SetPixelInfoPixel(frame_image,&matte,q);
               q+=GetPixelChannels(frame_image);
             }
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelPixelInfo(frame_image,&shadow,q);
+              SetPixelInfoPixel(frame_image,&shadow,q);
               q+=GetPixelChannels(frame_image);
             }
           }
@@ -380,7 +383,7 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
     Draw sides of ornamental border.
   */
 #if defined(MAGICKCORE_OPENMP_SUPPORT) 
-  #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
+  #pragma omp parallel for schedule(static) shared(progress,status)
 #endif
   for (y=0; y < (ssize_t) image->rows; y++)
   {
@@ -390,6 +393,9 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
     register Quantum
       *restrict q;
 
+    size_t
+      width;
+
     /*
       Initialize scanline with matte color.
     */
@@ -404,17 +410,17 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
       }
     for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
     {
-      SetPixelPixelInfo(frame_image,&highlight,q);
+      SetPixelInfoPixel(frame_image,&highlight,q);
       q+=GetPixelChannels(frame_image);
     }
     for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
     {
-      SetPixelPixelInfo(frame_image,&matte,q);
+      SetPixelInfoPixel(frame_image,&matte,q);
       q+=GetPixelChannels(frame_image);
     }
     for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
     {
-      SetPixelPixelInfo(frame_image,&shadow,q);
+      SetPixelInfoPixel(frame_image,&shadow,q);
       q+=GetPixelChannels(frame_image);
     }
     /*
@@ -424,7 +430,7 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
         (image->matte != MagickFalse)))
       for (x=0; x < (ssize_t) image->columns; x++)
       {
-        SetPixelPixelInfo(frame_image,&interior,q);
+        SetPixelInfoPixel(frame_image,&interior,q);
         q+=GetPixelChannels(frame_image);
       }
     else
@@ -456,18 +462,18 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
       }
     for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
     {
-      SetPixelPixelInfo(frame_image,&highlight,q);
+      SetPixelInfoPixel(frame_image,&highlight,q);
       q+=GetPixelChannels(frame_image);
     }
     width=frame_info->width-frame_info->x-image->columns-bevel_width;
     for (x=0; x < (ssize_t) width; x++)
     {
-      SetPixelPixelInfo(frame_image,&matte,q);
+      SetPixelInfoPixel(frame_image,&matte,q);
       q+=GetPixelChannels(frame_image);
     }
     for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
     {
-      SetPixelPixelInfo(frame_image,&shadow,q);
+      SetPixelInfoPixel(frame_image,&shadow,q);
       q+=GetPixelChannels(frame_image);
     }
     if (SyncCacheViewAuthenticPixels(frame_view,exception) == MagickFalse)
@@ -478,7 +484,7 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
           proceed;
 
 #if defined(MAGICKCORE_OPENMP_SUPPORT) 
-  #pragma omp critical (MagickCore_FrameImage)
+        #pragma omp critical (MagickCore_FrameImage)
 #endif
         proceed=SetImageProgress(image,FrameImageTag,progress++,image->rows);
         if (proceed == MagickFalse)
@@ -509,36 +515,36 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
           {
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelPixelInfo(frame_image,&highlight,q);
+              SetPixelInfoPixel(frame_image,&highlight,q);
               q+=GetPixelChannels(frame_image);
             }
             for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
             {
-              SetPixelPixelInfo(frame_image,&matte,q);
+              SetPixelInfoPixel(frame_image,&matte,q);
               q+=GetPixelChannels(frame_image);
             }
             for (x=0; x < y; x++)
             {
-              SetPixelPixelInfo(frame_image,&shadow,q);
+              SetPixelInfoPixel(frame_image,&shadow,q);
               q+=GetPixelChannels(frame_image);
             }
             for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
             {
               if (x >= (ssize_t) (image->columns+2*frame_info->inner_bevel-y))
-                SetPixelPixelInfo(frame_image,&highlight,q);
+                SetPixelInfoPixel(frame_image,&highlight,q);
               else
-                SetPixelPixelInfo(frame_image,&accentuate,q);
+                SetPixelInfoPixel(frame_image,&accentuate,q);
               q+=GetPixelChannels(frame_image);
             }
             width=frame_info->width-frame_info->x-image->columns-bevel_width;
             for (x=0; x < (ssize_t) width; x++)
             {
-              SetPixelPixelInfo(frame_image,&matte,q);
+              SetPixelInfoPixel(frame_image,&matte,q);
               q+=GetPixelChannels(frame_image);
             }
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelPixelInfo(frame_image,&shadow,q);
+              SetPixelInfoPixel(frame_image,&shadow,q);
               q+=GetPixelChannels(frame_image);
             }
           }
@@ -547,18 +553,18 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
           {
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelPixelInfo(frame_image,&highlight,q);
+              SetPixelInfoPixel(frame_image,&highlight,q);
               q+=GetPixelChannels(frame_image);
             }
             width=frame_image->columns-2*frame_info->outer_bevel;
             for (x=0; x < (ssize_t) width; x++)
             {
-              SetPixelPixelInfo(frame_image,&matte,q);
+              SetPixelInfoPixel(frame_image,&matte,q);
               q+=GetPixelChannels(frame_image);
             }
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelPixelInfo(frame_image,&shadow,q);
+              SetPixelInfoPixel(frame_image,&shadow,q);
               q+=GetPixelChannels(frame_image);
             }
           }
@@ -566,15 +572,15 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
           {
             for (x=0; x < y; x++)
             {
-              SetPixelPixelInfo(frame_image,&highlight,q);
+              SetPixelInfoPixel(frame_image,&highlight,q);
               q+=GetPixelChannels(frame_image);
             }
             for ( ; x < (ssize_t) frame_image->columns; x++)
             {
               if (x >= (ssize_t) (frame_image->columns-y))
-                SetPixelPixelInfo(frame_image,&shadow,q);
+                SetPixelInfoPixel(frame_image,&shadow,q);
               else
-                SetPixelPixelInfo(frame_image,&trough,q);
+                SetPixelInfoPixel(frame_image,&trough,q);
               q+=GetPixelChannels(frame_image);
             }
           }
@@ -590,7 +596,8 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
         frame_info->inner_bevel);
       y=(ssize_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+
         frame_info->inner_bevel);
-      (void) CompositeImage(frame_image,compose,image,x,y,exception);
+      (void) CompositeImage(frame_image,image,compose,MagickTrue,x,y,
+        exception);
     }
   return(frame_image);
 }
@@ -680,13 +687,10 @@ MagickExport MagickBooleanType RaiseImage(Image *image,
   progress=0;
   image_view=AcquireCacheView(image);
 #if defined(MAGICKCORE_OPENMP_SUPPORT) 
-  #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
+  #pragma omp parallel for schedule(static) shared(progress,status)
 #endif
   for (y=0; y < (ssize_t) raise_info->height; y++)
   {
-    PixelTrait
-      traits;
-
     register ssize_t
       i,
       x;
@@ -704,37 +708,74 @@ MagickExport MagickBooleanType RaiseImage(Image *image,
       }
     for (x=0; x < y; x++)
     {
+      if (GetPixelMask(image,q) != 0)
+        {
+          q+=GetPixelChannels(image);
+          continue;
+        }
       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
       {
-        traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
-        if ((traits & UpdatePixelTrait) != 0)
-          q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
-            HighlightFactor+(MagickRealType) foreground*(QuantumRange-
-            HighlightFactor)));
+        PixelChannel
+          channel;
+
+        PixelTrait
+          traits;
+
+        channel=GetPixelChannelMapChannel(image,i);
+        traits=GetPixelChannelMapTraits(image,channel);
+        if ((traits & UpdatePixelTrait) == 0)
+          continue;
+        q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*HighlightFactor+
+          (MagickRealType) foreground*(QuantumRange-HighlightFactor)));
       }
       q+=GetPixelChannels(image);
     }
     for ( ; x < (ssize_t) (image->columns-y); x++)
     {
+      if (GetPixelMask(image,q) != 0)
+        {
+          q+=GetPixelChannels(image);
+          continue;
+        }
       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
       {
-        traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
-        if ((traits & UpdatePixelTrait) != 0)
-          q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
-            AccentuateFactor+(MagickRealType) foreground*(QuantumRange-
-            AccentuateFactor)));
+        PixelChannel
+          channel;
+
+        PixelTrait
+          traits;
+
+        channel=GetPixelChannelMapChannel(image,i);
+        traits=GetPixelChannelMapTraits(image,channel);
+        if ((traits & UpdatePixelTrait) == 0)
+          continue;
+        q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
+          AccentuateFactor+(MagickRealType) foreground*(QuantumRange-
+          AccentuateFactor)));
       }
       q+=GetPixelChannels(image);
     }
     for ( ; x < (ssize_t) image->columns; x++)
     {
+      if (GetPixelMask(image,q) != 0)
+        {
+          q+=GetPixelChannels(image);
+          continue;
+        }
       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
       {
-        traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
-        if ((traits & UpdatePixelTrait) != 0)
-          q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
-            ShadowFactor+(MagickRealType) background*(QuantumRange-
-            ShadowFactor)));
+        PixelChannel
+          channel;
+
+        PixelTrait
+          traits;
+
+        channel=GetPixelChannelMapChannel(image,i);
+        traits=GetPixelChannelMapTraits(image,channel);
+        if ((traits & UpdatePixelTrait) == 0)
+          continue;
+        q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*ShadowFactor+
+          (MagickRealType) background*(QuantumRange-ShadowFactor)));
       }
       q+=GetPixelChannels(image);
     }
@@ -751,13 +792,10 @@ MagickExport MagickBooleanType RaiseImage(Image *image,
       }
   }
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
-  #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
+  #pragma omp parallel for schedule(static) shared(progress,status)
 #endif
   for (y=(ssize_t) raise_info->height; y < (ssize_t) (image->rows-raise_info->height); y++)
   {
-    PixelTrait
-      traits;
-
     register ssize_t
       i,
       x;
@@ -775,13 +813,25 @@ MagickExport MagickBooleanType RaiseImage(Image *image,
       }
     for (x=0; x < (ssize_t) raise_info->width; x++)
     {
+      if (GetPixelMask(image,q) != 0)
+        {
+          q+=GetPixelChannels(image);
+          continue;
+        }
       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
       {
-        traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
-        if ((traits & UpdatePixelTrait) != 0)
-          q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
-            HighlightFactor+(MagickRealType) foreground*(QuantumRange-
-            HighlightFactor)));
+        PixelChannel
+          channel;
+
+        PixelTrait
+          traits;
+
+        channel=GetPixelChannelMapChannel(image,i);
+        traits=GetPixelChannelMapTraits(image,channel);
+        if ((traits & UpdatePixelTrait) == 0)
+          continue;
+        q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*HighlightFactor+
+          (MagickRealType) foreground*(QuantumRange-HighlightFactor)));
       }
       q+=GetPixelChannels(image);
     }
@@ -789,13 +839,25 @@ MagickExport MagickBooleanType RaiseImage(Image *image,
       q+=GetPixelChannels(image);
     for ( ; x < (ssize_t) image->columns; x++)
     {
+      if (GetPixelMask(image,q) != 0)
+        {
+          q+=GetPixelChannels(image);
+          continue;
+        }
       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
       {
-        traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
-        if ((traits & UpdatePixelTrait) != 0)
-          q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
-            ShadowFactor+(MagickRealType) background*(QuantumRange-
-            ShadowFactor)));
+        PixelChannel
+          channel;
+
+        PixelTrait
+          traits;
+
+        channel=GetPixelChannelMapChannel(image,i);
+        traits=GetPixelChannelMapTraits(image,channel);
+        if ((traits & UpdatePixelTrait) == 0)
+          continue;
+        q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*ShadowFactor+
+          (MagickRealType) background*(QuantumRange-ShadowFactor)));
       }
       q+=GetPixelChannels(image);
     }
@@ -812,13 +874,10 @@ MagickExport MagickBooleanType RaiseImage(Image *image,
       }
   }
 #if defined(MAGICKCORE_OPENMP_SUPPORT) 
-  #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
+  #pragma omp parallel for schedule(static) shared(progress,status)
 #endif
   for (y=(ssize_t) (image->rows-raise_info->height); y < (ssize_t) image->rows; y++)
   {
-    PixelTrait
-      traits;
-
     register ssize_t
       i,
       x;
@@ -836,13 +895,25 @@ MagickExport MagickBooleanType RaiseImage(Image *image,
       }
     for (x=0; x < (ssize_t) (image->rows-y); x++)
     {
+      if (GetPixelMask(image,q) != 0)
+        {
+          q+=GetPixelChannels(image);
+          continue;
+        }
       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
       {
-        traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
-        if ((traits & UpdatePixelTrait) != 0)
-          q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
-            HighlightFactor+(MagickRealType) foreground*(QuantumRange-
-            HighlightFactor)));
+        PixelChannel
+          channel;
+
+        PixelTrait
+          traits;
+
+        channel=GetPixelChannelMapChannel(image,i);
+        traits=GetPixelChannelMapTraits(image,channel);
+        if ((traits & UpdatePixelTrait) == 0)
+          continue;
+        q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*HighlightFactor+
+          (MagickRealType) foreground*(QuantumRange-HighlightFactor)));
       }
       q+=GetPixelChannels(image);
     }
@@ -850,23 +921,42 @@ MagickExport MagickBooleanType RaiseImage(Image *image,
     {
       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
       {
-        traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
-        if ((traits & UpdatePixelTrait) != 0)
-          q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
-            TroughFactor+(MagickRealType) background*(QuantumRange-
-            TroughFactor)));
+        PixelChannel
+          channel;
+
+        PixelTrait
+          traits;
+
+        channel=GetPixelChannelMapChannel(image,i);
+        traits=GetPixelChannelMapTraits(image,channel);
+        if ((traits & UpdatePixelTrait) == 0)
+          continue;
+        q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*TroughFactor+
+          (MagickRealType) background*(QuantumRange-TroughFactor)));
       }
       q+=GetPixelChannels(image);
     }
     for ( ; x < (ssize_t) image->columns; x++)
     {
+      if (GetPixelMask(image,q) != 0)
+        {
+          q+=GetPixelChannels(image);
+          continue;
+        }
       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
       {
-        traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
-        if ((traits & UpdatePixelTrait) != 0)
-          q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*
-            ShadowFactor+(MagickRealType) background*(QuantumRange-
-            ShadowFactor)));
+        PixelChannel
+          channel;
+
+        PixelTrait
+          traits;
+
+        channel=GetPixelChannelMapChannel(image,i);
+        traits=GetPixelChannelMapTraits(image,channel);
+        if ((traits & UpdatePixelTrait) == 0)
+          continue;
+        q[i]=ClampToQuantum(QuantumScale*((MagickRealType) q[i]*ShadowFactor+
+          (MagickRealType) background*(QuantumRange-ShadowFactor)));
       }
       q+=GetPixelChannels(image);
     }
@@ -878,7 +968,7 @@ MagickExport MagickBooleanType RaiseImage(Image *image,
           proceed;
 
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
-  #pragma omp critical (MagickCore_RaiseImage)
+        #pragma omp critical (MagickCore_RaiseImage)
 #endif
         proceed=SetImageProgress(image,RaiseImageTag,progress++,image->rows);
         if (proceed == MagickFalse)
Unnamed repository; edit this file 'description' to name the repository.