(no commit message)

diff --git a/MagickCore/composite.c b/MagickCore/composite.c
index e65afd845e293ce44e341370836ffb4135321088..28674345c13518b0877daf47ee2e14a7ce55927c 100644 (file)
--- a/MagickCore/composite.c
+++ b/MagickCore/composite.c
@@ -1615,7 +1615,7 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
               }
               case IntensityCompositeOp:
               {
-                pixel=(double) GetPixelIntensity(composite_image,p);
+                pixel=GetPixelIntensity(composite_image,p);
                 break;
               }
               case LightenIntensityCompositeOp:

diff --git a/MagickCore/effect.c b/MagickCore/effect.c
index 0902e16753b43895a22278060eb655349d021a51..9e5c53e7dba67c308a247e4a4022aee688441a8f 100644 (file)
--- a/MagickCore/effect.c
+++ b/MagickCore/effect.c
@@ -3100,7 +3100,7 @@ MagickExport Image *SelectiveBlurImage(const Image *image,const double radius,
           q+=GetPixelChannels(blur_image);
           continue;
         }
-      intensity=(double) GetPixelIntensity(image,p+center);
+      intensity=GetPixelIntensity(image,p+center);
       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
       {
         double
@@ -3150,8 +3150,8 @@ MagickExport Image *SelectiveBlurImage(const Image *image,const double radius,
             {
               for (u=0; u < (ssize_t) width; u++)
               {
-                contrast=(double) GetPixelIntensity(luminance_image,
-                  luminance_pixels)-intensity;
+                contrast=GetPixelIntensity(luminance_image,luminance_pixels)-
+                  intensity;
                 if (fabs(contrast) < threshold)
                   {
                     pixel+=(*k)*pixels[i];

diff --git a/MagickCore/enhance.c b/MagickCore/enhance.c
index 7bee15ecdc72a48e017ec268749156777a9d5d5a..5544e135c181a717ade9234548f5d04f8043f522 100644 (file)
--- a/MagickCore/enhance.c
+++ b/MagickCore/enhance.c
@@ -1081,7 +1081,7 @@ MagickExport MagickBooleanType ContrastStretchImage(Image *image,
       register ssize_t
         i;
 
-      pixel=(double) GetPixelIntensity(image,p);
+      pixel=GetPixelIntensity(image,p);
       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
       {
         if (image->channel_mask != DefaultChannels)
@@ -2680,7 +2680,11 @@ MagickExport MagickBooleanType LinearStretchImage(Image *image,
       break;
     for (x=0; x < (ssize_t) image->columns; x++)
     {
-      histogram[ScaleQuantumToMap(GetPixelIntensity(image,p))]++;
+      double
+        intensity;
+
+      intensity=GetPixelIntensity(image,p);
+      histogram[ScaleQuantumToMap(ClampToQuantum(intensity))]++;
       p+=GetPixelChannels(image);
     }
   }

diff --git a/MagickCore/fx.c b/MagickCore/fx.c
index 24fd9c77f86391dbe46c67b008c79a5ecfaed331..456e8a0c73c3182bc4633c127e5c20722a9eb113 100644 (file)
--- a/MagickCore/fx.c
+++ b/MagickCore/fx.c
@@ -4193,7 +4193,7 @@ MagickExport Image *SepiaToneImage(const Image *image,const double threshold,
         intensity,
         tone;
 
-      intensity=(double) GetPixelIntensity(image,p);
+      intensity=GetPixelIntensity(image,p);
       tone=intensity > threshold ? (double) QuantumRange : intensity+
         (double) QuantumRange-threshold;
       SetPixelRed(sepia_image,ClampToQuantum(tone),q);

diff --git a/MagickCore/morphology.c b/MagickCore/morphology.c
index 37a3aac5c165de3cc28f8653fe97e9ccda515684..cbd150e1bc95cb81b7fe66326a03e00abf552768 100644 (file)
--- a/MagickCore/morphology.c
+++ b/MagickCore/morphology.c
@@ -118,7 +118,7 @@ static inline double MagickMax(const double x,const double y)
 #if 1
 static inline size_t fact(size_t n)
 {
-  size_t l,f;
+  size_t f,l;
   for(f=1, l=2; l <= n; f=f*l, l++);
   return(f);
 }
@@ -1330,10 +1330,10 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
         /* set all kernel values within diamond area to scale given */
         for ( i=0, v=0; v < (ssize_t)kernel->height; v++)
           { size_t
-              alpha = order_f / ( fact(v) * fact(kernel->height-v-1) );
+              alpha = order_f / ( fact((size_t) v) * fact(kernel->height-v-1) );
             for ( u=0; u < (ssize_t)kernel->width; u++, i++)
               kernel->positive_range += kernel->values[i] = (double)
-                (alpha * order_f / ( fact(u) * fact(kernel->height-u-1) ));
+                (alpha * order_f / ( fact((size_t) u) * fact(kernel->height-u-1) ));
           }
         kernel->minimum = 1.0;
         kernel->maximum = kernel->values[kernel->x+kernel->y*kernel->width];

diff --git a/MagickCore/paint.c b/MagickCore/paint.c
index 4089074830c4082ce7598e8a458cc7efdb8f0211..a3f9b906903b06be69e148c47b9bce55e920661f 100644 (file)
--- a/MagickCore/paint.c
+++ b/MagickCore/paint.c
@@ -645,8 +645,8 @@ MagickExport Image *OilPaintImage(const Image *image,const double radius,
       {
         for (u=0; u < (ssize_t) width; u++)
         {
-          n=(ssize_t) ScaleQuantumToChar(GetPixelIntensity(image,p+
-            GetPixelChannels(image)*(u+k)));
+          n=(ssize_t) ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,
+            p+GetPixelChannels(image)*(u+k))));
           histogram[n]++;
           if (histogram[n] > count)
             {

diff --git a/MagickCore/pixel-accessor.h b/MagickCore/pixel-accessor.h
index f54166cb9d52a7ef6fd1cd8a41d0a59ec524193a..a53128ca23347eef2ae0c5d7ff29a7a047f55fd7 100644 (file)
--- a/MagickCore/pixel-accessor.h
+++ b/MagickCore/pixel-accessor.h
@@ -244,7 +244,7 @@ static inline double GetPixelInfoLuminance(const PixelInfo *restrict pixel_info)
   return(0.21267*red+0.71516*green+0.07217*blue);
 }
 
-static inline Quantum GetPixelIntensity(const Image *restrict image,
+static inline double GetPixelIntensity(const Image *restrict image,
   const Quantum *restrict pixel)
 {
   double
@@ -253,19 +253,18 @@ static inline Quantum GetPixelIntensity(const Image *restrict image,
     red;
 
   if (image->colorspace == GRAYColorspace)
-    return(pixel[image->channel_map[GrayPixelChannel].offset]);
+    return((double) pixel[image->channel_map[GrayPixelChannel].offset]);
   if (image->colorspace != sRGBColorspace)
-    return(ClampToQuantum(
-      0.298839*pixel[image->channel_map[RedPixelChannel].offset]+
+    return(0.298839*pixel[image->channel_map[RedPixelChannel].offset]+
       0.586811*pixel[image->channel_map[GreenPixelChannel].offset]+
-      0.114350*pixel[image->channel_map[BluePixelChannel].offset]));
+      0.114350*pixel[image->channel_map[BluePixelChannel].offset]);
   red=InversesRGBCompandor((double)
     pixel[image->channel_map[RedPixelChannel].offset]);
   green=InversesRGBCompandor((double)
     pixel[image->channel_map[GreenPixelChannel].offset]);
   blue=InversesRGBCompandor((double)
     pixel[image->channel_map[BluePixelChannel].offset]);
-  return(ClampToQuantum(0.298839*red+0.586811*green+0.114350*blue));
+  return(0.298839*red+0.586811*green+0.114350*blue);
 }
 
 static inline Quantum GetPixelL(const Image *restrict image,
@@ -274,7 +273,7 @@ static inline Quantum GetPixelL(const Image *restrict image,
   return(pixel[image->channel_map[LPixelChannel].offset]);
 }
 
-static inline Quantum GetPixelLuminance(const Image *restrict image,
+static inline double GetPixelLuminance(const Image *restrict image,
   const Quantum *restrict pixel)
 {
   double
@@ -283,19 +282,18 @@ static inline Quantum GetPixelLuminance(const Image *restrict image,
     red;
 
   if (image->colorspace == GRAYColorspace)
-    return(pixel[image->channel_map[GrayPixelChannel].offset]);
+    return((double) pixel[image->channel_map[GrayPixelChannel].offset]);
   if (image->colorspace != sRGBColorspace)
-    return(ClampToQuantum(
-      0.298839*pixel[image->channel_map[RedPixelChannel].offset]+
+    return(0.298839*pixel[image->channel_map[RedPixelChannel].offset]+
       0.586811*pixel[image->channel_map[GreenPixelChannel].offset]+
-      0.114350*pixel[image->channel_map[BluePixelChannel].offset]));
+      0.114350*pixel[image->channel_map[BluePixelChannel].offset]);
   red=InversesRGBCompandor((double)
     pixel[image->channel_map[RedPixelChannel].offset]);
   green=InversesRGBCompandor((double)
     pixel[image->channel_map[GreenPixelChannel].offset]);
   blue=InversesRGBCompandor((double)
     pixel[image->channel_map[BluePixelChannel].offset]);
-  return(ClampToQuantum(0.21267*red+0.71516*green+0.07217*blue));
+  return(0.21267*red+0.71516*green+0.07217*blue);
 }
 
 static inline Quantum GetPixelMagenta(const Image *restrict image,

diff --git a/MagickCore/quantum-export.c b/MagickCore/quantum-export.c
index 461d358683ad2535c6292f4fd48ff2173bd855f3..bc57faee83ae991c408ad259ceebb528ec1946e2 100644 (file)
--- a/MagickCore/quantum-export.c
+++ b/MagickCore/quantum-export.c
@@ -1525,7 +1525,7 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
   {
     case 1:
     {
-      register Quantum
+      register double
         threshold;
 
       register unsigned char
@@ -1542,7 +1542,7 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
           black=0x01;
           white=0x00;
         }
-      threshold=(Quantum) (QuantumRange/2);
+      threshold=QuantumRange/2.0;
       for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
       {
         *q='\0';
@@ -1583,17 +1583,17 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
 
       for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
       {
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
         *q=(((pixel >> 4) & 0xf) << 4);
         p+=GetPixelChannels(image);
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
         *q|=pixel >> 4;
         p+=GetPixelChannels(image);
         q++;
       }
       if ((number_pixels % 2) != 0)
         {
-          pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+          pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
           *q=(((pixel >> 4) & 0xf) << 4);
           p+=GetPixelChannels(image);
           q++;
@@ -1607,7 +1607,7 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
 
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
         q=PopCharPixel(pixel,q);
         p+=GetPixelChannels(image);
         q+=quantum_info->pad;
@@ -1624,10 +1624,11 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
 
           for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
           {
-            pixel=(unsigned int) (ScaleQuantumToAny(GetPixelIntensity(image,
-              p+2*GetPixelChannels(image)),range) << 22 | ScaleQuantumToAny(
-              GetPixelIntensity(image,p+GetPixelChannels(image)),range) << 12 |
-              ScaleQuantumToAny(GetPixelIntensity(image,p),range) << 2);
+            pixel=(unsigned int) (ScaleQuantumToAny(ClampToQuantum(
+              GetPixelIntensity(image,p+2*GetPixelChannels(image))),range) <<
+              22 | ScaleQuantumToAny(ClampToQuantum(GetPixelIntensity(image,
+              p+GetPixelChannels(image))),range) << 12 | ScaleQuantumToAny(
+              ClampToQuantum(GetPixelIntensity(image,p)),range) << 2);
             q=PopLongPixel(quantum_info->endian,pixel,q);
             p+=3*GetPixelChannels(image);
             q+=quantum_info->pad;
@@ -1636,18 +1637,19 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
             {
               pixel=0U;
               if (x++ < (ssize_t) (number_pixels-1))
-                pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p+
-                  GetPixelChannels(image)),range) << 12;
+                pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelIntensity(image,
+                  p+GetPixelChannels(image))),range) << 12;
               if (x++ < (ssize_t) number_pixels)
-                pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p),range) << 2;
+                pixel|=ScaleQuantumToAny(ClampToQuantum(GetPixelIntensity(image,
+                  p)),range) << 2;
               q=PopLongPixel(quantum_info->endian,pixel,q);
             }
           break;
         }
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
-          GetPixelIntensity(image,p),range),q);
+        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+          GetPixelIntensity(image,p)),range),q);
         p+=GetPixelChannels(image);
         q+=quantum_info->pad;
       }
@@ -1663,7 +1665,8 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
         {
           for (x=0; x < (ssize_t) number_pixels; x++)
           {
-            pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
+            pixel=ScaleQuantumToShort(ClampToQuantum(
+              GetPixelIntensity(image,p)));
             q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel >> 4),
               q);
             p+=GetPixelChannels(image);
@@ -1673,8 +1676,8 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
         }
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
-          GetPixelIntensity(image,p),range),q);
+        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+          GetPixelIntensity(image,p)),range),q);
         p+=GetPixelChannels(image);
         q+=quantum_info->pad;
       }
@@ -1699,7 +1702,7 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
         }
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,p)));
         q=PopShortPixel(quantum_info->endian,pixel,q);
         p+=GetPixelChannels(image);
         q+=quantum_info->pad;
@@ -1727,7 +1730,7 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
         }
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
         q=PopLongPixel(quantum_info->endian,pixel,q);
         p+=GetPixelChannels(image);
         q+=quantum_info->pad;
@@ -1743,7 +1746,7 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
             double
               pixel;
 
-            pixel=(double) GetPixelIntensity(image,p);
+            pixel=GetPixelIntensity(image,p);
             q=PopDoublePixel(quantum_info,pixel,q);
             p+=GetPixelChannels(image);
             q+=quantum_info->pad;
@@ -1756,8 +1759,8 @@ static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
       range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
-          GetPixelIntensity(image,p),range),q);
+        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+          GetPixelIntensity(image,p)),range),q);
         p+=GetPixelChannels(image);
         q+=quantum_info->pad;
       }
@@ -1780,7 +1783,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
   {
     case 1:
     {
-      register Quantum
+      register double
         threshold;
 
       register unsigned char
@@ -1798,7 +1801,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
           black=0x01;
           white=0x00;
         }
-      threshold=(Quantum) (QuantumRange/2);
+      threshold=QuantumRange/2.0;
       for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
       {
         *q='\0';
@@ -1848,7 +1851,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
 
       for (x=0; x < (ssize_t) number_pixels ; x++)
       {
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
         *q=(((pixel >> 4) & 0xf) << 4);
         pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
         *q|=pixel & 0xf;
@@ -1864,7 +1867,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
 
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
         q=PopCharPixel(pixel,q);
         pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
         q=PopCharPixel(pixel,q);
@@ -1894,7 +1897,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
         }
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,p)));
         q=PopShortPixel(quantum_info->endian,pixel,q);
         pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
         q=PopShortPixel(quantum_info->endian,pixel,q);
@@ -1926,7 +1929,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
         }
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
+        pixel=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
         q=PopLongPixel(quantum_info->endian,pixel,q);
         pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
         q=PopLongPixel(quantum_info->endian,pixel,q);
@@ -1944,7 +1947,7 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
             double
               pixel;
 
-            pixel=(double) GetPixelIntensity(image,p);
+            pixel=GetPixelIntensity(image,p);
             q=PopDoublePixel(quantum_info,pixel,q);
             pixel=(double) (GetPixelAlpha(image,p));
             q=PopDoublePixel(quantum_info,pixel,q);
@@ -1959,8 +1962,8 @@ static void ExportGrayAlphaQuantum(const Image *image,QuantumInfo *quantum_info,
       range=GetQuantumRange(quantum_info->depth);
       for (x=0; x < (ssize_t) number_pixels; x++)
       {
-        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(
-          GetPixelIntensity(image,p),range),q);
+        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(ClampToQuantum(
+          GetPixelIntensity(image,p)),range),q);
         q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),
           range),q);
         p+=GetPixelChannels(image);

diff --git a/MagickCore/shear.c b/MagickCore/shear.c
index 0bb3fd923b5ffe594b44e1d015ae66f78ce9de38..95de2a5cfcac091bed95fdf23ab4199a210ca785 100644 (file)
--- a/MagickCore/shear.c
+++ b/MagickCore/shear.c
@@ -683,7 +683,7 @@ static MagickBooleanType RadonTransform(const Image *image,
     for (x=0; x < (ssize_t) image->columns; x++)
     {
       byte<<=1;
-      if ((double) GetPixelIntensity(image,p) < threshold)
+      if (GetPixelIntensity(image,p) < threshold)
         byte|=0x01;
       bit++;
       if (bit == 8)
@@ -733,7 +733,7 @@ static MagickBooleanType RadonTransform(const Image *image,
     for (x=0; x < (ssize_t) image->columns; x++)
     {
       byte<<=1;
-      if ((double) GetPixelIntensity(image,p) < threshold)
+      if (GetPixelIntensity(image,p) < threshold)
         byte|=0x01;
       bit++;
       if (bit == 8)

diff --git a/MagickCore/stream.c b/MagickCore/stream.c
index cef10b0ae5cca00026097e8091e831d92743dd28..9b9c011c77007474b78a26dba50c22e8b0c9d673 100644 (file)
--- a/MagickCore/stream.c
+++ b/MagickCore/stream.c
@@ -1472,7 +1472,7 @@ static MagickBooleanType StreamImagePixels(const StreamInfo *stream_info,
             break;
           for (x=0; x < (ssize_t) GetImageExtent(image); x++)
           {
-            *q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
+            *q++=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
             p++;
           }
           break;
@@ -1567,7 +1567,7 @@ static MagickBooleanType StreamImagePixels(const StreamInfo *stream_info,
             }
             case IndexQuantum:
             {
-              *q=ScaleQuantumToChar(GetPixelIntensity(image,p));
+              *q=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
               break;
             }
             default:
@@ -2020,7 +2020,7 @@ static MagickBooleanType StreamImagePixels(const StreamInfo *stream_info,
             break;
           for (x=0; x < (ssize_t) GetImageExtent(image); x++)
           {
-            *q++=ScaleQuantumToLong(GetPixelIntensity(image,p));
+            *q++=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
             p++;
           }
           break;
@@ -2115,7 +2115,7 @@ static MagickBooleanType StreamImagePixels(const StreamInfo *stream_info,
             }
             case IndexQuantum:
             {
-              *q=ScaleQuantumToLong(GetPixelIntensity(image,p));
+              *q=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
               break;
             }
             default:
@@ -2184,8 +2184,8 @@ static MagickBooleanType StreamImagePixels(const StreamInfo *stream_info,
             break;
           for (x=0; x < (ssize_t) GetImageExtent(image); x++)
           {
-            *q++=ScaleQuantumToLongLong(
-              GetPixelIntensity(image,p));
+            *q++=ScaleQuantumToLongLong(ClampToQuantum(
+              GetPixelIntensity(image,p)));
             p++;
           }
           break;
@@ -2280,7 +2280,8 @@ static MagickBooleanType StreamImagePixels(const StreamInfo *stream_info,
             }
             case IndexQuantum:
             {
-              *q=ScaleQuantumToLongLong(GetPixelIntensity(image,p));
+              *q=ScaleQuantumToLongLong(ClampToQuantum(
+                GetPixelIntensity(image,p)));
               break;
             }
             default:
@@ -2349,7 +2350,7 @@ static MagickBooleanType StreamImagePixels(const StreamInfo *stream_info,
             break;
           for (x=0; x < (ssize_t) GetImageExtent(image); x++)
           {
-            *q++=GetPixelIntensity(image,p);
+            *q++=ClampToQuantum(GetPixelIntensity(image,p));
             p++;
           }
           break;
@@ -2444,7 +2445,7 @@ static MagickBooleanType StreamImagePixels(const StreamInfo *stream_info,
             }
             case IndexQuantum:
             {
-              *q=GetPixelIntensity(image,p);
+              *q=ClampToQuantum(GetPixelIntensity(image,p));
               break;
             }
             default:
@@ -2513,7 +2514,8 @@ static MagickBooleanType StreamImagePixels(const StreamInfo *stream_info,
             break;
           for (x=0; x < (ssize_t) GetImageExtent(image); x++)
           {
-            *q++=ScaleQuantumToShort(GetPixelIntensity(image,p));
+            *q++=ScaleQuantumToShort(ClampToQuantum(
+              GetPixelIntensity(image,p)));
             p++;
           }
           break;
@@ -2608,7 +2610,8 @@ static MagickBooleanType StreamImagePixels(const StreamInfo *stream_info,
             }
             case IndexQuantum:
             {
-              *q=ScaleQuantumToShort(GetPixelIntensity(image,p));
+              *q=ScaleQuantumToShort(ClampToQuantum(
+                GetPixelIntensity(image,p)));
               break;
             }
             default:

diff --git a/MagickCore/threshold.c b/MagickCore/threshold.c
index 429ea04c8f197da302ad8010bdfbbac2029bb0be..009d6371e3f41c4503466645489596ed5983bbab 100644 (file)
--- a/MagickCore/threshold.c
+++ b/MagickCore/threshold.c
@@ -424,7 +424,7 @@ MagickExport MagickBooleanType BilevelImage(Image *image,const double threshold,
           q+=GetPixelChannels(image);
           continue;
         }
-      pixel=(double) GetPixelIntensity(image,q);
+      pixel=GetPixelIntensity(image,q);
       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
       {
         PixelChannel
@@ -438,7 +438,7 @@ MagickExport MagickBooleanType BilevelImage(Image *image,const double threshold,
         if ((traits & UpdatePixelTrait) == 0)
           continue;
         if (image->channel_mask != DefaultChannels)
-          pixel=q[i];
+          pixel=(double) q[i];
         q[i]=(Quantum) (pixel <= threshold ? 0 : QuantumRange);
       }
       q+=GetPixelChannels(image);
@@ -595,7 +595,7 @@ MagickExport MagickBooleanType BlackThresholdImage(Image *image,
           q+=GetPixelChannels(image);
           continue;
         }
-      pixel=(double) GetPixelIntensity(image,q);
+      pixel=GetPixelIntensity(image,q);
       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
       {
         PixelChannel
@@ -609,7 +609,7 @@ MagickExport MagickBooleanType BlackThresholdImage(Image *image,
         if ((traits & UpdatePixelTrait) == 0)
           continue;
         if (image->channel_mask != DefaultChannels)
-          pixel=q[i];
+          pixel=(double) q[i];
         if (pixel <= GetPixelInfoChannel(&threshold,channel))
           q[i]=0;
       }
@@ -1734,7 +1734,7 @@ MagickExport MagickBooleanType WhiteThresholdImage(Image *image,
           q+=GetPixelChannels(image);
           continue;
         }
-      pixel=(double) GetPixelIntensity(image,q);
+      pixel=GetPixelIntensity(image,q);
       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
       {
         PixelChannel
@@ -1748,7 +1748,7 @@ MagickExport MagickBooleanType WhiteThresholdImage(Image *image,
         if ((traits & UpdatePixelTrait) == 0)
           continue;
         if (image->channel_mask != DefaultChannels)
-          pixel=q[i];
+          pixel=(double) q[i];
         if (pixel > GetPixelInfoChannel(&threshold,channel))
           q[i]=QuantumRange;
       }

diff --git a/MagickCore/xwindow-private.h b/MagickCore/xwindow-private.h
index 7506c95c933e4514110946cfe3f36220ddf12a08..b1c8b7d48cfd4f1ad38bac29b27822757dbe8c4c 100644 (file)
--- a/MagickCore/xwindow-private.h
+++ b/MagickCore/xwindow-private.h
@@ -603,14 +603,10 @@ static inline double XPixelIntensity(const XColor *pixel)
     green,
     red;
 
-  double
-    intensity;
-
-  red=InversesRGBCompandor(pixel->red);
-  green=InversesRGBCompandor(pixel->green);
-  blue=InversesRGBCompandor(pixel->blue);
-  intensity=0.298839*red+0.586811*green+0.114350*blue;
-  return(intensity);
+  red=InversesRGBCompandor((double) pixel->red);
+  green=InversesRGBCompandor((double) pixel->green);
+  blue=InversesRGBCompandor((double) pixel->blue);
+  return(0.298839*red+0.586811*green+0.114350*blue);
 }
 
 #endif