(no commit message)

diff --git a/MagickCore/enhance.c b/MagickCore/enhance.c
index c36c7c4e07d8825f0c90779917c2522ac4003063..17896cde6ddb00f57bc6d54fb5e60f535000f2a3 100644 (file)
--- a/MagickCore/enhance.c
+++ b/MagickCore/enhance.c
@@ -1878,6 +1878,200 @@ MagickExport MagickBooleanType GammaImage(Image *image,const double gamma,
 %                                                                             %
 %                                                                             %
 %                                                                             %
+%     G r a y s c a l e I m a g e                                             %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  GrayscaleImage() converts the image to grayscale.
+%
+%  The format of the GrayscaleImage method is:
+%
+%      MagickBooleanType GrayscaleImage(Image *image,
+%        const PixelIntensityMethod method ,ExceptionInfo *exception)
+%
+%  A description of each parameter follows:
+%
+%    o image: the image.
+%
+%    o method: the pixel intensity method.
+%
+%    o exception: return any errors or warnings in this 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 MagickBooleanType GrayscaleImage(Image *image,
+  const PixelIntensityMethod grayscale,ExceptionInfo *exception)
+{
+#define GrayscaleImageTag  "Grayscale/Image"
+
+  CacheView
+    *image_view;
+
+  MagickBooleanType
+    status;
+
+  MagickOffsetType
+    progress;
+
+  ssize_t
+    y;
+
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
+  if (image->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+  if (image->storage_class == PseudoClass)
+    {
+      if (SyncImage(image,exception) == MagickFalse)
+        return(MagickFalse);
+      if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
+        return(MagickFalse);
+    }
+  /*
+    Grayscale image.
+  */
+  status=MagickTrue;
+  progress=0;
+  image_view=AcquireAuthenticCacheView(image,exception);
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+  #pragma omp parallel for schedule(static,4) shared(progress,status) \
+    magick_threads(image,image,image->rows,1)
+#endif
+  for (y=0; y < (ssize_t) image->rows; y++)
+  {
+    register Quantum
+      *restrict q;
+
+    register ssize_t
+      x;
+
+    if (status == MagickFalse)
+      continue;
+    q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
+    if (q == (Quantum *) NULL)
+      {
+        status=MagickFalse;
+        continue;
+      }
+    for (x=0; x < (ssize_t) image->columns; x++)
+    {
+      MagickRealType
+        blue,
+        green,
+        red,
+        intensity;
+
+      if (GetPixelMask(image,q) == 0)
+        {
+          q+=GetPixelChannels(image);
+          continue;
+        }
+      red=(MagickRealType) GetPixelRed(image,q);
+      green=(MagickRealType) GetPixelGreen(image,q);
+      blue=(MagickRealType) GetPixelBlue(image,q);
+      switch (image->intensity)
+      {
+        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);
+          break;
+        }
+        case Rec601LumaPixelIntensityMethod:
+        {
+          intensity=0.298839f*red+0.586811f*green+0.114350f*blue;
+          break;
+        }
+        case Rec601LuminancePixelIntensityMethod:
+        {
+          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:
+        default:
+        {
+          intensity=0.21260f*red+0.71520f*green+0.07220f*blue;
+          break;
+        }
+        case Rec709LuminancePixelIntensityMethod:
+        {
+          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 RMSPixelIntensityMethod:
+        {
+          intensity=(MagickRealType) sqrt((double) red*red+green*green+
+            blue*blue);
+          break;
+        }
+      }
+      SetPixelGray(image,ClampToQuantum(intensity),q);
+      q+=GetPixelChannels(image);
+    }
+    if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
+      status=MagickFalse;
+    if (image->progress_monitor != (MagickProgressMonitor) NULL)
+      {
+        MagickBooleanType
+          proceed;
+
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+        #pragma omp critical (MagickCore_GrayscaleImage)
+#endif
+        proceed=SetImageProgress(image,GrayscaleImageTag,progress++,
+           image->rows);
+        if (proceed == MagickFalse)
+          status=MagickFalse;
+      }
+  }
+  image_view=DestroyCacheView(image_view);
+  return(status);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
 %     H a l d C l u t I m a g e                                               %
 %                                                                             %
 %                                                                             %
@@ -1904,14 +2098,6 @@ MagickExport MagickBooleanType GammaImage(Image *image,const double gamma,
 %    o exception: return any errors or warnings in this structure.
 %
 */
-
-static inline size_t MagickMin(const size_t x,const size_t y)
-{
-  if (x < y)
-    return(x);
-  return(y);
-}
-
 MagickExport MagickBooleanType HaldClutImage(Image *image,
   const Image *hald_image,ExceptionInfo *exception)
 {
@@ -1966,7 +2152,8 @@ MagickExport MagickBooleanType HaldClutImage(Image *image,
   */
   status=MagickTrue;
   progress=0;
-  length=MagickMin(hald_image->columns,hald_image->rows);
+  length=(size_t) MagickMin((MagickRealType) hald_image->columns,
+    (MagickRealType) hald_image->rows);
   for (level=2; (level*level*level) < length; level++) ;
   level*=level;
   cube_size=level*level;

diff --git a/MagickCore/enhance.h b/MagickCore/enhance.h
index 86cf58a7528a8d1e60cc9b8acb46aea02e994436..b56857869fcb0957fb0b4eb1fe4fda596f59a4ee 100644 (file)
--- a/MagickCore/enhance.h
+++ b/MagickCore/enhance.h
@@ -22,6 +22,8 @@
 extern "C" {
 #endif
 
+#include "MagickCore/pixel.h"
+
 extern MagickExport MagickBooleanType
   AutoGammaImage(Image *,ExceptionInfo *),
   AutoLevelImage(Image *,ExceptionInfo *),
@@ -32,6 +34,7 @@ extern MagickExport MagickBooleanType
   ContrastStretchImage(Image *,const double,const double,ExceptionInfo *),
   EqualizeImage(Image *image,ExceptionInfo *),
   GammaImage(Image *,const double,ExceptionInfo *),
+  GrayscaleImage(Image *,const PixelIntensityMethod,ExceptionInfo *),
   HaldClutImage(Image *,const Image *,ExceptionInfo *),
   LevelImage(Image *,const double,const double,const double,ExceptionInfo *),
   LevelizeImage(Image *,const double,const double,const double,ExceptionInfo *),

diff --git a/MagickWand/mogrify.c b/MagickWand/mogrify.c
index 9692d2da6b60e45ef0f4009bf2aa718aa0d27727..6f2c455297e5c28ac4bebb9b430ace24b11688ad 100644 (file)
--- a/MagickWand/mogrify.c
+++ b/MagickWand/mogrify.c
@@ -1755,16 +1755,13 @@ WandExport MagickBooleanType MogrifyImage(ImageInfo *image_info,const int argc,
           }
         if (LocaleCompare("grayscale",option+1) == 0)
           {
+            PixelIntensityMethod
+              method;
+
             (void) SyncImageSettings(mogrify_info,*image,exception);
-            if (*option == '+')
-              {
-                (void) TransformImageColorspace(*image,sRGBColorspace,
-                  exception);
-                break;
-              }
-            (*image)->intensity=(PixelIntensityMethod) ParseCommandOption(
+            method=(PixelIntensityMethod) ParseCommandOption(
               MagickPixelIntensityOptions,MagickFalse,argv[i+1]);
-            (void) TransformImageColorspace(*image,GRAYColorspace,exception);
+            (void) GrayscaleImage(*image,method,exception);
             break;
           }
         break;

diff --git a/MagickWand/operation.c b/MagickWand/operation.c
index 253fe10c95dfe014b5cf6873ca627b8b25855f11..91eb28a158ad3c7330c891ff31126598ba22746c 100644 (file)
--- a/MagickWand/operation.c
+++ b/MagickWand/operation.c
@@ -168,8 +168,7 @@ static inline Image *GetImageCache(const ImageInfo *image_info,const char *path,
   This really should be in MagickCore, so that other API's can make use of it.
 */
 static Image *SparseColorOption(const Image *image,
-  const SparseColorMethod method,const char *arguments,
-  ExceptionInfo *exception)
+  const SparseColorMethod method,const char *arguments,ExceptionInfo *exception)
 {
   char
     token[MaxTextExtent];
@@ -2447,17 +2446,14 @@ static MagickBooleanType CLISimpleOperatorImage(MagickCLI *cli_wand,
               _image->filter,_exception);
           break;
         }
-      if (LocaleCompare("distort",option+1) == 0)
+      if (LocaleCompare("grayscale",option+1) == 0)
         {
-          parse = ParseCommandOption(MagickPixelIntensityOptions,
+          parse=ParseCommandOption(MagickPixelIntensityOptions,
             MagickFalse,arg1);
-          if ( parse < 0 )
-             CLIWandExceptArgBreak(OptionError,"UnrecognizedIntensityMethod",
-               option,arg1);
-          _image->intensity = (PixelIntensityMethod) parse;
-          (void) TransformImageColorspace(_image,
-                    IfNormalOp ? _image_info->colorspace : GRAYColorspace,
-                    _exception);
+          if (parse < 0)
+            CLIWandExceptArgBreak(OptionError,"UnrecognizedIntensityMethod",
+              option,arg1);
+          (void) GrayscaleImage(_image,(PixelIntensityMethod) parse,_exception);
           break;
         }
       CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);

diff --git a/PerlMagick/quantum/quantum.xs.in b/PerlMagick/quantum/quantum.xs.in
index 7e3d6a7cc7665660f7bc510aa9d98c43c557ade7..cd40c8571950d7073dc4316fc5e73c2bf72924cf 100644 (file)
--- a/PerlMagick/quantum/quantum.xs.in
+++ b/PerlMagick/quantum/quantum.xs.in
@@ -10928,10 +10928,13 @@ Mogrify(ref,...)
         }
         case 137:  /* Grayscale */
         {
+          PixelIntensityMethod
+            method;
+
+          method=UndefinedPixelIntensityMethod;
           if (attribute_flag[0] != 0)
-            image->intensity=(PixelIntensityMethod)
-              argument_list[0].integer_reference;
-          (void) TransformImageColorspace(image,GRAYColorspace,exception);
+            method=(PixelIntensityMethod) argument_list[0].integer_reference;
+          (void) GrayscaleImage(image,method,exception);
           break;
         }
       }