http://www.imagemagick.org/discourse-server/viewtopic.php?f=3&t=26830

diff --git a/Magick++/lib/Image.cpp b/Magick++/lib/Image.cpp
index 437ef13f67a50dda33433000d31f9ab8efd4b274..de6c83f1bb2f76f6453813a8f14706323c0e181a 100644 (file)
--- a/Magick++/lib/Image.cpp
+++ b/Magick++/lib/Image.cpp
@@ -3640,7 +3640,7 @@ void Magick::Image::pixelColor(const ssize_t x_,const ssize_t y_,
     // Set pixel value
   pixel=pixels.get(x_, y_, 1, 1 );
   packet=color_;
-  MagickCore::SetPixelInfoPixel(constImage(),&packet,pixel);
+  MagickCore::SetPixelViaPixelInfo(constImage(),&packet,pixel);
   // Tell ImageMagick that pixels have been updated
   pixels.sync();
 }

diff --git a/MagickCore/channel.c b/MagickCore/channel.c
index 856425e14a9f5d29fb16989ebdeb5f19ad0f831e..5a5c68077a288f8a30c20f5eaa5e88ac4b2229f7 100644 (file)
--- a/MagickCore/channel.c
+++ b/MagickCore/channel.c
@@ -1042,7 +1042,7 @@ MagickExport MagickBooleanType SetImageAlphaChannel(Image *image,
         {
           if (GetPixelAlpha(image,q) == TransparentAlpha)
             {
-              SetPixelInfoPixel(image,&image->background_color,q);
+              SetPixelViaPixelInfo(image,&image->background_color,q);
               SetPixelChannel(image,AlphaPixelChannel,TransparentAlpha,q);
             }
           q+=GetPixelChannels(image);

diff --git a/MagickCore/color.c b/MagickCore/color.c
index c3301f365da4b76a93803970ff02215bab45841c..19d94d15df420662c5028d638350354bfb893c19 100644 (file)
--- a/MagickCore/color.c
+++ b/MagickCore/color.c
@@ -1844,11 +1844,11 @@ MagickPrivate MagickBooleanType IsEquivalentIntensity(const Image *image,
   register double
     distance;
 
-  if (GetPixelInfoIntensity(p) == GetPixelInfoIntensity(q))
+  if (GetPixelInfoIntensity(image,p) == GetPixelInfoIntensity(image,q))
     return(MagickTrue);
   fuzz=MagickMax(image->fuzz,MagickSQ1_2);
   fuzz*=fuzz;
-  pixel=GetPixelInfoIntensity(p)-GetPixelInfoIntensity(q);
+  pixel=GetPixelInfoIntensity(image,p)-GetPixelInfoIntensity(image,q);
   distance=pixel*pixel;
   if (distance > fuzz)
     return(MagickFalse);

diff --git a/MagickCore/colormap.c b/MagickCore/colormap.c
index 560d64baa70cfbb1f8f9a5179ac2b8aa8dbeed25..e84eee10c680edf9b3f44e0bae648769f1e56627 100644 (file)
--- a/MagickCore/colormap.c
+++ b/MagickCore/colormap.c
@@ -225,7 +225,7 @@ MagickExport MagickBooleanType CycleColormapImage(Image *image,
       if (index < 0)
         index+=(ssize_t) image->colors;
       SetPixelIndex(image,(Quantum) index,q);
-      SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+      SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
       q+=GetPixelChannels(image);
     }
     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
@@ -277,8 +277,8 @@ static int IntensityCompare(const void *x,const void *y)
 
   color_1=(const PixelInfo *) x;
   color_2=(const PixelInfo *) y;
-  intensity=(int) GetPixelInfoIntensity(color_2)-(int)
-    GetPixelInfoIntensity(color_1);
+  intensity=(int) GetPixelInfoIntensity((const Image *) NULL,color_2)-(int)
+    GetPixelInfoIntensity((const Image *) NULL,color_1);
   return(intensity);
 }
 
@@ -363,7 +363,7 @@ MagickExport MagickBooleanType SortColormapByIntensity(Image *image,
     {
       index=(Quantum) pixels[(ssize_t) GetPixelIndex(image,q)];
       SetPixelIndex(image,index,q);
-      SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+      SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
       q+=GetPixelChannels(image);
     }
     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)

diff --git a/MagickCore/colorspace.c b/MagickCore/colorspace.c
index 661fe28c25e6f3c4f89535aba34c913643848952..2442856d47cf2356ae32bba059fb6bb44bbcc8fa 100644 (file)
--- a/MagickCore/colorspace.c
+++ b/MagickCore/colorspace.c
@@ -309,7 +309,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
         {
           GetPixelInfoPixel(image,q,&pixel);
           ConvertRGBToCMYK(&pixel);
-          SetPixelInfoPixel(image,&pixel,q);
+          SetPixelViaPixelInfo(image,&pixel,q);
           q+=GetPixelChannels(image);
         }
         sync=SyncCacheViewAuthenticPixels(image_view,exception);
@@ -1654,7 +1654,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
         {
           GetPixelInfoPixel(image,q,&pixel);
           ConvertCMYKToRGB(&pixel);
-          SetPixelInfoPixel(image,&pixel,q);
+          SetPixelViaPixelInfo(image,&pixel,q);
           q+=GetPixelChannels(image);
         }
         sync=SyncCacheViewAuthenticPixels(image_view,exception);

diff --git a/MagickCore/compare.c b/MagickCore/compare.c
index 057a223edea1547920430876e25a6e3e50d05c8d..1eaa903727e29f48e338246486d0c9f1bf49adcf 100644 (file)
--- a/MagickCore/compare.c
+++ b/MagickCore/compare.c
@@ -255,7 +255,7 @@ MagickExport Image *CompareImages(Image *image,const Image *reconstruct_image,
 
       if (GetPixelReadMask(image,p) == 0)
         {
-          SetPixelInfoPixel(highlight_image,&lowlight,r);
+          SetPixelViaPixelInfo(highlight_image,&lowlight,r);
           p+=GetPixelChannels(image);
           q+=GetPixelChannels(reconstruct_image);
           r+=GetPixelChannels(highlight_image);
@@ -282,9 +282,9 @@ MagickExport Image *CompareImages(Image *image,const Image *reconstruct_image,
           difference=MagickTrue;
       }
       if (difference == MagickFalse)
-        SetPixelInfoPixel(highlight_image,&lowlight,r);
+        SetPixelViaPixelInfo(highlight_image,&lowlight,r);
       else
-        SetPixelInfoPixel(highlight_image,&highlight,r);
+        SetPixelViaPixelInfo(highlight_image,&highlight,r);
       p+=GetPixelChannels(image);
       q+=GetPixelChannels(reconstruct_image);
       r+=GetPixelChannels(highlight_image);

diff --git a/MagickCore/composite.c b/MagickCore/composite.c
index 2570f4f99bb0f1a329347a2ac89953352c2e8fe6..66644ae4882626d1643643d5df7b7e4ca9a118b7 100644 (file)
--- a/MagickCore/composite.c
+++ b/MagickCore/composite.c
@@ -908,7 +908,7 @@ if (0)
             blur.y2*QuantumScale*GetPixelGreen(composite_image,p) );
           (void) ResamplePixelColor(resample_filter,(double) x_offset+x,
             (double) y_offset+y,&pixel,exception);
-          SetPixelInfoPixel(destination_image,&pixel,q);
+          SetPixelViaPixelInfo(destination_image,&pixel,q);
           p+=GetPixelChannels(composite_image);
           q+=GetPixelChannels(destination_image);
         }
@@ -1087,7 +1087,7 @@ if (0)
           */
           pixel.alpha=(MagickRealType) QuantumRange*(1.0-(1.0-QuantumScale*
             pixel.alpha)*(1.0-QuantumScale*GetPixelAlpha(composite_image,p)));
-          SetPixelInfoPixel(destination_image,&pixel,q);
+          SetPixelViaPixelInfo(destination_image,&pixel,q);
           p+=GetPixelChannels(composite_image);
           q+=GetPixelChannels(destination_image);
         }

diff --git a/MagickCore/compress.c b/MagickCore/compress.c
index e5b18006a0e572662e3481c4df086ebf338d91ae..735c7fa67e25798c38efe8c102b3d51143bfab17 100644 (file)
--- a/MagickCore/compress.c
+++ b/MagickCore/compress.c
@@ -612,7 +612,7 @@ MagickExport MagickBooleanType HuffmanDecodeImage(Image *image,
     {
       index=(Quantum) (*p++);
       SetPixelIndex(image,index,q);
-      SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+      SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
       q+=GetPixelChannels(image);
     }
     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)

diff --git a/MagickCore/decorate.c b/MagickCore/decorate.c
index cc322f539243fbd0fefb41120449bda39b61fac5..5ef3c9a12252d22eb2ae22c23a249e94e1729c75 100644 (file)
--- a/MagickCore/decorate.c
+++ b/MagickCore/decorate.c
@@ -308,14 +308,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)
-                SetPixelInfoPixel(frame_image,&highlight,q);
+                SetPixelViaPixelInfo(frame_image,&highlight,q);
               else
-                SetPixelInfoPixel(frame_image,&accentuate,q);
+                SetPixelViaPixelInfo(frame_image,&accentuate,q);
               q+=GetPixelChannels(frame_image);
             }
             for ( ; x < (ssize_t) frame_image->columns; x++)
             {
-              SetPixelInfoPixel(frame_image,&shadow,q);
+              SetPixelViaPixelInfo(frame_image,&shadow,q);
               q+=GetPixelChannels(frame_image);
             }
           }
@@ -323,18 +323,18 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
           {
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelInfoPixel(frame_image,&highlight,q);
+              SetPixelViaPixelInfo(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++)
             {
-              SetPixelInfoPixel(frame_image,&matte,q);
+              SetPixelViaPixelInfo(frame_image,&matte,q);
               q+=GetPixelChannels(frame_image);
             }
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelInfoPixel(frame_image,&shadow,q);
+              SetPixelViaPixelInfo(frame_image,&shadow,q);
               q+=GetPixelChannels(frame_image);
             }
           }
@@ -342,12 +342,12 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
           {
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelInfoPixel(frame_image,&highlight,q);
+              SetPixelViaPixelInfo(frame_image,&highlight,q);
               q+=GetPixelChannels(frame_image);
             }
             for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
             {
-              SetPixelInfoPixel(frame_image,&matte,q);
+              SetPixelViaPixelInfo(frame_image,&matte,q);
               q+=GetPixelChannels(frame_image);
             }
             width=image->columns+((size_t) frame_info->inner_bevel << 1)-
@@ -355,25 +355,25 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
             for (x=0; x < (ssize_t) width; x++)
             {
               if (x < y)
-                SetPixelInfoPixel(frame_image,&shadow,q);
+                SetPixelViaPixelInfo(frame_image,&shadow,q);
               else
-                SetPixelInfoPixel(frame_image,&trough,q);
+                SetPixelViaPixelInfo(frame_image,&trough,q);
               q+=GetPixelChannels(frame_image);
             }
             for ( ; x < (ssize_t) (image->columns+2*frame_info->inner_bevel); x++)
             {
-              SetPixelInfoPixel(frame_image,&highlight,q);
+              SetPixelViaPixelInfo(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++)
             {
-              SetPixelInfoPixel(frame_image,&matte,q);
+              SetPixelViaPixelInfo(frame_image,&matte,q);
               q+=GetPixelChannels(frame_image);
             }
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelInfoPixel(frame_image,&shadow,q);
+              SetPixelViaPixelInfo(frame_image,&shadow,q);
               q+=GetPixelChannels(frame_image);
             }
           }
@@ -412,17 +412,17 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
       }
     for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
     {
-      SetPixelInfoPixel(frame_image,&highlight,q);
+      SetPixelViaPixelInfo(frame_image,&highlight,q);
       q+=GetPixelChannels(frame_image);
     }
     for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
     {
-      SetPixelInfoPixel(frame_image,&matte,q);
+      SetPixelViaPixelInfo(frame_image,&matte,q);
       q+=GetPixelChannels(frame_image);
     }
     for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
     {
-      SetPixelInfoPixel(frame_image,&shadow,q);
+      SetPixelViaPixelInfo(frame_image,&shadow,q);
       q+=GetPixelChannels(frame_image);
     }
     /*
@@ -432,7 +432,7 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
         (image->alpha_trait != UndefinedPixelTrait)))
       for (x=0; x < (ssize_t) image->columns; x++)
       {
-        SetPixelInfoPixel(frame_image,&interior,q);
+        SetPixelViaPixelInfo(frame_image,&interior,q);
         q+=GetPixelChannels(frame_image);
       }
     else
@@ -478,18 +478,18 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
       }
     for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)
     {
-      SetPixelInfoPixel(frame_image,&highlight,q);
+      SetPixelViaPixelInfo(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++)
     {
-      SetPixelInfoPixel(frame_image,&matte,q);
+      SetPixelViaPixelInfo(frame_image,&matte,q);
       q+=GetPixelChannels(frame_image);
     }
     for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
     {
-      SetPixelInfoPixel(frame_image,&shadow,q);
+      SetPixelViaPixelInfo(frame_image,&shadow,q);
       q+=GetPixelChannels(frame_image);
     }
     if (SyncCacheViewAuthenticPixels(frame_view,exception) == MagickFalse)
@@ -531,36 +531,36 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
           {
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelInfoPixel(frame_image,&highlight,q);
+              SetPixelViaPixelInfo(frame_image,&highlight,q);
               q+=GetPixelChannels(frame_image);
             }
             for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)
             {
-              SetPixelInfoPixel(frame_image,&matte,q);
+              SetPixelViaPixelInfo(frame_image,&matte,q);
               q+=GetPixelChannels(frame_image);
             }
             for (x=0; x < y; x++)
             {
-              SetPixelInfoPixel(frame_image,&shadow,q);
+              SetPixelViaPixelInfo(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))
-                SetPixelInfoPixel(frame_image,&highlight,q);
+                SetPixelViaPixelInfo(frame_image,&highlight,q);
               else
-                SetPixelInfoPixel(frame_image,&accentuate,q);
+                SetPixelViaPixelInfo(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++)
             {
-              SetPixelInfoPixel(frame_image,&matte,q);
+              SetPixelViaPixelInfo(frame_image,&matte,q);
               q+=GetPixelChannels(frame_image);
             }
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelInfoPixel(frame_image,&shadow,q);
+              SetPixelViaPixelInfo(frame_image,&shadow,q);
               q+=GetPixelChannels(frame_image);
             }
           }
@@ -569,18 +569,18 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
           {
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelInfoPixel(frame_image,&highlight,q);
+              SetPixelViaPixelInfo(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++)
             {
-              SetPixelInfoPixel(frame_image,&matte,q);
+              SetPixelViaPixelInfo(frame_image,&matte,q);
               q+=GetPixelChannels(frame_image);
             }
             for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)
             {
-              SetPixelInfoPixel(frame_image,&shadow,q);
+              SetPixelViaPixelInfo(frame_image,&shadow,q);
               q+=GetPixelChannels(frame_image);
             }
           }
@@ -588,15 +588,15 @@ MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,
           {
             for (x=0; x < y; x++)
             {
-              SetPixelInfoPixel(frame_image,&highlight,q);
+              SetPixelViaPixelInfo(frame_image,&highlight,q);
               q+=GetPixelChannels(frame_image);
             }
             for ( ; x < (ssize_t) frame_image->columns; x++)
             {
               if (x >= (ssize_t) (frame_image->columns-y))
-                SetPixelInfoPixel(frame_image,&shadow,q);
+                SetPixelViaPixelInfo(frame_image,&shadow,q);
               else
-                SetPixelInfoPixel(frame_image,&trough,q);
+                SetPixelViaPixelInfo(frame_image,&trough,q);
               q+=GetPixelChannels(frame_image);
             }
           }

diff --git a/MagickCore/display.c b/MagickCore/display.c
index 21d5788f8567ed963c75f760bf246b23861c95aa..0ab21cf10183638c7efcbb25f45c0b53d3ffff5d 100644 (file)
--- a/MagickCore/display.c
+++ b/MagickCore/display.c
@@ -13268,7 +13268,7 @@ static Image *XTileImage(Display *display,XResourceInfo *resource_info,
             break;
           for (j=0; j < (int) width; j++)
           {
-            SetPixelInfoPixel(image,&pixel,s);
+            SetPixelViaPixelInfo(image,&pixel,s);
             s+=GetPixelChannels(image);
           }
           if (IfMagickFalse(SyncCacheViewAuthenticPixels(image_view,exception)) )

diff --git a/MagickCore/distort.c b/MagickCore/distort.c
index 6f494a1e8d125df392b6cde39f7cbe48503fb582..f455aa93a285ecda67aa397e65b4d9cd55e0c2b1 100644 (file)
--- a/MagickCore/distort.c
+++ b/MagickCore/distort.c
@@ -2711,7 +2711,7 @@ if ( d.x == 0.5 && d.y == 0.5 ) {
 
         if ( validity <= 0.0 ) {
           /* result of distortion is an invalid pixel - don't resample */
-          SetPixelInfoPixel(distort_image,&invalid,q);
+          SetPixelViaPixelInfo(distort_image,&invalid,q);
         }
         else {
           /* resample the source image to find its correct color */
@@ -2724,7 +2724,7 @@ if ( d.x == 0.5 && d.y == 0.5 ) {
             CompositePixelInfoBlend(&pixel,validity,&invalid,(1.0-validity),
               &pixel);
           }
-          SetPixelInfoPixel(distort_image,&pixel,q);
+          SetPixelViaPixelInfo(distort_image,&pixel,q);
         }
         q+=GetPixelChannels(distort_image);
       }
@@ -3220,7 +3220,7 @@ MagickExport Image *SparseColorImage(const Image *image,
         if (((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0) &&
             (image->alpha_trait != UndefinedPixelTrait))
           pixel.alpha*=QuantumRange;
-        SetPixelInfoPixel(sparse_image,&pixel,q);
+        SetPixelViaPixelInfo(sparse_image,&pixel,q);
         q+=GetPixelChannels(sparse_image);
       }
       sync=SyncCacheViewAuthenticPixels(sparse_view,exception);

diff --git a/MagickCore/draw.c b/MagickCore/draw.c
index f2cb83524e378a10c30fac16488a990f4599a346..3be3eafe035545df472bef75f05e450c3f0d0f21 100644 (file)
--- a/MagickCore/draw.c
+++ b/MagickCore/draw.c
@@ -1192,7 +1192,7 @@ MagickExport MagickBooleanType DrawAffineImage(Image *image,
       GetPixelInfoPixel(image,q,&composite);
       CompositePixelInfoOver(&pixel,pixel.alpha,&composite,composite.alpha,
         &composite);
-      SetPixelInfoPixel(image,&composite,q);
+      SetPixelViaPixelInfo(image,&composite,q);
       x_offset++;
       q+=GetPixelChannels(image);
     }
@@ -3430,7 +3430,7 @@ MagickExport MagickBooleanType DrawGradientImage(Image *image,
       }
       CompositePixelInfoOver(&composite,composite.alpha,&pixel,pixel.alpha,
         &pixel);
-      SetPixelInfoPixel(image,&pixel,q);
+      SetPixelViaPixelInfo(image,&pixel,q);
       q+=GetPixelChannels(image);
     }
     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
@@ -3907,7 +3907,7 @@ RestoreMSCWarning
               (y == (ssize_t) ceil(primitive_info->point.y-0.5)))
             {
               (void) GetStrokeColor(draw_info,x,y,&pixel,exception);
-              SetPixelInfoPixel(image,&pixel,q);
+              SetPixelViaPixelInfo(image,&pixel,q);
             }
           q+=GetPixelChannels(image);
         }
@@ -4206,7 +4206,7 @@ MagickExport MagickBooleanType DrawPrimitive(Image *image,
             break;
           GetPixelInfo(image,&pixel);
           (void) GetFillColor(draw_info,x,y,&pixel,exception);
-          SetPixelInfoPixel(image,&pixel,q);
+          SetPixelViaPixelInfo(image,&pixel,q);
           (void) SyncCacheViewAuthenticPixels(image_view,exception);
           break;
         }
@@ -4239,7 +4239,7 @@ MagickExport MagickBooleanType DrawPrimitive(Image *image,
                   continue;
                 }
               (void) GetFillColor(draw_info,x,y,&pixel,exception);
-              SetPixelInfoPixel(image,&pixel,q);
+              SetPixelViaPixelInfo(image,&pixel,q);
               q+=GetPixelChannels(image);
             }
             sync=SyncCacheViewAuthenticPixels(image_view,exception);
@@ -4291,7 +4291,7 @@ MagickExport MagickBooleanType DrawPrimitive(Image *image,
             for (x=0; x < (ssize_t) image->columns; x++)
             {
               (void) GetFillColor(draw_info,x,y,&pixel,exception);
-              SetPixelInfoPixel(image,&pixel,q);
+              SetPixelViaPixelInfo(image,&pixel,q);
               q+=GetPixelChannels(image);
             }
             sync=SyncCacheViewAuthenticPixels(image_view,exception);

diff --git a/MagickCore/enhance.c b/MagickCore/enhance.c
index bc06d88565ebf2ca569bbcfcb4cbc5269685dc9e..d7ee3689a91ccd76a70a1e9b83440a3c5d2b861d 100644 (file)
--- a/MagickCore/enhance.c
+++ b/MagickCore/enhance.c
@@ -391,7 +391,7 @@ MagickExport MagickBooleanType ClutImage(Image *image,const Image *clut_image,
         ClampToQuantum(pixel.black))].black;
       pixel.alpha=clut_map[ScaleQuantumToMap(
         ClampToQuantum(pixel.alpha))].alpha;
-      SetPixelInfoPixel(image,&pixel,q);
+      SetPixelViaPixelInfo(image,&pixel,q);
       q+=GetPixelChannels(image);
     }
     if( IfMagickFalse(SyncCacheViewAuthenticPixels(image_view,exception)) )

diff --git a/MagickCore/fx.c b/MagickCore/fx.c
index e5b5dfba6b4dcce9a3f11a95d4d2970a96b50a82..38b4e33aa8df5650e5739848dbda5a17be78f6f1 100644 (file)
--- a/MagickCore/fx.c
+++ b/MagickCore/fx.c
@@ -1006,7 +1006,7 @@ MagickExport Image *ColorMatrixImage(const Image *image,
           default: break;
         }
       }
-      SetPixelInfoPixel(color_image,&pixel,q);
+      SetPixelViaPixelInfo(color_image,&pixel,q);
       p+=GetPixelChannels(image);
       q+=GetPixelChannels(color_image);
     }
@@ -1488,7 +1488,13 @@ static double FxGetSymbol(FxInfo *fx_info,const PixelChannel channel,
         case IndexPixelChannel:
           return(0.0);
         case IntensityPixelChannel:
-          return(QuantumScale*GetPixelInfoIntensity(&pixel));
+        {
+          Quantum
+            quantum_pixel[MaxPixelChannels];
+
+          SetPixelViaPixelInfo(image,&pixel,quantum_pixel);
+          return(QuantumScale*GetPixelIntensity(image,quantum_pixel));
+        }
         default:
           break;
       }
@@ -1666,7 +1672,13 @@ static double FxGetSymbol(FxInfo *fx_info,const PixelChannel channel,
       if (LocaleCompare(symbol,"image.resolution.y") == 0)
         return(image->resolution.y);
       if (LocaleCompare(symbol,"intensity") == 0)
-        return(QuantumScale*GetPixelInfoIntensity(&pixel));
+        {
+          Quantum
+            quantum_pixel[MaxPixelChannels];
+
+          SetPixelViaPixelInfo(image,&pixel,quantum_pixel);
+          return(QuantumScale*GetPixelIntensity(image,quantum_pixel));
+        }
       if (LocaleCompare(symbol,"i") == 0)
         return((double) x);
       break;
@@ -4318,7 +4330,7 @@ MagickExport Image *ShadowImage(const Image *image,const double alpha,
     {
       if (border_image->alpha_trait != UndefinedPixelTrait)
         background_color.alpha=GetPixelAlpha(border_image,q)*alpha/100.0;
-      SetPixelInfoPixel(border_image,&background_color,q);
+      SetPixelViaPixelInfo(border_image,&background_color,q);
       q+=GetPixelChannels(border_image);
     }
     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
@@ -4776,19 +4788,19 @@ MagickExport Image *SteganoImage(const Image *image,const Image *watermark,
           case 0:
           {
             SetPixelRed(stegano_image,SetBit(GetPixelRed(stegano_image,q),j,
-              GetBit(GetPixelInfoIntensity(&pixel),i)),q);
+              GetBit(GetPixelInfoIntensity(stegano_image,&pixel),i)),q);
             break;
           }
           case 1:
           {
             SetPixelGreen(stegano_image,SetBit(GetPixelGreen(stegano_image,q),j,
-              GetBit(GetPixelInfoIntensity(&pixel),i)),q);
+              GetBit(GetPixelInfoIntensity(stegano_image,&pixel),i)),q);
             break;
           }
           case 2:
           {
             SetPixelBlue(stegano_image,SetBit(GetPixelBlue(stegano_image,q),j,
-              GetBit(GetPixelInfoIntensity(&pixel),i)),q);
+              GetBit(GetPixelInfoIntensity(stegano_image,&pixel),i)),q);
             break;
           }
         }
@@ -5280,7 +5292,7 @@ MagickExport Image *TintImage(const Image *image,const char *blend,
       if ((flags & ChiValue) != 0)
         color_vector.alpha=geometry_info.chi;
     }
-  intensity=(double) GetPixelInfoIntensity(tint);
+  intensity=(double) GetPixelInfoIntensity(image,tint);
   color_vector.red=(double) (color_vector.red*tint->red/100.0-intensity);
   color_vector.green=(double) (color_vector.green*tint->green/100.0-intensity);
   color_vector.blue=(double) (color_vector.blue*tint->blue/100.0-intensity);
@@ -5357,7 +5369,7 @@ MagickExport Image *TintImage(const Image *image,const char *blend,
       weight=QuantumScale*GetPixelBlack(image,p)-0.5;
       pixel.black=(double) GetPixelBlack(image,p)+color_vector.black*(1.0-(4.0*
         (weight*weight)));
-      SetPixelInfoPixel(tint_image,&pixel,q);
+      SetPixelViaPixelInfo(tint_image,&pixel,q);
       p+=GetPixelChannels(image);
       q+=GetPixelChannels(tint_image);
     }

diff --git a/MagickCore/image.c b/MagickCore/image.c
index a64d679406bc16571fd6ac4004d15ee5f81ef1de..2c24d2977e5a54ce14b01f515a1dfeeb01555204 100644 (file)
--- a/MagickCore/image.c
+++ b/MagickCore/image.c
@@ -585,7 +585,7 @@ MagickExport Image *AppendImages(const Image *images,
             continue;
           }
         GetPixelInfoPixel(image,p,&pixel);
-        SetPixelInfoPixel(append_image,&pixel,q);
+        SetPixelViaPixelInfo(append_image,&pixel,q);
         p+=GetPixelChannels(image);
         q+=GetPixelChannels(append_image);
       }
@@ -1919,7 +1919,7 @@ MagickExport Image *NewMagickImage(const ImageInfo *image_info,
       }
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      SetPixelInfoPixel(image,background,q);
+      SetPixelViaPixelInfo(image,background,q);
       q+=GetPixelChannels(image);
     }
     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
@@ -2107,7 +2107,7 @@ MagickExport MagickBooleanType SetImageBackgroundColor(Image *image,
       }
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      SetPixelInfoPixel(image,&background,q);
+      SetPixelViaPixelInfo(image,&background,q);
       q+=GetPixelChannels(image);
     }
     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
@@ -2227,7 +2227,7 @@ MagickExport MagickBooleanType SetImageColor(Image *image,
       }
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      SetPixelInfoPixel(image,color,q);
+      SetPixelViaPixelInfo(image,color,q);
       q+=GetPixelChannels(image);
     }
     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
@@ -3369,7 +3369,7 @@ MagickExport MagickBooleanType SyncImage(Image *image,ExceptionInfo *exception)
     for (x=0; x < (ssize_t) image->columns; x++)
     {
       index=PushColormapIndex(image,GetPixelIndex(image,q),&range_exception);
-      SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+      SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
       q+=GetPixelChannels(image);
     }
     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)

diff --git a/MagickCore/paint.c b/MagickCore/paint.c
index 81064df5ebef4bcb1823394be89531cd6732559d..f6334a75038b1811dcba203997f1194c0e49a2da 100644 (file)
--- a/MagickCore/paint.c
+++ b/MagickCore/paint.c
@@ -352,7 +352,7 @@ MagickExport MagickBooleanType FloodfillPaintImage(Image *image,
       if (GetPixelGray(floodplane_image,p) != 0)
         {
           (void) GetFillColor(draw_info,x,y,&fill_color,exception);
-          SetPixelInfoPixel(image,&fill_color,q);
+          SetPixelViaPixelInfo(image,&fill_color,q);
         }
       p+=GetPixelChannels(floodplane_image);
       q+=GetPixelChannels(image);
@@ -827,7 +827,7 @@ MagickExport MagickBooleanType OpaquePaintImage(Image *image,
     {
       GetPixelInfoPixel(image,q,&pixel);
       if (IsFuzzyEquivalencePixelInfo(&pixel,&conform_target) != invert)
-        SetPixelInfoPixel(image,&conform_fill,q);
+        SetPixelViaPixelInfo(image,&conform_fill,q);
       q+=GetPixelChannels(image);
     }
     if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)

diff --git a/MagickCore/pixel-accessor.h b/MagickCore/pixel-accessor.h
index f1da4c263a478fb70582293f10b84c13dbfcfa26..2b9b0603baf4cab0ff1a6528e74c3c3b6ce5e60c 100644 (file)
--- a/MagickCore/pixel-accessor.h
+++ b/MagickCore/pixel-accessor.h
@@ -194,15 +194,6 @@ static inline MagickRealType GetPixelInfoChannel(
   }
 }
 
-static inline MagickRealType GetPixelInfoIntensity(
-  const PixelInfo *restrict pixel_info)
-{
-  if (pixel_info->colorspace == GRAYColorspace)
-    return(pixel_info->red);
-  return(0.212656f*pixel_info->red+0.715158f*pixel_info->green+0.072186f*
-    pixel_info->blue);
-}
-
 static inline MagickRealType GetPixelInfoLuma(const PixelInfo *restrict pixel)
 {
   MagickRealType
@@ -696,7 +687,7 @@ static inline void SetPixelIndexTraits(Image *image,const PixelTrait traits)
   image->channel_map[IndexPixelChannel].traits=traits;
 }
 
-static inline void SetPixelInfoPixel(const Image *restrict image,
+static inline void SetPixelViaPixelInfo(const Image *restrict image,
   const PixelInfo *restrict pixel_info,Quantum *restrict pixel)
 {
   pixel[image->channel_map[RedPixelChannel].offset]=

diff --git a/MagickCore/pixel.c b/MagickCore/pixel.c
index 33f98f8698889174c5a56eb2c5be6dc129432319..c43c3489b08bac449818eac18115ca0429a5f107 100644 (file)
--- a/MagickCore/pixel.c
+++ b/MagickCore/pixel.c
@@ -2185,6 +2185,140 @@ MagickExport void GetPixelInfo(const Image *image,PixelInfo *pixel)
 %                                                                             %
 %                                                                             %
 %                                                                             %
+%   G e t P i x e l I n d o I n t e n s i t y                                 %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  GetPixelInfoIntensity() returns a single sample intensity value from the red,
+%  green, and blue components of a pixel based on the selected method:
+%
+%    Rec601Luma       0.298839R' + 0.586811G' + 0.114350B'
+%    Rec601Luminance  0.298839R + 0.586811G + 0.114350B
+%    Rec709Luma       0.212656R' + 0.715158G' + 0.072186B'
+%    Rec709Luminance  0.212656R + 0.715158G + 0.072186B
+%    Brightness       max(R', G', B')
+%    Lightness        (min(R', G', B') + max(R', G', B')) / 2.0
+%
+%    MS               (R^2 + G^2 + B^2) / 3.0
+%    RMS              sqrt((R^2 + G^2 + B^2) / 3.0
+%    Average          (R + G + B') / 3.0
+%
+%  The format of the GetPixelInfoIntensity method is:
+%
+%      MagickRealType GetPixelInfoIntensity(const Image *image,
+%        const Quantum *pixel)
+%
+%  A description of each parameter follows:
+%
+%    o image: the image.
+%
+%    o pixel: Specifies a pointer to a Quantum structure.
+%
+*/
+MagickExport MagickRealType GetPixelInfoIntensity(const Image *restrict image,
+  const PixelInfo *restrict pixel)
+{
+  MagickRealType
+    blue,
+    green,
+    red,
+    intensity;
+
+  PixelIntensityMethod
+    method;
+
+  method=Rec709LumaPixelIntensityMethod;
+  if (image != (const Image *) NULL)
+    method=image->intensity;
+  red=pixel->red;
+  green=pixel->green;
+  blue=pixel->blue;
+  switch (method)
+  {
+    case AveragePixelIntensityMethod:
+    {
+      intensity=(red+green+blue)/3.0;
+      break;
+    }
+    case BrightnessPixelIntensityMethod:
+    {
+      intensity=MagickMax(MagickMax(red,green),blue);
+      break;
+    }
+    case LightnessPixelIntensityMethod:
+    {
+      intensity=(MagickMin(MagickMin(red,green),blue)+
+        MagickMax(MagickMax(red,green),blue))/2.0;
+      break;
+    }
+    case MSPixelIntensityMethod:
+    {
+      intensity=(MagickRealType) (((double) red*red+green*green+blue*blue)/
+        (3.0*QuantumRange));
+      break;
+    }
+    case Rec601LumaPixelIntensityMethod:
+    {
+      if (pixel->colorspace == RGBColorspace)
+        {
+          red=EncodePixelGamma(red);
+          green=EncodePixelGamma(green);
+          blue=EncodePixelGamma(blue);
+        }
+      intensity=0.298839*red+0.586811*green+0.114350*blue;
+      break;
+    }
+    case Rec601LuminancePixelIntensityMethod:
+    {
+      if (pixel->colorspace == sRGBColorspace)
+        {
+          red=DecodePixelGamma(red);
+          green=DecodePixelGamma(green);
+          blue=DecodePixelGamma(blue);
+        }
+      intensity=0.298839*red+0.586811*green+0.114350*blue;
+      break;
+    }
+    case Rec709LumaPixelIntensityMethod:
+    default:
+    {
+      if (pixel->colorspace == RGBColorspace)
+        {
+          red=EncodePixelGamma(red);
+          green=EncodePixelGamma(green);
+          blue=EncodePixelGamma(blue);
+        }
+      intensity=0.212656*red+0.715158*green+0.072186*blue;
+      break;
+    }
+    case Rec709LuminancePixelIntensityMethod:
+    {
+      if (pixel->colorspace == sRGBColorspace)
+        {
+          red=DecodePixelGamma(red);
+          green=DecodePixelGamma(green);
+          blue=DecodePixelGamma(blue);
+        }
+      intensity=0.212656*red+0.715158*green+0.072186*blue;
+      break;
+    }
+    case RMSPixelIntensityMethod:
+    {
+      intensity=(MagickRealType) (sqrt((double) red*red+green*green+blue*blue)/
+        sqrt(3.0));
+      break;
+    }
+  }
+  return(intensity);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
 %   G e t P i x e l I n t e n s i t y                                         %
 %                                                                             %
 %                                                                             %

diff --git a/MagickCore/pixel.h b/MagickCore/pixel.h
index 3685e3218e00b11493fe42d6d7ca2e0a7739ff7c..b150f1347f092883896fe6abddaace0e7c10d9d9 100644 (file)
--- a/MagickCore/pixel.h
+++ b/MagickCore/pixel.h
@@ -228,6 +228,8 @@ extern MagickExport MagickBooleanType
   SetPixelMetaChannels(Image *,const size_t,ExceptionInfo *);
 
 extern MagickExport MagickRealType
+  GetPixelInfoIntensity(const Image *restrict,const PixelInfo *restrict)
+    magick_hot_spot,
   GetPixelIntensity(const Image *restrict,const Quantum *restrict)
     magick_hot_spot;
 

diff --git a/MagickCore/quantize.c b/MagickCore/quantize.c
index 134e1e6e395f39f7a279fc145934993713b54e6e..42dc6e8abb8be18e29b3f7a5ca839ee0597f9a32 100644 (file)
--- a/MagickCore/quantize.c
+++ b/MagickCore/quantize.c
@@ -3350,8 +3350,8 @@ static int IntensityCompare(const void *x,const void *y)
 
   color_1=(PixelInfo *) x;
   color_2=(PixelInfo *) y;
-  intensity=(ssize_t) (GetPixelInfoIntensity(color_1)-(ssize_t)
-    GetPixelInfoIntensity(color_2));
+  intensity=(ssize_t) (GetPixelInfoIntensity((const Image *) NULL,color_1)-
+    (ssize_t) GetPixelInfoIntensity((const Image *) NULL,color_2));
   return((int) intensity);
 }
 

diff --git a/MagickCore/quantum-import.c b/MagickCore/quantum-import.c
index a60186ca99ff51908854b617891368b2eafbc101..a1f4d302fc002a248028689f0177202087256903 100644 (file)
--- a/MagickCore/quantum-import.c
+++ b/MagickCore/quantum-import.c
@@ -2275,7 +2275,7 @@ static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
               0x00 : 0x01);
           SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),
             q);
-          SetPixelInfoPixel(image,image->colormap+(ssize_t)
+          SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
             GetPixelIndex(image,q),q);
           q+=GetPixelChannels(image);
         }
@@ -2288,7 +2288,7 @@ static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
         else
           pixel=(unsigned char) (((*p) & (1 << (7-bit))) != 0 ? 0x00 : 0x01);
         SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
-        SetPixelInfoPixel(image,image->colormap+(ssize_t)
+        SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
           GetPixelIndex(image,q),q);
         q+=GetPixelChannels(image);
       }
@@ -2303,12 +2303,12 @@ static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
       {
         pixel=(unsigned char) ((*p >> 4) & 0xf);
         SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
-        SetPixelInfoPixel(image,image->colormap+(ssize_t)
+        SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
           GetPixelIndex(image,q),q);
         q+=GetPixelChannels(image);
         pixel=(unsigned char) ((*p) & 0xf);
         SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
-        SetPixelInfoPixel(image,image->colormap+(ssize_t)
+        SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
           GetPixelIndex(image,q),q);
         p++;
         q+=GetPixelChannels(image);
@@ -2317,7 +2317,7 @@ static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
       {
         pixel=(unsigned char) ((*p++ >> 4) & 0xf);
         SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
-        SetPixelInfoPixel(image,image->colormap+(ssize_t)
+        SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
           GetPixelIndex(image,q),q);
         q+=GetPixelChannels(image);
       }
@@ -2332,7 +2332,7 @@ static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
       {
         p=PushCharPixel(p,&pixel);
         SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
-        SetPixelInfoPixel(image,image->colormap+(ssize_t)
+        SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
           GetPixelIndex(image,q),q);
         p+=quantum_info->pad;
         q+=GetPixelChannels(image);
@@ -2352,7 +2352,7 @@ static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
             SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
               (double) QuantumRange*HalfToSinglePrecision(pixel)),
               &range_exception),q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t)
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
               GetPixelIndex(image,q),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -2363,7 +2363,7 @@ static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
       {
         p=PushShortPixel(quantum_info->endian,p,&pixel);
         SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
-        SetPixelInfoPixel(image,image->colormap+(ssize_t)
+        SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
           GetPixelIndex(image,q),q);
         p+=quantum_info->pad;
         q+=GetPixelChannels(image);
@@ -2385,7 +2385,7 @@ static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
             p=PushFloatPixel(quantum_info,p,&pixel);
             SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
               &range_exception),q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t)
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
               GetPixelIndex(image,q),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -2396,7 +2396,7 @@ static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
       {
         p=PushLongPixel(quantum_info->endian,p,&pixel);
         SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
-        SetPixelInfoPixel(image,image->colormap+(ssize_t)
+        SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
           GetPixelIndex(image,q),q);
         p+=quantum_info->pad;
         q+=GetPixelChannels(image);
@@ -2415,7 +2415,7 @@ static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
             p=PushDoublePixel(quantum_info,p,&pixel);
             SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
               &range_exception),q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t)
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
               GetPixelIndex(image,q),q);
             p+=quantum_info->pad;
             q+=GetPixelChannels(image);
@@ -2429,7 +2429,7 @@ static void ImportIndexQuantum(const Image *image,QuantumInfo *quantum_info,
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
         SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
-        SetPixelInfoPixel(image,image->colormap+(ssize_t)
+        SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
           GetPixelIndex(image,q),q);
         p+=quantum_info->pad;
         q+=GetPixelChannels(image);
@@ -2515,7 +2515,7 @@ static void ImportIndexAlphaQuantum(const Image *image,
       {
         pixel=(unsigned char) ((*p >> 4) & 0xf);
         SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
-        SetPixelInfoPixel(image,image->colormap+(ssize_t)
+        SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
           GetPixelIndex(image,q),q);
         pixel=(unsigned char) ((*p) & 0xf);
         SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);
@@ -2533,7 +2533,7 @@ static void ImportIndexAlphaQuantum(const Image *image,
       {
         p=PushCharPixel(p,&pixel);
         SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
-        SetPixelInfoPixel(image,image->colormap+(ssize_t)
+        SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
           GetPixelIndex(image,q),q);
         p=PushCharPixel(p,&pixel);
         SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);
@@ -2555,7 +2555,7 @@ static void ImportIndexAlphaQuantum(const Image *image,
             SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(
               (double) QuantumRange*HalfToSinglePrecision(pixel)),
               &range_exception),q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t)
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
               GetPixelIndex(image,q),q);
             p=PushShortPixel(quantum_info->endian,p,&pixel);
             SetPixelAlpha(image,ClampToQuantum(QuantumRange*
@@ -2569,7 +2569,7 @@ static void ImportIndexAlphaQuantum(const Image *image,
       {
         p=PushShortPixel(quantum_info->endian,p,&pixel);
         SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
-        SetPixelInfoPixel(image,image->colormap+(ssize_t)
+        SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
           GetPixelIndex(image,q),q);
         p=PushShortPixel(quantum_info->endian,p,&pixel);
         SetPixelAlpha(image,ScaleShortToQuantum(pixel),q);
@@ -2593,7 +2593,7 @@ static void ImportIndexAlphaQuantum(const Image *image,
             p=PushFloatPixel(quantum_info,p,&pixel);
             SetPixelIndex(image,PushColormapIndex(image,
               ClampToQuantum(pixel),&range_exception),q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t)
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
               GetPixelIndex(image,q),q);
             p=PushFloatPixel(quantum_info,p,&pixel);
             SetPixelAlpha(image,ClampToQuantum(pixel),q);
@@ -2606,7 +2606,7 @@ static void ImportIndexAlphaQuantum(const Image *image,
       {
         p=PushLongPixel(quantum_info->endian,p,&pixel);
         SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
-        SetPixelInfoPixel(image,image->colormap+(ssize_t)
+        SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
           GetPixelIndex(image,q),q);
         p=PushLongPixel(quantum_info->endian,p,&pixel);
         SetPixelAlpha(image,ScaleLongToQuantum(pixel),q);
@@ -2627,7 +2627,7 @@ static void ImportIndexAlphaQuantum(const Image *image,
             p=PushDoublePixel(quantum_info,p,&pixel);
             SetPixelIndex(image,PushColormapIndex(image,ClampToQuantum(pixel),
               &range_exception),q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t)
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
               GetPixelIndex(image,q),q);
             p=PushDoublePixel(quantum_info,p,&pixel);
             SetPixelAlpha(image,ClampToQuantum(pixel),q);
@@ -2644,7 +2644,7 @@ static void ImportIndexAlphaQuantum(const Image *image,
       {
         p=PushQuantumPixel(quantum_info,p,&pixel);
         SetPixelIndex(image,PushColormapIndex(image,pixel,&range_exception),q);
-        SetPixelInfoPixel(image,image->colormap+(ssize_t)
+        SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
           GetPixelIndex(image,q),q);
         p=PushQuantumPixel(quantum_info,p,&pixel);
         SetPixelAlpha(image,ScaleAnyToQuantum(pixel,range),q);

diff --git a/MagickCore/shear.c b/MagickCore/shear.c
index 6a555bc844a8970f767d0b88d14d9b461ec41d70..478e0fe6548fd060612b211966cc095c329aa8a2 100644 (file)
--- a/MagickCore/shear.c
+++ b/MagickCore/shear.c
@@ -1259,18 +1259,18 @@ static MagickBooleanType XShearImage(Image *image,const double degrees,
           GetPixelInfoPixel(image,p,&source);
           CompositePixelInfoAreaBlend(&pixel,(double) pixel.alpha,
             &source,(double) GetPixelAlpha(image,p),area,&destination);
-          SetPixelInfoPixel(image,&destination,q);
+          SetPixelViaPixelInfo(image,&destination,q);
           GetPixelInfoPixel(image,p,&pixel);
           p+=GetPixelChannels(image);
           q+=GetPixelChannels(image);
         }
         CompositePixelInfoAreaBlend(&pixel,(double) pixel.alpha,
           &background,(double) background.alpha,area,&destination);
-        SetPixelInfoPixel(image,&destination,q);
+        SetPixelViaPixelInfo(image,&destination,q);
         q+=GetPixelChannels(image);
         for (i=0; i < (step-1); i++)
         {
-          SetPixelInfoPixel(image,&background,q);
+          SetPixelViaPixelInfo(image,&background,q);
           q+=GetPixelChannels(image);
         }
         break;
@@ -1291,17 +1291,17 @@ static MagickBooleanType XShearImage(Image *image,const double degrees,
           GetPixelInfoPixel(image,p,&source);
           CompositePixelInfoAreaBlend(&pixel,(double) pixel.alpha,
             &source,(double) GetPixelAlpha(image,p),area,&destination);
-          SetPixelInfoPixel(image,&destination,q);
+          SetPixelViaPixelInfo(image,&destination,q);
           GetPixelInfoPixel(image,p,&pixel);
         }
         CompositePixelInfoAreaBlend(&pixel,(double) pixel.alpha,
           &background,(double) background.alpha,area,&destination);
         q-=GetPixelChannels(image);
-        SetPixelInfoPixel(image,&destination,q);
+        SetPixelViaPixelInfo(image,&destination,q);
         for (i=0; i < (step-1); i++)
         {
           q-=GetPixelChannels(image);
-          SetPixelInfoPixel(image,&background,q);
+          SetPixelViaPixelInfo(image,&background,q);
         }
         break;
       }
@@ -1476,18 +1476,18 @@ static MagickBooleanType YShearImage(Image *image,const double degrees,
           CompositePixelInfoAreaBlend(&pixel,(double) pixel.alpha,
             &source,(double) GetPixelAlpha(image,p),area,
             &destination);
-          SetPixelInfoPixel(image,&destination,q);
+          SetPixelViaPixelInfo(image,&destination,q);
           GetPixelInfoPixel(image,p,&pixel);
           p+=GetPixelChannels(image);
           q+=GetPixelChannels(image);
         }
         CompositePixelInfoAreaBlend(&pixel,(double) pixel.alpha,
           &background,(double) background.alpha,area,&destination);
-        SetPixelInfoPixel(image,&destination,q);
+        SetPixelViaPixelInfo(image,&destination,q);
         q+=GetPixelChannels(image);
         for (i=0; i < (step-1); i++)
         {
-          SetPixelInfoPixel(image,&background,q);
+          SetPixelViaPixelInfo(image,&background,q);
           q+=GetPixelChannels(image);
         }
         break;
@@ -1509,17 +1509,17 @@ static MagickBooleanType YShearImage(Image *image,const double degrees,
           CompositePixelInfoAreaBlend(&pixel,(double) pixel.alpha,
             &source,(double) GetPixelAlpha(image,p),area,
             &destination);
-          SetPixelInfoPixel(image,&destination,q);
+          SetPixelViaPixelInfo(image,&destination,q);
           GetPixelInfoPixel(image,p,&pixel);
         }
         CompositePixelInfoAreaBlend(&pixel,(double) pixel.alpha,
           &background,(double) background.alpha,area,&destination);
         q-=GetPixelChannels(image);
-        SetPixelInfoPixel(image,&destination,q);
+        SetPixelViaPixelInfo(image,&destination,q);
         for (i=0; i < (step-1); i++)
         {
           q-=GetPixelChannels(image);
-          SetPixelInfoPixel(image,&background,q);
+          SetPixelViaPixelInfo(image,&background,q);
         }
         break;
       }

diff --git a/MagickCore/xwindow.c b/MagickCore/xwindow.c
index 8274f1e1a7be376f31320b2a05b1cb7b539c1011..56bc5b40ff2ce5a4fab0faf6e984cd58c11cf67d 100644 (file)
--- a/MagickCore/xwindow.c
+++ b/MagickCore/xwindow.c
@@ -2486,7 +2486,7 @@ MagickPrivate MagickBooleanType XDrawImage(Display *display,
           /*
             Set this pixel to the background color.
           */
-          SetPixelInfoPixel(draw_image,&draw_image->background_color,q);
+          SetPixelViaPixelInfo(draw_image,&draw_image->background_color,q);
           SetPixelAlpha(draw_image,(Quantum) (draw_info->stencil ==
             OpaqueStencil ? TransparentAlpha : OpaqueAlpha),q);
         }
@@ -4474,7 +4474,7 @@ static Image *XGetWindowImage(Display *display,const Window window,
               {
                 index=(Quantum) XGetPixel(ximage,x,y);
                 SetPixelIndex(composite_image,index,q);
-                SetPixelInfoPixel(composite_image,
+                SetPixelViaPixelInfo(composite_image,
                   composite_image->colormap+(ssize_t) index,q);
                 q+=GetPixelChannels(composite_image);
               }
@@ -5953,11 +5953,11 @@ static void XMakeImageLSBFirst(const XResourceInfo *resource_info,
       foreground=(unsigned char)
         (XPixelIntensity(&window->pixel_info->background_color) <
          XPixelIntensity(&window->pixel_info->foreground_color) ? 0x80 : 0x00);
-      polarity=(unsigned short) ((GetPixelInfoIntensity(
+      polarity=(unsigned short) ((GetPixelInfoIntensity(image,
         &canvas->colormap[0])) < (QuantumRange/2) ? 1 : 0);
       if (canvas->colors == 2)
-        polarity=GetPixelInfoIntensity(&canvas->colormap[0]) <
-          GetPixelInfoIntensity(&canvas->colormap[1]);
+        polarity=GetPixelInfoIntensity(image,&canvas->colormap[0]) <
+          GetPixelInfoIntensity(image,&canvas->colormap[1]);
       for (y=0; y < (int) canvas->rows; y++)
       {
         p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,canvas->columns,1,
@@ -6514,7 +6514,8 @@ static void XMakeImageMSBFirst(const XResourceInfo *resource_info,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   canvas=image;
   if ((window->immutable != MagickFalse) &&
-      (image->storage_class == DirectClass) && (image->alpha_trait != UndefinedPixelTrait))
+      (image->storage_class == DirectClass) &&
+      (image->alpha_trait != UndefinedPixelTrait))
     {
       char
         size[MaxTextExtent];
@@ -6569,11 +6570,11 @@ static void XMakeImageMSBFirst(const XResourceInfo *resource_info,
       foreground=(unsigned char)
         (XPixelIntensity(&window->pixel_info->background_color) <
          XPixelIntensity(&window->pixel_info->foreground_color) ?  0x01 : 0x00);
-      polarity=(unsigned short) ((GetPixelInfoIntensity(
+      polarity=(unsigned short) ((GetPixelInfoIntensity(image,
         &canvas->colormap[0])) < (QuantumRange/2) ? 1 : 0);
       if (canvas->colors == 2)
-        polarity=GetPixelInfoIntensity(&canvas->colormap[0]) <
-          GetPixelInfoIntensity(&canvas->colormap[1]);
+        polarity=GetPixelInfoIntensity(image,&canvas->colormap[0]) <
+          GetPixelInfoIntensity(image,&canvas->colormap[1]);
       for (y=0; y < (int) canvas->rows; y++)
       {
         p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,canvas->columns,1,

diff --git a/coders/braille.c b/coders/braille.c
index 2e2658a1e78da2ccba9e73b7c1977fc18743aac1..481cc082ec69f9bcaf1604ca8ab2e60b2b9b85dc 100644 (file)
--- a/coders/braille.c
+++ b/coders/braille.c
@@ -253,11 +253,11 @@ static MagickBooleanType WriteBRAILLEImage(const ImageInfo *image_info,
   (void) SetImageType(image,BilevelType,exception);
   polarity = 0;
   if (image->storage_class == PseudoClass) {
-    polarity=(Quantum) (GetPixelInfoIntensity(&image->colormap[0]) >=
+    polarity=(Quantum) (GetPixelInfoIntensity(image,&image->colormap[0]) >=
       (Quantum) (QuantumRange/2));
     if (image->colors == 2)
-      polarity=(Quantum) (GetPixelInfoIntensity(&image->colormap[0]) >=
-        GetPixelInfoIntensity(&image->colormap[1]));
+      polarity=(Quantum) (GetPixelInfoIntensity(image,&image->colormap[0]) >=
+        GetPixelInfoIntensity(image,&image->colormap[1]));
   }
   for (y=0; y < (ssize_t) image->rows; y+=(ssize_t) cell_height)
   {

diff --git a/coders/gif.c b/coders/gif.c
index df06bf3adcb8e62e6fc2c6c2959c9575ae6dd91a..57aa7f0ced66b170715ebfa92bc28b989831ea3e 100644 (file)
--- a/coders/gif.c
+++ b/coders/gif.c
@@ -443,7 +443,7 @@ static MagickBooleanType DecodeImage(Image *image,const ssize_t opacity,
         break;
       index=ConstrainColormapIndex(image,(size_t) c,exception);
       SetPixelIndex(image,index,q);
-      SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+      SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
       SetPixelAlpha(image,(ssize_t) index == opacity ? TransparentAlpha :
         OpaqueAlpha,q);
       x++;

diff --git a/coders/gradient.c b/coders/gradient.c
index 2f94701e6919dfd7f0272a464adf28cdf2c5e18f..1ffdb2cdd7ff7d7dfe779225511fd4ad1e40deb5 100644 (file)
--- a/coders/gradient.c
+++ b/coders/gradient.c
@@ -149,7 +149,7 @@ static Image *ReadGRADIENTImage(const ImageInfo *image_info,
     }
   (void) SetImageColorspace(image,start_color.colorspace,exception);
   (void) CopyMagickString(colorname,"white",MaxTextExtent);
-  if (GetPixelInfoIntensity(&start_color) > (Quantum) (QuantumRange/2))
+  if (GetPixelInfoIntensity(image,&start_color) > (Quantum) (QuantumRange/2))
     (void) CopyMagickString(colorname,"black",MaxTextExtent);
   if (icc_color == MagickFalse)
     (void) sscanf(image_info->filename,"%*[^-]-%[^-]",colorname);

diff --git a/coders/jbig.c b/coders/jbig.c
index c8731b495b637611fd7c9d2df519d580ea3248b6..ae230f7aec6694f4b9b251c66ce040d0f13b256b 100644 (file)
--- a/coders/jbig.c
+++ b/coders/jbig.c
@@ -239,7 +239,7 @@ static Image *ReadJBIGImage(const ImageInfo *image_info,
       if (bit == 8)
         bit=0;
       SetPixelIndex(image,index,q);
-      SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+      SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
       q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)

diff --git a/coders/jpeg.c b/coders/jpeg.c
index 1ce2a3e0d0adc8ffe14cb7d6d17e2fd129b4af8f..b88768db052341025aeb1efb14282d594cd7fa6f 100644 (file)
--- a/coders/jpeg.c
+++ b/coders/jpeg.c
@@ -1383,7 +1383,7 @@ static Image *ReadJPEGImage(const ImageInfo *image_info,
             pixel=(size_t) (scale*GETJSAMPLE(*p));
             index=ConstrainColormapIndex(image,pixel,exception);
             SetPixelIndex(image,index,q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
             p++;
             q+=GetPixelChannels(image);
           }
@@ -1421,7 +1421,7 @@ static Image *ReadJPEGImage(const ImageInfo *image_info,
         {
           index=ConstrainColormapIndex(image,(size_t) GETJSAMPLE(*p),exception);
           SetPixelIndex(image,index,q);
-          SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+          SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
           p++;
           q+=GetPixelChannels(image);
         }

diff --git a/coders/map.c b/coders/map.c
index 797e1b35085f82156a3bb3914f51f7cc2c0d53e4..0c427b82befcc35137d952c48a16a33d7a68af54 100644 (file)
--- a/coders/map.c
+++ b/coders/map.c
@@ -230,7 +230,7 @@ static Image *ReadMAPImage(const ImageInfo *image_info,ExceptionInfo *exception)
           p++;
         }
       SetPixelIndex(image,index,q);
-      SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+      SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
       q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)

diff --git a/coders/null.c b/coders/null.c
index 8c069705c8b4c8d423cb15e0eb8da5ff17b5478b..c2ba676dda36b11cb18f1dc65a7e580a35fbe2b9 100644 (file)
--- a/coders/null.c
+++ b/coders/null.c
@@ -142,7 +142,7 @@ static Image *ReadNULLImage(const ImageInfo *image_info,
       break;
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      SetPixelInfoPixel(image,&background,q);
+      SetPixelViaPixelInfo(image,&background,q);
       q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)

diff --git a/coders/palm.c b/coders/palm.c
index b0d15c352bbf5bc609141d93b6d038bae2f2bac9..ab914914c9b886695845e66f54bb6a8025eaab4f 100644 (file)
--- a/coders/palm.c
+++ b/coders/palm.c
@@ -481,7 +481,7 @@ static Image *ReadPALMImage(const ImageInfo *image_info,
               ThrowReaderException(CorruptImageError,"CorruptImage");
             index=(Quantum) (mask-(((*ptr) & (mask << bit)) >> bit));
             SetPixelIndex(image,index,q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
             if (bit)
               bit-=bits_per_pixel;
             else

diff --git a/coders/png.c b/coders/png.c
index cf330777a0f44ebcc08768c41688d63ea3d0600c..499fcf0ff32d3478a0163b83a42c0b065f674dc8 100644 (file)
--- a/coders/png.c
+++ b/coders/png.c
@@ -8917,7 +8917,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
           {
               if (GetPixelAlpha(image,r) < OpaqueAlpha/2)
                 {
-                  SetPixelInfoPixel(image,&image->background_color,r);
+                  SetPixelViaPixelInfo(image,&image->background_color,r);
                   SetPixelAlpha(image,TransparentAlpha,r);
                 }
               else
@@ -9826,7 +9826,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
                 (ScaleQuantumToShort(image->colormap[0].blue) & mask);
 
               ping_trans_color.gray=(png_uint_16)
-                (ScaleQuantumToShort(GetPixelInfoIntensity(
+                (ScaleQuantumToShort(GetPixelInfoIntensity(image,
                    image->colormap)) & mask);
 
               ping_trans_color.index=(png_byte) 0;
@@ -10096,7 +10096,7 @@ static MagickBooleanType WriteOnePNGImage(MngInfo *mng_info,
          {
 
          ping_background.gray=(png_uint_16) ((maxval/65535.)*
-           (ScaleQuantumToShort(((GetPixelInfoIntensity(
+           (ScaleQuantumToShort(((GetPixelInfoIntensity(image,
            &image->background_color))) +.5)));
 
          if (logging != MagickFalse)

diff --git a/coders/psd.c b/coders/psd.c
index 4a34344f441944dc6f2e40ebfa23dcd0ad0976cc..e9b376e68262b5c7614c5b9455034a0de3973d6f 100644 (file)
--- a/coders/psd.c
+++ b/coders/psd.c
@@ -717,7 +717,7 @@ static MagickStatusType ReadPSDChannelPixels(Image *image,
               SetPixelIndex(image,ScaleQuantumToChar(pixel),q);
             else
               SetPixelIndex(image,ScaleQuantumToShort(pixel),q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t)
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
               ConstrainColormapIndex(image,GetPixelIndex(image,q),exception),q);
             if (image->depth == 1)
               {
@@ -732,7 +732,7 @@ static MagickStatusType ReadPSDChannelPixels(Image *image,
                 {
                   SetPixelIndex(image,(((unsigned char) pixel) &
                     (0x01 << (7-bit))) != 0 ? 0 : 255,q);
-                  SetPixelInfoPixel(image,image->colormap+(ssize_t)
+                  SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
                     GetPixelIndex(image,q),q);
                   q+=GetPixelChannels(image);
                   x++;

diff --git a/coders/ttf.c b/coders/ttf.c
index 2b4928ef95661f0f89cd8dff1011d15f205e971d..c12bc1cadec0fee5ecb900a1978d4b1af2b005d1 100644 (file)
--- a/coders/ttf.c
+++ b/coders/ttf.c
@@ -238,7 +238,7 @@ static Image *ReadTTFImage(const ImageInfo *image_info,ExceptionInfo *exception)
       break;
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      SetPixelInfoPixel(image,&background_color,q);
+      SetPixelViaPixelInfo(image,&background_color,q);
       q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)

diff --git a/coders/txt.c b/coders/txt.c
index 0e5b539fa642cfc5b0981e1d9f6bb77719c914f1..69150dd05667fda2bc6b76db63e1914c9118b0d9 100644 (file)
--- a/coders/txt.c
+++ b/coders/txt.c
@@ -540,7 +540,7 @@ static Image *ReadTXTImage(const ImageInfo *image_info,ExceptionInfo *exception)
         q=GetAuthenticPixels(image,x_offset,y_offset,1,1,exception);
         if (q == (Quantum *) NULL)
           continue;
-        SetPixelInfoPixel(image,&pixel,q);
+        SetPixelViaPixelInfo(image,&pixel,q);
         if (SyncAuthenticPixels(image,exception) == MagickFalse)
           break;
       }

diff --git a/coders/uil.c b/coders/uil.c
index 9f71ac3c54ddf0e910a454134f95c85fb3f0c24b..446a7cccc6d878488e03a31cfc0f39c344b98fa3 100644 (file)
--- a/coders/uil.c
+++ b/coders/uil.c
@@ -328,7 +328,7 @@ static MagickBooleanType WriteUILImage(const ImageInfo *image_info,Image *image,
     else
       (void) FormatLocaleString(buffer,MaxTextExtent,
         "    color('%s',%s) = '%s'",name,
-        GetPixelInfoIntensity(image->colormap+i) <
+        GetPixelInfoIntensity(image,image->colormap+i) <
         (QuantumRange/2) ? "background" : "foreground",symbol);
     (void) WriteBlobString(image,buffer);
     (void) FormatLocaleString(buffer,MaxTextExtent,"%s",

diff --git a/coders/wpg.c b/coders/wpg.c
index 736cd434a6d26498ef44aae51beccce357660fdb..cc292a30cd79b788929a85c11787846c9d62bdeb 100644 (file)
--- a/coders/wpg.c
+++ b/coders/wpg.c
@@ -292,7 +292,7 @@ static void InsertRow(Image *image,unsigned char *p,ssize_t y,int bpp,
           {
             index=((*p) & (0x80 >> bit) ? 0x01 : 0x00);
             SetPixelIndex(image,index,q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
             q+=GetPixelChannels(image);
           }
           p++;
@@ -303,7 +303,7 @@ static void InsertRow(Image *image,unsigned char *p,ssize_t y,int bpp,
             {
               index=((*p) & (0x80 >> bit) ? 0x01 : 0x00);
               SetPixelIndex(image,index,q);
-              SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+              SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
               q+=GetPixelChannels(image);
             }
             p++;
@@ -321,19 +321,19 @@ static void InsertRow(Image *image,unsigned char *p,ssize_t y,int bpp,
         {
             index=ConstrainColormapIndex(image,(*p >> 6) & 0x3,exception);
             SetPixelIndex(image,index,q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
             q+=GetPixelChannels(image);
             index=ConstrainColormapIndex(image,(*p >> 4) & 0x3,exception);
             SetPixelIndex(image,index,q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
             q+=GetPixelChannels(image);
             index=ConstrainColormapIndex(image,(*p >> 2) & 0x3,exception);
             SetPixelIndex(image,index,q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
             q+=GetPixelChannels(image);
             index=ConstrainColormapIndex(image,(*p) & 0x3,exception);
             SetPixelIndex(image,index,q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
             p++;
             q+=GetPixelChannels(image);
         }
@@ -341,14 +341,14 @@ static void InsertRow(Image *image,unsigned char *p,ssize_t y,int bpp,
           {
             index=ConstrainColormapIndex(image,(*p >> 6) & 0x3,exception);
             SetPixelIndex(image,index,q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
             q+=GetPixelChannels(image);
             if ((image->columns % 4) >= 1)
 
               {
                 index=ConstrainColormapIndex(image,(*p >> 4) & 0x3,exception);
                 SetPixelIndex(image,index,q);
-                SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+                SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
                 q+=GetPixelChannels(image);
                 if ((image->columns % 4) >= 2)
 
@@ -356,7 +356,7 @@ static void InsertRow(Image *image,unsigned char *p,ssize_t y,int bpp,
                     index=ConstrainColormapIndex(image,(*p >> 2) & 0x3,
                       exception);
                     SetPixelIndex(image,index,q);
-                    SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+                    SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
                     q+=GetPixelChannels(image);
                   }
               }
@@ -376,11 +376,11 @@ static void InsertRow(Image *image,unsigned char *p,ssize_t y,int bpp,
           { 
             index=ConstrainColormapIndex(image,(*p >> 4) & 0x0f,exception);
             SetPixelIndex(image,index,q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
             q+=GetPixelChannels(image);
             index=ConstrainColormapIndex(image,(*p) & 0x0f,exception);
             SetPixelIndex(image,index,q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
             p++;
             q+=GetPixelChannels(image);
           }
@@ -388,7 +388,7 @@ static void InsertRow(Image *image,unsigned char *p,ssize_t y,int bpp,
           {
             index=ConstrainColormapIndex(image,(*p >> 4) & 0x0f,exception);
             SetPixelIndex(image,index,q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
             p++;
             q+=GetPixelChannels(image);
           }
@@ -405,7 +405,7 @@ static void InsertRow(Image *image,unsigned char *p,ssize_t y,int bpp,
           {
             index=ConstrainColormapIndex(image,*p,exception);
             SetPixelIndex(image,index,q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
             p++;
             q+=GetPixelChannels(image);
           }

diff --git a/coders/xc.c b/coders/xc.c
index af996a46701e32cd606222138a832fff0e192d65..1fd5fa23064cc337428aeef710417565223a6544 100644 (file)
--- a/coders/xc.c
+++ b/coders/xc.c
@@ -149,7 +149,7 @@ static Image *ReadXCImage(const ImageInfo *image_info,ExceptionInfo *exception)
       break;
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      SetPixelInfoPixel(image,&pixel,q);
+      SetPixelViaPixelInfo(image,&pixel,q);
       q+=GetPixelChannels(image);
     }
     if (SyncAuthenticPixels(image,exception) == MagickFalse)

diff --git a/coders/xpm.c b/coders/xpm.c
index 1279603c012e0abf4b47eca6f5535c880bf6d823..29eb8810577119736eef3934687f7d2d8e5de49f 100644 (file)
--- a/coders/xpm.c
+++ b/coders/xpm.c
@@ -437,7 +437,7 @@ static Image *ReadXPMImage(const ImageInfo *image_info,ExceptionInfo *exception)
           j=(ssize_t) GetValueFromSplayTree(xpm_colors,key);
           if (image->storage_class == PseudoClass)
             SetPixelIndex(image,(Quantum) j,r);
-          SetPixelInfoPixel(image,image->colormap+j,r);
+          SetPixelViaPixelInfo(image,image->colormap+j,r);
           p+=count;
           r+=GetPixelChannels(image);
         }

diff --git a/coders/xwd.c b/coders/xwd.c
index cdb1bb1739b25ec914bb3efc676f3ba02258a880..960fc0cae5f983de75d3304b230368a6993d93a1 100644 (file)
--- a/coders/xwd.c
+++ b/coders/xwd.c
@@ -542,7 +542,7 @@ static Image *ReadXWDImage(const ImageInfo *image_info,ExceptionInfo *exception)
             index=ConstrainColormapIndex(image,XGetPixel(ximage,(int) x,
               (int) y),exception);
             SetPixelIndex(image,index,q);
-            SetPixelInfoPixel(image,image->colormap+(ssize_t) index,q);
+            SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);
             q+=GetPixelChannels(image);
           }
           if (SyncAuthenticPixels(image,exception) == MagickFalse)