(no commit message)

diff --git a/MagickCore/image.h b/MagickCore/image.h
index d3c1f1b44fdc48e2b2ce641441c921bcf997507c..ebd0f67b8d43e5607acb8227193a898329621420 100644 (file)
--- a/MagickCore/image.h
+++ b/MagickCore/image.h
@@ -216,6 +216,9 @@ struct _Image
   FilterTypes
     filter;         /* resize/distort filter to apply */
 
+  PixelIntensityMethod
+    intensity;      /* method to generate an intensity value from a pixel */
+
   InterlaceType
     interlace;
 

diff --git a/MagickCore/pixel.c b/MagickCore/pixel.c
index 592bac9e60715b32f6c8f43647907b0eaef51d81..9c674cb2640cff14a920b58530103f8350f01818 100644 (file)
--- a/MagickCore/pixel.c
+++ b/MagickCore/pixel.c
@@ -494,7 +494,7 @@ static void ExportCharPixel(Image *image,const RectangleInfo *roi,
           break;
         for (x=0; x < (ssize_t) roi->width; x++)
         {
-          *q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
+          *q++=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
           p+=GetPixelChannels(image);
         }
       }
@@ -605,7 +605,7 @@ static void ExportCharPixel(Image *image,const RectangleInfo *roi,
           }
           case IndexQuantum:
           {
-            *q=ScaleQuantumToChar(GetPixelIntensity(image,p));
+            *q=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
             break;
           }
           default:
@@ -1113,7 +1113,7 @@ static void ExportLongPixel(Image *image,const RectangleInfo *roi,
           break;
         for (x=0; x < (ssize_t) roi->width; x++)
         {
-          *q++=ScaleQuantumToLong(GetPixelIntensity(image,p));
+          *q++=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
           p+=GetPixelChannels(image);
         }
       }
@@ -1224,7 +1224,7 @@ static void ExportLongPixel(Image *image,const RectangleInfo *roi,
           }
           case IndexQuantum:
           {
-            *q=ScaleQuantumToLong(GetPixelIntensity(image,p));
+            *q=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
             break;
           }
           default:
@@ -1319,7 +1319,7 @@ static void ExportLongLongPixel(Image *image,const RectangleInfo *roi,
           break;
         for (x=0; x < (ssize_t) roi->width; x++)
         {
-          *q++=ScaleQuantumToLongLong(GetPixelIntensity(image,p));
+          *q++=ScaleQuantumToLongLong(ClampToQuantum(GetPixelIntensity(image,p)));
           p+=GetPixelChannels(image);
         }
       }
@@ -1430,7 +1430,7 @@ static void ExportLongLongPixel(Image *image,const RectangleInfo *roi,
           }
           case IndexQuantum:
           {
-            *q=ScaleQuantumToLongLong(GetPixelIntensity(image,p));
+            *q=ScaleQuantumToLongLong(ClampToQuantum(GetPixelIntensity(image,p)));
             break;
           }
           default:
@@ -1525,7 +1525,7 @@ static void ExportQuantumPixel(Image *image,const RectangleInfo *roi,
           break;
         for (x=0; x < (ssize_t) roi->width; x++)
         {
-          *q++=GetPixelIntensity(image,p);
+          *q++=ClampToQuantum(GetPixelIntensity(image,p));
           p+=GetPixelChannels(image);
         }
       }
@@ -1636,7 +1636,7 @@ static void ExportQuantumPixel(Image *image,const RectangleInfo *roi,
           }
           case IndexQuantum:
           {
-            *q=(GetPixelIntensity(image,p));
+            *q=ClampToQuantum(GetPixelIntensity(image,p));
             break;
           }
           default:
@@ -1734,7 +1734,7 @@ static void ExportShortPixel(Image *image,const RectangleInfo *roi,
           break;
         for (x=0; x < (ssize_t) roi->width; x++)
         {
-          *q++=ScaleQuantumToShort(GetPixelIntensity(image,p));
+          *q++=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,p)));
           p+=GetPixelChannels(image);
         }
       }
@@ -1845,7 +1845,7 @@ static void ExportShortPixel(Image *image,const RectangleInfo *roi,
           }
           case IndexQuantum:
           {
-            *q=ScaleQuantumToShort(GetPixelIntensity(image,p));
+            *q=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,p)));
             break;
           }
           default:
@@ -2096,7 +2096,14 @@ MagickExport void GetPixelInfo(const Image *image,PixelInfo *pixel)
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
 %  GetPixelIntensity() returns a single sample intensity value from the red,
-%  green, and blue components of a pixel.
+%  green, and blue components of a pixel based on the selected method:
+%
+%    Rec601Luma   0.298839R + 0.586811G + 0.114350B
+%    Rec709Luma   0.21260R + 0.71520G + 0.07220B
+%    Brightness   max(R, G, B)
+%    Lightness    (min(R, G, B) + max(R, G, B)) / 2.0
+%    RMS          (R^2 + G^2 + B^2) / 3.0
+%    Average      (R + G + B) / 3.0
 %
 %  The format of the GetPixelIntensity method is:
 %
@@ -2109,27 +2116,96 @@ MagickExport void GetPixelInfo(const Image *image,PixelInfo *pixel)
 %    o pixel: Specifies a pointer to a Quantum structure.
 %
 */
+
+static inline MagickRealType MagickMax(const MagickRealType x,
+  const MagickRealType y)
+{
+  if (x > y)
+    return(x);
+  return(y);
+}
+
+static inline MagickRealType MagickMin(const MagickRealType x,
+  const MagickRealType y)
+{
+  if (x < y)
+    return(x);
+  return(y);
+}
+
 MagickExport MagickRealType GetPixelIntensity(const Image *restrict image,
   const Quantum *restrict pixel)
 {
   MagickRealType
     blue,
     green,
-    red;
+    red,
+    intensity;
 
   if (image->colorspace == GRAYColorspace)
     return((MagickRealType) pixel[image->channel_map[GrayPixelChannel].offset]);
-  if (image->colorspace != sRGBColorspace)
-    return(0.298839f*pixel[image->channel_map[RedPixelChannel].offset]+
-      0.586811f*pixel[image->channel_map[GreenPixelChannel].offset]+
-      0.114350f*pixel[image->channel_map[BluePixelChannel].offset]);
-  red=DecodePixelGamma((MagickRealType)
-    pixel[image->channel_map[RedPixelChannel].offset]);
-  green=DecodePixelGamma((MagickRealType)
-    pixel[image->channel_map[GreenPixelChannel].offset]);
-  blue=DecodePixelGamma((MagickRealType)
-    pixel[image->channel_map[BluePixelChannel].offset]);
-  return(0.298839f*red+0.586811f*green+0.114350f*blue);
+  red=(MagickRealType) pixel[image->channel_map[RedPixelChannel].offset];
+  green=(MagickRealType) pixel[image->channel_map[GreenPixelChannel].offset];
+  blue=(MagickRealType) pixel[image->channel_map[BluePixelChannel].offset];
+  switch (image->intensity)
+  {
+    case Rec601LumaPixelIntensityMethod:
+    default:
+    {
+      if (image->colorspace == sRGBColorspace)
+        {
+          red=DecodePixelGamma(red);
+          green=DecodePixelGamma(green);
+          blue=DecodePixelGamma(blue);
+        }
+      intensity=0.298839f*red+0.586811f*green+0.114350f*blue;
+      break;
+    }
+    case Rec709LumaPixelIntensityMethod:
+    {
+      if (image->colorspace == sRGBColorspace)
+        {
+          red=DecodePixelGamma(red);
+          green=DecodePixelGamma(green);
+          blue=DecodePixelGamma(blue);
+        }
+      intensity=0.21260f*red+0.71520f*green+0.07220f*blue;
+      break;
+    }
+    case BrightnessPixelIntensityMethod:
+    {
+      if (image->colorspace == sRGBColorspace)
+        {
+          red=DecodePixelGamma(red);
+          green=DecodePixelGamma(green);
+          blue=DecodePixelGamma(blue);
+        }
+      intensity=MagickMax(MagickMax(red,green),blue);
+      break;
+    }
+    case LightnessPixelIntensityMethod:
+    {
+      if (image->colorspace == sRGBColorspace)
+        {
+          red=DecodePixelGamma(red);
+          green=DecodePixelGamma(green);
+          blue=DecodePixelGamma(blue);
+        }
+      intensity=MagickMin(MagickMin(red,green),blue);
+      break;
+    }
+    case RMSPixelIntensityMethod:
+    {
+      intensity=(MagickRealType) sqrt((double) red*red+green*green+blue*blue);
+      break;
+    }
+    case AveragePixelIntensityMethod:
+    {
+      intensity=(red+green+blue)/3.0;
+      break;
+    }
+  }
+  return(intensity);
 }
 
 \f
@@ -4094,13 +4170,6 @@ MagickExport void InitializePixelChannelMap(Image *image)
 %
 */
 
-static inline double MagickMax(const double x,const double y)
-{
-  if (x > y)
-    return(x);
-  return(y);
-}
-
 static inline void CatromWeights(const double x,double (*weights)[4])
 {
   double
@@ -4228,8 +4297,8 @@ MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
             x_offset--;
             y_offset--;
           }
-      p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,count,count,
-        exception);
+      p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,(size_t) count,(size_t)
+        count,exception);
       if (p == (const Quantum *) NULL)
         {
           status=MagickFalse;
@@ -4687,8 +4756,8 @@ MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
             x_offset--;
             y_offset--;
           }
-      p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,count,count,
-        exception);
+      p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,(size_t) count,(size_t)
+        count,exception);
       if (p == (const Quantum *) NULL)
         {
           status=MagickFalse;
@@ -5302,8 +5371,8 @@ MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
           x_offset--;
           y_offset--;
         }
-      p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,count,count,
-        exception);
+      p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,(size_t) count,(size_t)
+        count,exception);
       if (p == (const Quantum *) NULL)
         {
           status=MagickFalse;
@@ -5774,8 +5843,7 @@ MagickExport MagickBooleanType IsFuzzyEquivalencePixel(const Image *source,
       /*
         Transparencies are involved - set alpha distance
       */
-      pixel=GetPixelAlpha(source,p)-(double)
-        GetPixelAlpha(destination,q);
+      pixel=GetPixelAlpha(source,p)-(double) GetPixelAlpha(destination,q);
       distance=pixel*pixel;
       if (distance > fuzz)
         return(MagickFalse);

diff --git a/MagickCore/property.c b/MagickCore/property.c
index c115c11689acbc51acfab3d6f4bea7b557d19a1e..dca063dc3d3b0c45a13b81bfef6b623768f42b2a 100644 (file)
--- a/MagickCore/property.c
+++ b/MagickCore/property.c
@@ -3676,6 +3676,18 @@ MagickExport MagickBooleanType SetImageProperty(Image *image,
     case 'I':
     case 'i':
     {
+      if (LocaleCompare("intensity",property) == 0)
+        {
+          ssize_t
+            intensity;
+
+          intensity=ParseCommandOption(MagickIntentOptions,MagickFalse,
+            value);
+          if (intensity < 0)
+            return(MagickFalse);
+          image->intensity=(PixelIntensityMethod) intensity;
+          return(MagickTrue);
+        }
       if (LocaleCompare("intent",property) == 0)
         {
           ssize_t

diff --git a/MagickWand/convert.c b/MagickWand/convert.c
index 4ffd6c8445fbac454751d82ee38008eb8135f49b..0b498f5ce2e2c93bf84991b808b4398abde10ad8 100644 (file)
--- a/MagickWand/convert.c
+++ b/MagickWand/convert.c
@@ -379,7 +379,7 @@ static MagickBooleanType ConvertUsage(void)
       "-fuzz distance       colors within this distance are considered equal",
       "-gravity type        horizontal and vertical text placement",
       "-green-primary point chromaticity green primary point",
-      "-intensity method    method to generate intensity value from pixel",
+      "-intensity method    method to generate an intensity value from a pixel",
       "-intent type         type of rendering intent when managing the image color",
       "-interlace type      type of image interlacing scheme",
       "-interline-spacing value",
@@ -1709,6 +1709,21 @@ WandExport MagickBooleanType ConvertImageCommand(ImageInfo *image_info,
               ThrowConvertInvalidArgumentException(option,argv[i]);
             break;
           }
+        if (LocaleCompare("intensity",option+1) == 0)
+          {
+            ssize_t
+              intensity;
+
+            if (*option == '+')
+              break;
+            i++;
+            if (i == (ssize_t) (argc-1))
+              ThrowConvertException(OptionError,"MissingArgument",option);
+            intensity=ParseCommandOption(MagickPixelIntensityOptions,MagickFalse,argv[i]);
+            if (intensity < 0)
+              ThrowConvertException(OptionError,"UnrecognizedPixelIntensityMethod",argv[i]);
+            break;
+          }
         if (LocaleCompare("intent",option+1) == 0)
           {
             ssize_t
@@ -1719,11 +1734,9 @@ WandExport MagickBooleanType ConvertImageCommand(ImageInfo *image_info,
             i++;
             if (i == (ssize_t) (argc-1))
               ThrowConvertException(OptionError,"MissingArgument",option);
-            intent=ParseCommandOption(MagickIntentOptions,MagickFalse,
-              argv[i]);
+            intent=ParseCommandOption(MagickIntentOptions,MagickFalse,argv[i]);
             if (intent < 0)
-              ThrowConvertException(OptionError,"UnrecognizedIntentType",
-                argv[i]);
+              ThrowConvertException(OptionError,"UnrecognizedIntentType",argv[i]);
             break;
           }
         if (LocaleCompare("interlace",option+1) == 0)

diff --git a/MagickWand/mogrify.c b/MagickWand/mogrify.c
index 278812e6b555dbadda6cf4b5e6738e65cef27914..cec3a47d25dda6c5e9492766a27b2ae814289ee3 100644 (file)
--- a/MagickWand/mogrify.c
+++ b/MagickWand/mogrify.c
@@ -3452,7 +3452,7 @@ static MagickBooleanType MogrifyUsage(void)
       "-fuzz distance       colors within this distance are considered equal",
       "-gravity type        horizontal and vertical text placement",
       "-green-primary point chromaticity green primary point",
-      "-intensity method    method to generate intensity value from pixel",
+      "-intensity method    method to generate an intensity value from a pixel",
       "-intent type         type of rendering intent when managing the image color",
       "-interlace type      type of image interlacing scheme",
       "-interline-spacing value",
@@ -4778,6 +4778,22 @@ WandExport MagickBooleanType MogrifyImageCommand(ImageInfo *image_info,
               ThrowMogrifyInvalidArgumentException(option,argv[i]);
             break;
           }
+        if (LocaleCompare("intensity",option+1) == 0)
+          {
+            ssize_t
+              intensity;
+
+            if (*option == '+')
+              break;
+            i++;
+            if (i == (ssize_t) (argc-1))
+              ThrowMogrifyException(OptionError,"MissingArgument",option);
+            intensity=ParseCommandOption(MagickPixelIntensityOptions,MagickFalse,argv[i]);
+            if (intensity < 0)
+              ThrowMogrifyException(OptionError,"UnrecognizedPixelIntensityMethod",
+                argv[i]);
+            break;
+          }
         if (LocaleCompare("intent",option+1) == 0)
           {
             ssize_t
@@ -6582,6 +6598,16 @@ WandExport MagickBooleanType MogrifyImageInfo(ImageInfo *image_info,
       }
       case 'i':
       {
+        if (LocaleCompare("intensity",option+1) == 0)
+          {
+            if (*option == '+')
+              {
+                (void) SetImageOption(image_info,option+1,"undefined");
+                break;
+              }
+            (void) SetImageOption(image_info,option+1,argv[i+1]);
+            break;
+          }
         if (LocaleCompare("intent",option+1) == 0)
           {
             if (*option == '+')

diff --git a/MagickWand/operation.c b/MagickWand/operation.c
index df93a44d8b6fc113ba966b8b5c35a8003dd5f5ce..939002e1defbb3b75308b4e7de2cf0bb42967684 100644 (file)
--- a/MagickWand/operation.c
+++ b/MagickWand/operation.c
@@ -949,13 +949,22 @@ interpret Percent Escapes in Arguments, At least not yet */
     }
     case 'i':
     {
+      if (LocaleCompare("intensity",option+1) == 0)
+        {
+          arg1 = ArgOption("undefined");
+          parse = ParseCommandOption(MagickPixelIntensityOptions,MagickFalse,arg1);
+          if (parse < 0)
+            CLIWandExceptArgBreak(OptionError,"UnrecognizedIntentType",option,arg1);
+          (void) SetImageOption(_image_info,option+1,arg1);
+          break;
+        }
       if (LocaleCompare("intent",option+1) == 0)
         {
           /* Only used by coders: MIFF, MPC, BMP, PNG
              and for image profile call to AcquireTransformThreadSet()
              SyncImageSettings() used to set per-image attribute.
           */
-          arg1 = ArgOption("indefined");
+          arg1 = ArgOption("undefined");
           parse = ParseCommandOption(MagickIntentOptions,MagickFalse,arg1);
           if (parse < 0)
             CLIWandExceptArgBreak(OptionError,"UnrecognizedIntentType",

diff --git a/coders/txt.c b/coders/txt.c
index f7cc93148e70240634cbf843f1a39722a2232a34..6c74bd00ffddd401ddc9e9e0ad182391c0c37198 100644 (file)
--- a/coders/txt.c
+++ b/coders/txt.c
@@ -715,16 +715,18 @@ static MagickBooleanType WriteTXTImage(const ImageInfo *image_info,Image *image,
             pixel.green-=(QuantumRange+1)/2.0;
             pixel.blue-=(QuantumRange+1)/2.0;
           }
-        if ((sparse_color != MagickFalse) &&
-            (GetPixelAlpha(image,p) == (Quantum) OpaqueAlpha))
+        if (sparse_color != MagickFalse)
           {
             /*
               Sparse-color format.
             */
-            (void) QueryColorname(image,&pixel,SVGCompliance,tuple,exception);
-            (void) WriteBlobString(image," ");
-            (void) WriteBlobString(image,tuple);
-            (void) WriteBlobString(image," ");
+            if (GetPixelAlpha(image,p) == (Quantum) OpaqueAlpha)
+              {
+                (void) QueryColorname(image,&pixel,SVGCompliance,tuple,exception);
+                (void) WriteBlobString(image," ");
+                (void) WriteBlobString(image,tuple);
+                (void) WriteBlobString(image," ");
+              }
             p+=GetPixelChannels(image);
             continue;
           }