Renamed IsImageGray to SetImageGray and IsImageMonochrome to SetImageMonochrome since...

Added new IsImageGray and IsImageMonochrome that only check if the image is gray or monochrome.

diff --git a/MagickCore/attribute.c b/MagickCore/attribute.c
index c82b0ea24ee2fcf6b873874754d5c5f86d6f45c0..dce8b8b4b292f24919bb0dac1e15ac4cc682f73b 100644 (file)
--- a/MagickCore/attribute.c
+++ b/MagickCore/attribute.c
@@ -601,9 +601,9 @@ MagickExport ImageType GetImageType(const Image *image,ExceptionInfo *exception)
         return(ColorSeparationType);
       return(ColorSeparationAlphaType);
     }
-  if (IsImageMonochrome(image,exception) != MagickFalse)
+  if (SetImageMonochrome((Image *) image,exception) != MagickFalse)
     return(BilevelType);
-  if (IsImageGray(image,exception) != MagickFalse)
+  if (SetImageGray((Image *) image,exception) != MagickFalse)
     {
       if (image->alpha_trait != UndefinedPixelTrait)
         return(GrayscaleAlphaType);
@@ -631,8 +631,8 @@ MagickExport ImageType GetImageType(const Image *image,ExceptionInfo *exception)
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  IsImageGray() returns MagickTrue if all the pixels in the image have the
-%  same red, green, and blue intensities.
+%  IsImageGray() returns MagickTrue if the type of the image is grayscale or
+%  bilevel.
 %
 %  The format of the IsImageGray method is:
 %
@@ -646,66 +646,14 @@ MagickExport ImageType GetImageType(const Image *image,ExceptionInfo *exception)
 %    o exception: return any errors or warnings in this structure.
 %
 */
-MagickExport MagickBooleanType IsImageGray(const Image *image,
-  ExceptionInfo *exception)
+MagickExport MagickBooleanType IsImageGray(const Image *image)
 {
-  CacheView
-    *image_view;
-
-  ImageType
-    type;
-
-  register const Quantum
-    *p;
-
-  register ssize_t
-    x;
-
-  ssize_t
-    y;
-
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
-  if (image->debug != MagickFalse)
-    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   if ((image->type == BilevelType) || (image->type == GrayscaleType) ||
       (image->type == GrayscaleAlphaType))
     return(MagickTrue);
-  if ((IsGrayColorspace(image->colorspace) == MagickFalse) &&
-      (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse))
-    return(MagickFalse);
-  type=BilevelType;
-  image_view=AcquireVirtualCacheView(image,exception);
-  for (y=0; y < (ssize_t) image->rows; y++)
-  {
-    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
-    if (p == (const Quantum *) NULL)
-      break;
-    for (x=0; x < (ssize_t) image->columns; x++)
-    {
-      if (IsPixelGray(image,p) == MagickFalse)
-        {
-          type=UndefinedType;
-          break;
-        }
-      if ((type == BilevelType) &&
-          (IsPixelMonochrome(image,p) == MagickFalse))
-        type=GrayscaleType;
-      p+=GetPixelChannels(image);
-    }
-    if (type == UndefinedType)
-      break;
-  }
-  image_view=DestroyCacheView(image_view);
-  if (type == UndefinedType)
-    return(MagickFalse);
-  ((Image *) image)->colorspace=GRAYColorspace;
-  if (SyncImagePixelCache((Image *) image,exception) == MagickFalse)
-    return(MagickFalse);
-  ((Image *) image)->type=type;
-  if ((type == GrayscaleType) && (image->alpha_trait != UndefinedPixelTrait))
-    ((Image *) image)->type=GrayscaleAlphaType;
-  return(MagickTrue);
+  return(MagickFalse);
 }
 \f
 /*
@@ -719,9 +667,7 @@ MagickExport MagickBooleanType IsImageGray(const Image *image,
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  IsImageMonochrome() returns MagickTrue if all the pixels in the image have
-%  the same red, green, and blue intensities and the intensity is either
-%  0 or QuantumRange.
+%  IsImageMonochrome() returns MagickTrue if type of the image is bi-level.
 %
 %  The format of the IsImageMonochrome method is:
 %
@@ -735,59 +681,12 @@ MagickExport MagickBooleanType IsImageGray(const Image *image,
 %    o exception: return any errors or warnings in this structure.
 %
 */
-MagickExport MagickBooleanType IsImageMonochrome(const Image *image,
-  ExceptionInfo *exception)
+MagickExport MagickBooleanType IsImageMonochrome(const Image *image)
 {
-  CacheView
-    *image_view;
-
-  ImageType
-    type;
-
-  register ssize_t
-    x;
-
-  register const Quantum
-    *p;
-
-  ssize_t
-    y;
-
   assert(image != (Image *) NULL);
   assert(image->signature == MagickSignature);
-  if (image->debug != MagickFalse)
-    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   if (image->type == BilevelType)
     return(MagickTrue);
-  if ((IsGrayColorspace(image->colorspace) == MagickFalse) &&
-      (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse))
-    return(MagickFalse);
-  type=BilevelType;
-  image_view=AcquireVirtualCacheView(image,exception);
-  for (y=0; y < (ssize_t) image->rows; y++)
-  {
-    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
-    if (p == (const Quantum *) NULL)
-      break;
-    for (x=0; x < (ssize_t) image->columns; x++)
-    {
-      if (IsPixelMonochrome(image,p) == MagickFalse)
-        {
-          type=UndefinedType;
-          break;
-        }
-      p+=GetPixelChannels(image);
-    }
-    if (type == UndefinedType)
-      break;
-  }
-  image_view=DestroyCacheView(image_view);
-  if (type == UndefinedType)
-    return(MagickFalse);
-  ((Image *) image)->colorspace=GRAYColorspace;
-  if (SyncImagePixelCache((Image *) image,exception) == MagickFalse)
-    return(MagickFalse);
-  ((Image *) image)->type=type;
   return(MagickTrue);
 }
 \f
@@ -1090,6 +989,177 @@ MagickExport MagickBooleanType SetImageDepth(Image *image,
 %                                                                             %
 %                                                                             %
 %                                                                             %
+%     S e t I m a g e G r a y                                                 %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  SetImageGray() returns MagickTrue if all the pixels in the image have the
+%  same red, green, and blue intensities and changes the type of the image to
+%  bi-level or grayscale.
+%
+%  The format of the SetImageGray method is:
+%
+%      MagickBooleanType SetImageGray(const Image *image,
+%        ExceptionInfo *exception)
+%
+%  A description of each parameter follows:
+%
+%    o image: the image.
+%
+%    o exception: return any errors or warnings in this structure.
+%
+*/
+MagickExport MagickBooleanType SetImageGray(Image *image,
+  ExceptionInfo *exception)
+{
+  CacheView
+    *image_view;
+
+  ImageType
+    type;
+
+  register const Quantum
+    *p;
+
+  register ssize_t
+    x;
+
+  ssize_t
+    y;
+
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
+  if (image->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+  if (IsImageGray(image))
+    return(MagickTrue);
+  if ((IsGrayColorspace(image->colorspace) == MagickFalse) &&
+      (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse))
+    return(MagickFalse);
+  type=BilevelType;
+  image_view=AcquireVirtualCacheView(image,exception);
+  for (y=0; y < (ssize_t) image->rows; y++)
+  {
+    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
+    if (p == (const Quantum *) NULL)
+      break;
+    for (x=0; x < (ssize_t) image->columns; x++)
+    {
+      if (IsPixelGray(image,p) == MagickFalse)
+        {
+          type=UndefinedType;
+          break;
+        }
+      if ((type == BilevelType) &&
+          (IsPixelMonochrome(image,p) == MagickFalse))
+        type=GrayscaleType;
+      p+=GetPixelChannels(image);
+    }
+    if (type == UndefinedType)
+      break;
+  }
+  image_view=DestroyCacheView(image_view);
+  if (type == UndefinedType)
+    return(MagickFalse);
+  image->colorspace=GRAYColorspace;
+  if (SyncImagePixelCache((Image *) image,exception) == MagickFalse)
+    return(MagickFalse);
+  image->type=type;
+  if ((type == GrayscaleType) && (image->alpha_trait != UndefinedPixelTrait))
+    image->type=GrayscaleAlphaType;
+  return(MagickTrue);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   S e t I m a g e M o n o c h r o m e                                       %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  SetImageMonochrome() returns MagickTrue if all the pixels in the image have
+%  the same red, green, and blue intensities and the intensity is either
+%  0 or QuantumRange and changes the type of the image to bi-level.
+%
+%  The format of the SetImageMonochrome method is:
+%
+%      MagickBooleanType SetImageMonochrome(const Image *image,
+%        ExceptionInfo *exception)
+%
+%  A description of each parameter follows:
+%
+%    o image: the image.
+%
+%    o exception: return any errors or warnings in this structure.
+%
+*/
+MagickExport MagickBooleanType SetImageMonochrome(Image *image,
+  ExceptionInfo *exception)
+{
+  CacheView
+    *image_view;
+
+  ImageType
+    type;
+
+  register ssize_t
+    x;
+
+  register const Quantum
+    *p;
+
+  ssize_t
+    y;
+
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
+  if (image->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+  if (image->type == BilevelType)
+    return(MagickTrue);
+  if ((IsGrayColorspace(image->colorspace) == MagickFalse) &&
+      (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse))
+    return(MagickFalse);
+  type=BilevelType;
+  image_view=AcquireVirtualCacheView(image,exception);
+  for (y=0; y < (ssize_t) image->rows; y++)
+  {
+    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
+    if (p == (const Quantum *) NULL)
+      break;
+    for (x=0; x < (ssize_t) image->columns; x++)
+    {
+      if (IsPixelMonochrome(image,p) == MagickFalse)
+        {
+          type=UndefinedType;
+          break;
+        }
+      p+=GetPixelChannels(image);
+    }
+    if (type == UndefinedType)
+      break;
+  }
+  image_view=DestroyCacheView(image_view);
+  if (type == UndefinedType)
+    return(MagickFalse);
+  image->colorspace=GRAYColorspace;
+  if (SyncImagePixelCache((Image *) image,exception) == MagickFalse)
+    return(MagickFalse);
+  image->type=type;
+  return(MagickTrue);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
 %   S e t I m a g e T y p e                                                   %
 %                                                                             %
 %                                                                             %
@@ -1146,10 +1216,10 @@ MagickExport MagickBooleanType SetImageType(Image *image,const ImageType type,
   {
     case BilevelType:
     {
-      if (IsImageGray(image,exception) == MagickFalse)
+      if (SetImageGray(image,exception) == MagickFalse)
         status=TransformImageColorspace(image,GRAYColorspace,exception);
       (void) NormalizeImage(image,exception);
-      if (IsImageMonochrome(image,exception) == MagickFalse)
+      if (SetImageMonochrome(image,exception) == MagickFalse)
         {
           quantize_info=AcquireQuantizeInfo(image_info);
           quantize_info->number_colors=2;
@@ -1163,14 +1233,14 @@ MagickExport MagickBooleanType SetImageType(Image *image,const ImageType type,
     }
     case GrayscaleType:
     {
-      if (IsImageGray(image,exception) == MagickFalse)
+      if (SetImageGray(image,exception) == MagickFalse)
         status=TransformImageColorspace(image,GRAYColorspace,exception);
       image->alpha_trait=UndefinedPixelTrait;
       break;
     }
     case GrayscaleAlphaType:
     {
-      if (IsImageGray(image,exception) == MagickFalse)
+      if (SetImageGray(image,exception) == MagickFalse)
         status=TransformImageColorspace(image,GRAYColorspace,exception);
       if (image->alpha_trait == UndefinedPixelTrait)
         (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);

diff --git a/MagickCore/attribute.h b/MagickCore/attribute.h
index 2bf33df1d5f3d6119c20bea39be09025d89c4b42..86d494d6b1af949730a07baba1a07719b4f4b556 100644 (file)
--- a/MagickCore/attribute.h
+++ b/MagickCore/attribute.h
@@ -29,10 +29,12 @@ extern MagickExport ImageType
   GetImageType(const Image *,ExceptionInfo *);
 
 extern MagickExport MagickBooleanType
-  IsImageGray(const Image *,ExceptionInfo *),
-  IsImageMonochrome(const Image *,ExceptionInfo *),
+  IsImageGray(const Image *),
+  IsImageMonochrome(const Image *),
   IsImageOpaque(const Image *,ExceptionInfo *),
   SetImageDepth(Image *,const size_t,ExceptionInfo *),
+  SetImageGray(Image *,ExceptionInfo *),
+  SetImageMonochrome(Image *,ExceptionInfo *),
   SetImageType(Image *,const ImageType,ExceptionInfo *);
 
 extern MagickExport RectangleInfo

diff --git a/MagickCore/enhance.c b/MagickCore/enhance.c
index 4eb173f958f68f3bf95f22cf55421af3320a19ff..85c38fcf25da28301ad00d1a83e225a0af91bd87 100644 (file)
--- a/MagickCore/enhance.c
+++ b/MagickCore/enhance.c
@@ -1042,7 +1042,7 @@ MagickExport MagickBooleanType ContrastStretchImage(Image *image,
   assert(image->signature == MagickSignature);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
-  if (IsImageGray(image,exception) != MagickFalse)
+  if (SetImageGray(image,exception) != MagickFalse)
     (void) SetImageColorspace(image,GRAYColorspace,exception);
   black=(double *) AcquireQuantumMemory(GetPixelChannels(image),sizeof(*black));
   white=(double *) AcquireQuantumMemory(GetPixelChannels(image),sizeof(*white));

diff --git a/MagickCore/fourier.c b/MagickCore/fourier.c
index e20da1fb9e6142a0e90c704702fef201719c3a54..c2cd48d26af147a460f0a50084874e6b4a9c6cb6 100644 (file)
--- a/MagickCore/fourier.c
+++ b/MagickCore/fourier.c
@@ -946,7 +946,7 @@ MagickExport Image *ForwardFourierTransformImage(const Image *image,
             AppendImageToList(&fourier_image,magnitude_image);
             AppendImageToList(&fourier_image,phase_image);
             status=MagickTrue;
-            is_gray=IsImageGray(image,exception);
+            is_gray=SetImageGray(image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
             #pragma omp parallel sections
 #endif
@@ -1511,9 +1511,9 @@ MagickExport Image *InverseFourierTransformImage(const Image *magnitude_image,
           status;
 
         status=MagickTrue;
-        is_gray=IsImageGray(magnitude_image,exception);
+        is_gray=SetImageGray(magnitude_image,exception);
         if (is_gray != MagickFalse)
-          is_gray=IsImageGray(phase_image,exception);
+          is_gray=SetImageGray(phase_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
         #pragma omp parallel sections
 #endif

diff --git a/MagickCore/identify.c b/MagickCore/identify.c
index 43422deb0ed448646d3e4b5ee6f883f9316fd748..8b114208451c7a7496d6af0ab1305e6dacc28389 100644 (file)
--- a/MagickCore/identify.c
+++ b/MagickCore/identify.c
@@ -514,7 +514,7 @@ MagickExport MagickBooleanType IdentifyImage(Image *image,FILE *file,
       if (channel_statistics == (ChannelStatistics *) NULL)
         return(MagickFalse);
       colorspace=image->colorspace;
-      if (IsImageGray(image,exception) != MagickFalse)
+      if (SetImageGray(image,exception) != MagickFalse)
         colorspace=GRAYColorspace;
       (void) FormatLocaleFile(file,"Channel %s locations:\n",locate);
       switch (colorspace)
@@ -724,7 +724,7 @@ MagickExport MagickBooleanType IdentifyImage(Image *image,FILE *file,
         (void) FormatLocaleFile(file,"  Depth: %.20g/%.20g-bit\n",(double)
           image->depth,(double) depth);
       (void) FormatLocaleFile(file,"  Channel depth:\n");
-      if (IsImageGray(image,exception) != MagickFalse)
+      if (SetImageGray(image,exception) != MagickFalse)
         colorspace=GRAYColorspace;
       switch (colorspace)
       {

diff --git a/MagickCore/methods.h b/MagickCore/methods.h
index 318f52b7e0146877fd5c460707ce57481769d1fc..db38132d5caacaf23d1175a8d6a80fd3c406aa58 100644 (file)
--- a/MagickCore/methods.h
+++ b/MagickCore/methods.h
@@ -1070,12 +1070,14 @@ extern "C" {
 #define SetImageColorspace  PrependMagickMethod(SetImageColorspace)
 #define SetImageDepth  PrependMagickMethod(SetImageDepth)
 #define SetImageExtent  PrependMagickMethod(SetImageExtent)
+#define SetImageGray  PrependMagickMethod(SetImageGray)
 #define SetImageInfoBlob  PrependMagickMethod(SetImageInfoBlob)
 #define SetImageInfoFile  PrependMagickMethod(SetImageInfoFile)
 #define SetImageInfo  PrependMagickMethod(SetImageInfo)
 #define SetImageInfoProgressMonitor  PrependMagickMethod(SetImageInfoProgressMonitor)
 #define SetImageList  PrependMagickMethod(SetImageList)
 #define SetImageMask  PrependMagickMethod(SetImageMask)
+#define SetImageMonochrome  PrependMagickMethod(SetImageMonochrome)
 #define SetImageOpacity  PrependMagickMethod(SetImageOpacity)
 #define SetImageOption  PrependMagickMethod(SetImageOption)
 #define SetImagePixels  PrependMagickMethod(SetImagePixels)

diff --git a/MagickCore/profile.c b/MagickCore/profile.c
index c5ee0f3d242586529912c54b05d66e3869c12927..c2c082482cb7b60025fdb956179247e508495851 100644 (file)
--- a/MagickCore/profile.c
+++ b/MagickCore/profile.c
@@ -1077,7 +1077,7 @@ MagickExport MagickBooleanType ProfileImage(Image *image,const char *name,
               ThrowProfileException(ImageError,"ColorspaceColorProfileMismatch",
                 name);
              if ((source_colorspace == GRAYColorspace) &&
-                 (IsImageGray(image,exception) == MagickFalse))
+                 (SetImageGray(image,exception) == MagickFalse))
               ThrowProfileException(ImageError,"ColorspaceColorProfileMismatch",
                 name);
              if ((source_colorspace == CMYKColorspace) &&

diff --git a/MagickCore/property.c b/MagickCore/property.c
index 3af05a0489796b69825c8ae660b8d84b4a677b9c..eb8ebc14bceca7986c950da06cda550725c4d172 100644 (file)
--- a/MagickCore/property.c
+++ b/MagickCore/property.c
@@ -2400,7 +2400,7 @@ static const char *GetMagickPropertyLetter(ImageInfo *image_info,
 
       WarnNoImageReturn("\"%%%c\"",letter);
       colorspace=image->colorspace;
-      if (IfMagickTrue(IsImageGray(image,exception)))
+      if (IfMagickTrue(SetImageGray(image,exception)))
         colorspace=GRAYColorspace;   /* FUTURE: this is IMv6 not IMv7 */
       (void) FormatLocaleString(value,MaxTextExtent,"%s %s %s",
         CommandOptionToMnemonic(MagickClassOptions,(ssize_t) image->storage_class),

diff --git a/MagickCore/quantize.c b/MagickCore/quantize.c
index 14d548099785f9263a0c2330029b26eeb3a64e2c..772ef9b322cfb42d3a89b8e56cf4923636f8375a 100644 (file)
--- a/MagickCore/quantize.c
+++ b/MagickCore/quantize.c
@@ -2732,7 +2732,7 @@ MagickExport MagickBooleanType QuantizeImage(const QuantizeInfo *quantize_info,
     {
       if ((image->columns*image->rows) <= maximum_colors)
         (void) DirectToColormapImage(image,exception);
-      if (IsImageGray(image,exception) != MagickFalse)
+      if (SetImageGray(image,exception) != MagickFalse)
         (void) SetGrayscaleImage(image,exception);
     }
   if ((image->storage_class == PseudoClass) &&
@@ -2760,7 +2760,7 @@ MagickExport MagickBooleanType QuantizeImage(const QuantizeInfo *quantize_info,
         depth--;
       if ((image->alpha_trait == BlendPixelTrait) && (depth > 5))
         depth--;
-      if (IsImageGray(image,exception) != MagickFalse)
+      if (SetImageGray(image,exception) != MagickFalse)
         depth=MaxTreeDepth;
     }
   /*
@@ -3510,7 +3510,7 @@ static MagickBooleanType SetGrayscaleImage(Image *image,
   image_view=DestroyCacheView(image_view);
   colormap_index=(ssize_t *) RelinquishMagickMemory(colormap_index);
   image->type=GrayscaleType;
-  if (IsImageMonochrome(image,exception) != MagickFalse)
+  if (SetImageMonochrome(image,exception) != MagickFalse)
     image->type=BilevelType;
   return(status);
 }

diff --git a/coders/cut.c b/coders/cut.c
index 78dd94eb0e3b70bd7a3ccfb033152b9896b978a0..85b00226bf54d07efd1c465049c7dc8970376edd 100644 (file)
--- a/coders/cut.c
+++ b/coders/cut.c
@@ -562,7 +562,7 @@ static Image *ReadCUTImage(const ImageInfo *image_info,ExceptionInfo *exception)
   if(palette==NULL)
     {    /*attempt to detect binary (black&white) images*/
       if ((image->storage_class == PseudoClass) &&
-          (IsImageGray(image,exception) != MagickFalse))
+          (SetImageGray(image,exception) != MagickFalse))
         {
           if(GetCutColors(image,exception)==2)
             {

diff --git a/coders/dcm.c b/coders/dcm.c
index 1f11d1596cce2aafc4d442f7c3a2b6d0e4eab42a..a6b67d09c683119e15664c8859711916cd746de2 100644 (file)
--- a/coders/dcm.c
+++ b/coders/dcm.c
@@ -4055,7 +4055,7 @@ static Image *ReadDCMImage(const ImageInfo *image_info,ExceptionInfo *exception)
               }
           }
       }
-    if (IsImageGray(image,exception) != MagickFalse)
+    if (SetImageGray(image,exception) != MagickFalse)
       (void) SetImageColorspace(image,GRAYColorspace,exception);
     if (EOFBlob(image) != MagickFalse)
       {

diff --git a/coders/dib.c b/coders/dib.c
index 5ab95f382626f1c2b07b416b0ac01659a47b3251..b324f20e36121d749dc4eca5f0ab320b2f8f6c54 100644 (file)
--- a/coders/dib.c
+++ b/coders/dib.c
@@ -1059,7 +1059,7 @@ static MagickBooleanType WriteDIBImage(const ImageInfo *image_info,Image *image,
       dib_info.bits_per_pixel=8;
       if (image_info->depth > 8)
         dib_info.bits_per_pixel=16;
-      if (IsImageMonochrome(image,exception) != MagickFalse)
+      if (SetImageMonochrome(image,exception) != MagickFalse)
         dib_info.bits_per_pixel=1;
       dib_info.number_colors=(dib_info.bits_per_pixel == 16) ? 0 :
         (1UL << dib_info.bits_per_pixel);

diff --git a/coders/dpx.c b/coders/dpx.c
index df692fe8e078e88549ed48d3952c0d5c87049ab8..c1b1d34272498ebd5b0442ed6b1a4e3671eef103 100644 (file)
--- a/coders/dpx.c
+++ b/coders/dpx.c
@@ -1638,7 +1638,7 @@ static MagickBooleanType WriteDPXImage(const ImageInfo *image_info,Image *image,
             dpx.image.image_element[i].descriptor=RGBAComponentType;
           if ((image_info->type != TrueColorType) &&
               (image->alpha_trait == UndefinedPixelTrait) &&
-              (IsImageGray(image,exception) != MagickFalse))
+              (SetImageGray(image,exception) != MagickFalse))
             dpx.image.image_element[i].descriptor=LumaComponentType;
           break;
         }
@@ -1972,7 +1972,7 @@ static MagickBooleanType WriteDPXImage(const ImageInfo *image_info,Image *image,
     dpx.image.image_element[0].packing == 0 ? MagickFalse : MagickTrue);
   if ((image_info->type != TrueColorType) &&
       (image->alpha_trait == UndefinedPixelTrait) &&
-      (IsImageGray(image,exception) != MagickFalse))
+      (SetImageGray(image,exception) != MagickFalse))
     {
       quantum_type=GrayQuantum;
       extent=GetBytesPerRow(image->columns,1UL,image->depth,

diff --git a/coders/fits.c b/coders/fits.c
index c6157a2b048250147aa67f6f2e1ae5a25888c8ad..254cb51f233f18c6b5354280dbc75beebc9142b3 100644 (file)
--- a/coders/fits.c
+++ b/coders/fits.c
@@ -679,7 +679,7 @@ static MagickBooleanType WriteFITSImage(const ImageInfo *image_info,
   (void) strncpy(fits_info+offset,header,strlen(header));
   offset+=80;
   (void) FormatLocaleString(header,FITSBlocksize,"NAXIS   =           %10lu",
-    IsImageGray(image,exception) != MagickFalse ? 2UL : 3UL);
+    SetImageGray(image,exception) != MagickFalse ? 2UL : 3UL);
   (void) strncpy(fits_info+offset,header,strlen(header));
   offset+=80;
   (void) FormatLocaleString(header,FITSBlocksize,"NAXIS1  =           %10lu",
@@ -690,7 +690,7 @@ static MagickBooleanType WriteFITSImage(const ImageInfo *image_info,
     (unsigned long) image->rows);
   (void) strncpy(fits_info+offset,header,strlen(header));
   offset+=80;
-  if (IsImageGray(image,exception) == MagickFalse)
+  if (SetImageGray(image,exception) == MagickFalse)
     {
       (void) FormatLocaleString(header,FITSBlocksize,
         "NAXIS3  =           %10lu",3UL);
@@ -729,7 +729,7 @@ static MagickBooleanType WriteFITSImage(const ImageInfo *image_info,
     Convert image to fits scale PseudoColor class.
   */
   pixels=GetQuantumPixels(quantum_info);
-  if (IsImageGray(image,exception) != MagickFalse)
+  if (SetImageGray(image,exception) != MagickFalse)
     {
       length=GetQuantumExtent(image,quantum_info,GrayQuantum);
       for (y=(ssize_t) image->rows-1; y >= 0; y--)

diff --git a/coders/fpx.c b/coders/fpx.c
index 571b1ad3243625b07734abe1f0b8d9a506620bfc..2db31f20a1fe49d13ab5187def34ffac841ca9f5 100644 (file)
--- a/coders/fpx.c
+++ b/coders/fpx.c
@@ -837,7 +837,7 @@ static MagickBooleanType WriteFPXImage(const ImageInfo *image_info,Image *image,
   if (image->alpha_trait != UndefinedPixelTrait)
     colorspace.numberOfComponents=4;
   if ((image_info->type != TrueColorType) &&
-      (IsImageGray(image,exception) != MagickFalse))
+      (SetImageGray(image,exception) != MagickFalse))
     {
       colorspace.numberOfComponents=1;
       colorspace.theComponents[0].myColor=MONOCHROME;

diff --git a/coders/jpeg.c b/coders/jpeg.c
index 46823ca218f53271b79259c9f2d1bdf4b61d631e..ea86abd2fffb5dad015b835e7330c10a2615c5e9 100644 (file)
--- a/coders/jpeg.c
+++ b/coders/jpeg.c
@@ -2231,7 +2231,7 @@ static MagickBooleanType WriteJPEGImage(const ImageInfo *image_info,
       (void) TransformImageColorspace(image,sRGBColorspace,exception);
       if (image_info->type == TrueColorType)
         break;
-      if (IsImageGray(image,exception) != MagickFalse)
+      if (SetImageGray(image,exception) != MagickFalse)
         {
           jpeg_info.input_components=1;
           jpeg_info.in_color_space=JCS_GRAYSCALE;

diff --git a/coders/json.c b/coders/json.c
index d81a7d170a51be7a04fb75c58f1d465f217a907f..37b919da9bfea335971f818a02e074a49ea6dd0a 100644 (file)
--- a/coders/json.c
+++ b/coders/json.c
@@ -618,7 +618,7 @@ static MagickBooleanType EncodeImageAttributes(Image *image,FILE *file,
       if (channel_statistics == (ChannelStatistics *) NULL)
         return(MagickFalse);
       colorspace=image->colorspace;
-      if (IsImageGray(image,exception) != MagickFalse)
+      if (SetImageGray(image,exception) != MagickFalse)
         colorspace=GRAYColorspace;
       (void) FormatLocaleFile(file,"Channel %s locations:\n",locate);
       switch (colorspace)
@@ -702,7 +702,7 @@ static MagickBooleanType EncodeImageAttributes(Image *image,FILE *file,
         (void) FormatLocaleFile(file,"  Depth: %.20g/%.20g-bit\n",(double)
           image->depth,(double) depth);
       (void) FormatLocaleFile(file,"  Channel depth:\n");
-      if (IsImageGray(image,exception) != MagickFalse)
+      if (SetImageGray(image,exception) != MagickFalse)
         colorspace=GRAYColorspace;
       switch (colorspace)
       {

diff --git a/coders/mat.c b/coders/mat.c
index cd58d730ab03575d2ca8e7a217aecbf06b4291dd..913c82716b848719db6ac40b959dc27ef12ad786 100644 (file)
--- a/coders/mat.c
+++ b/coders/mat.c
@@ -1232,7 +1232,7 @@ static MagickBooleanType WriteMATImage(const ImageInfo *image_info,Image *image,
   do
   {
     (void) TransformImageColorspace(image,sRGBColorspace,exception);
-    is_gray = IsImageGray(image,exception);
+    is_gray = SetImageGray(image,exception);
     z = is_gray ? 0 : 3;
 
     /*

diff --git a/coders/pcl.c b/coders/pcl.c
index 3a92922d76968456fdcb72e61b84851abbcb0875..07bfe80bdf149874058c60728cd7952780c53d82 100644 (file)
--- a/coders/pcl.c
+++ b/coders/pcl.c
@@ -738,7 +738,7 @@ static MagickBooleanType WritePCLImage(const ImageInfo *image_info,Image *image,
       density);
     (void) WriteBlobString(image,buffer);
     (void) WriteBlobString(image,"\033&l0E");  /* top margin 0 */
-    if (IsImageMonochrome(image,exception) != MagickFalse)
+    if (SetImageMonochrome(image,exception) != MagickFalse)
       {
         /*
           Monochrome image: use default printer monochrome setup.

diff --git a/coders/pcx.c b/coders/pcx.c
index 617694a57f1cec1ef2d685c6ba7fa44f15ffb3ae..8505d50c3082de583f5ea2d8f1856c5e96d43efe 100644 (file)
--- a/coders/pcx.c
+++ b/coders/pcx.c
@@ -919,7 +919,7 @@ static MagickBooleanType WritePCXImage(const ImageInfo *image_info,Image *image,
     pcx_info.encoding=image_info->compression == NoCompression ? 0 : 1;
     pcx_info.bits_per_pixel=8;
     if ((image->storage_class == PseudoClass) &&
-        (IsImageMonochrome(image,exception) != MagickFalse))
+        (SetImageMonochrome(image,exception) != MagickFalse))
       pcx_info.bits_per_pixel=1;
     pcx_info.left=0;
     pcx_info.top=0;

diff --git a/coders/pdf.c b/coders/pdf.c
index 4f3eb8ff6654f4547bab5dbf0d2f41098bcc8b0b..5a0dae0e993ec40e92ae575cb5768058a2ecccc4 100644 (file)
--- a/coders/pdf.c
+++ b/coders/pdf.c
@@ -1324,7 +1324,7 @@ RestoreMSCWarning
       case FaxCompression:
       case Group4Compression:
       {
-        if ((IsImageMonochrome(image,exception) == MagickFalse) ||
+        if ((SetImageMonochrome(image,exception) == MagickFalse) ||
             (image->alpha_trait != UndefinedPixelTrait))
           compression=RLECompression;
         break;
@@ -1675,7 +1675,7 @@ RestoreMSCWarning
       ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
     if ((compression == FaxCompression) || (compression == Group4Compression) ||
         ((image_info->type != TrueColorType) &&
-         (IsImageGray(image,exception) != MagickFalse)))
+         (SetImageGray(image,exception) != MagickFalse)))
       {
         switch (compression)
         {
@@ -2026,7 +2026,7 @@ RestoreMSCWarning
       if ((compression == FaxCompression) ||
           (compression == Group4Compression) ||
           ((image_info->type != TrueColorType) &&
-           (IsImageGray(image,exception) != MagickFalse)))
+           (SetImageGray(image,exception) != MagickFalse)))
           (void) CopyMagickString(buffer,"/DeviceGray\n",MaxTextExtent);
       else
         if ((image->storage_class == DirectClass) || (image->colors > 256) ||
@@ -2132,7 +2132,7 @@ RestoreMSCWarning
     if ((compression == FaxCompression) ||
         (compression == Group4Compression) ||
         ((image_info->type != TrueColorType) &&
-         (IsImageGray(tile_image,exception) != MagickFalse)))
+         (SetImageGray(tile_image,exception) != MagickFalse)))
       {
         switch (compression)
         {

diff --git a/coders/png.c b/coders/png.c
index 05b6fd44510b6c35d04bfc18c01ed3defe35857f..701f915472d914c18b9b1567d16cf504799bbc32 100644 (file)
--- a/coders/png.c
+++ b/coders/png.c
@@ -12244,7 +12244,7 @@ static MagickBooleanType WriteOneJNGImage(MngInfo *mng_info,
 
   /* Check if image is grayscale. */
   if (image_info->type != TrueColorAlphaType && image_info->type !=
-    TrueColorType && IsImageGray(image,exception))
+    TrueColorType && SetImageGray(image,exception))
     jng_color_type-=2;
 
   if (logging != MagickFalse)
@@ -13030,7 +13030,7 @@ static MagickBooleanType WriteMNGImage(const ImageInfo *image_info,Image *image,
 
         if (need_local_plte == 0)
           {
-            if (IsImageGray(image,exception) == MagickFalse)
+            if (SetImageGray(image,exception) == MagickFalse)
               all_images_are_gray=MagickFalse;
             mng_info->equal_palettes=PalettesAreEqual(image,next_image);
             if (use_global_plte == 0)

diff --git a/coders/pnm.c b/coders/pnm.c
index a0e1e6af1c87ed26b7fa831f02f5809eacd9780d..6a2a6f1da34245387e2d2bb476e32c74f1504e2e 100644 (file)
--- a/coders/pnm.c
+++ b/coders/pnm.c
@@ -1598,7 +1598,7 @@ static MagickBooleanType WritePNMImage(const ImageInfo *image_info,Image *image,
       case 'f':
       {
         format='F';
-        if (IsImageGray(image,exception) != MagickFalse)
+        if (SetImageGray(image,exception) != MagickFalse)
           format='f';
         break;
       }
@@ -1614,12 +1614,12 @@ static MagickBooleanType WritePNMImage(const ImageInfo *image_info,Image *image,
       case 'n':
       {
         if ((image_info->type != TrueColorType) &&
-            (IsImageGray(image,exception) != MagickFalse))
+            (SetImageGray(image,exception) != MagickFalse))
           {
             format='5';
             if (image_info->compression == NoCompression)
               format='2';
-            if (IsImageMonochrome(image,exception) != MagickFalse)
+            if (SetImageMonochrome(image,exception) != MagickFalse)
               {
                 format='4';
                 if (image_info->compression == NoCompression)

diff --git a/coders/ps.c b/coders/ps.c
index adddfbdc56837a0194484d660487b034e52c5752..0e605e742e4e23acbb171f937b95174ba610a0c8 100644 (file)
--- a/coders/ps.c
+++ b/coders/ps.c
@@ -1887,9 +1887,9 @@ RestoreMSCWarning
     index=0;
     x=0;
     if ((image_info->type != TrueColorType) &&
-        (IsImageGray(image,exception) != MagickFalse))
+        (SetImageGray(image,exception) != MagickFalse))
       {
-        if (IsImageMonochrome(image,exception) == MagickFalse)
+        if (SetImageMonochrome(image,exception) == MagickFalse)
           {
             Quantum
               pixel;

diff --git a/coders/ps2.c b/coders/ps2.c
index 7052f14aad40726e8d0fcd8a568156b9ab6ab1b6..908e321ae7a04feea5eb03e818336c202160ac51 100644 (file)
--- a/coders/ps2.c
+++ b/coders/ps2.c
@@ -733,7 +733,7 @@ static MagickBooleanType WritePS2Image(const ImageInfo *image_info,Image *image,
       ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
     if ((compression == FaxCompression) || (compression == Group4Compression) ||
         ((image_info->type != TrueColorType) &&
-         (IsImageGray(image,exception) != MagickFalse)))
+         (SetImageGray(image,exception) != MagickFalse)))
       {
         (void) FormatLocaleString(buffer,MaxTextExtent,"%.20g %.20g\n1\n%d\n",
           (double) image->columns,(double) image->rows,(int)

diff --git a/coders/ps3.c b/coders/ps3.c
index 687ebf347087401ae98fba1467ca5887b40d2a6f..58c81aebb8171c3f2e0507230fb06db67dcf46ec 100644 (file)
--- a/coders/ps3.c
+++ b/coders/ps3.c
@@ -334,7 +334,7 @@ static MagickBooleanType SerializeImageChannel(const ImageInfo *image_info,
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   status=MagickTrue;
-  pack=IsImageMonochrome(image,exception) == MagickFalse ? 1UL : 8UL;
+  pack=SetImageMonochrome(image,exception) == MagickFalse ? 1UL : 8UL;
   padded_columns=((image->columns+pack-1)/pack)*pack;
   *length=(size_t) padded_columns*image->rows/pack;
   *pixel_info=AcquireVirtualMemory(*length,sizeof(*q));
@@ -899,7 +899,7 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,
     case FaxCompression:
     case Group4Compression:
     { 
-      if ((IsImageMonochrome(image,exception) == MagickFalse) ||
+      if ((SetImageMonochrome(image,exception) == MagickFalse) ||
           (image->alpha_trait != UndefinedPixelTrait))
         compression=RLECompression;
       break;
@@ -1042,7 +1042,7 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,
               (void) WriteBlobString(image,
                 "%%DocumentProcessColors: Cyan Magenta Yellow Black\n");
             else
-              if (IsImageGray(image,exception) != MagickFalse)
+              if (SetImageGray(image,exception) != MagickFalse)
                 (void) WriteBlobString(image,
                   "%%DocumentProcessColors: Black\n");
           }
@@ -1128,7 +1128,7 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,
       (void) WriteBlobString(image,
         "%%PageProcessColors: Cyan Magenta Yellow Black\n");
     else
-      if (IsImageGray(image,exception) != MagickFalse)
+      if (SetImageGray(image,exception) != MagickFalse)
         (void) WriteBlobString(image,"%%PageProcessColors: Black\n");
     /*
       Adjust document bounding box to bound page bounding box.
@@ -1257,7 +1257,7 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,
     */
     option=GetImageOption(image_info,"ps3:imagemask");
     (void) WriteBlobString(image,((option != (const char *) NULL) &&
-      (IsImageMonochrome(image,exception) != MagickFalse)) ?
+      (SetImageMonochrome(image,exception) != MagickFalse)) ?
       "true\n" : "false\n");
     /*
       Output pixel data.
@@ -1269,8 +1269,8 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,
         (image_info->type != ColorSeparationType) &&
         (image_info->type != ColorSeparationAlphaType) &&
         (image->colorspace != CMYKColorspace) &&
-        ((IsImageGray(image,exception) != MagickFalse) ||
-         (IsImageMonochrome(image,exception) != MagickFalse)))
+        ((SetImageGray(image,exception) != MagickFalse) ||
+         (SetImageMonochrome(image,exception) != MagickFalse)))
       {
         /*
           Gray images.
@@ -1319,7 +1319,7 @@ static MagickBooleanType WritePS3Image(const ImageInfo *image_info,Image *image,
           1 bit or 8 bit components?
         */
         (void) FormatLocaleString(buffer,MaxTextExtent,"%d\n",
-          IsImageMonochrome(image,exception) != MagickFalse ? 1 : 8);
+          SetImageMonochrome(image,exception) != MagickFalse ? 1 : 8);
         (void) WriteBlobString(image,buffer);
         /*
           Image data.

diff --git a/coders/psd.c b/coders/psd.c
index 6a56d1fd75d645ed06b8442b16d52f52e7252728..e0a52b2d7e6d55db4ceb628afe4998d0637b7373 100644 (file)
--- a/coders/psd.c
+++ b/coders/psd.c
@@ -2152,7 +2152,7 @@ static void WriteOneChannel(const PSDInfo *psd_info,const ImageInfo *image_info,
     (void) WriteBlobMSBShort(image,0);
   if (next_image->depth > 8)
     next_image->depth=16;
-  monochrome=IsImageMonochrome(image,exception) && (image->depth == 1) ?
+  monochrome=SetImageMonochrome(image,exception) && (image->depth == 1) ?
     MagickTrue : MagickFalse;
   packet_size=next_image->depth > 8UL ? 2UL : 1UL;
   (void) packet_size;
@@ -2204,7 +2204,7 @@ static MagickBooleanType WriteImageChannels(const PSDInfo *psd_info,
       if (compact_pixels == (unsigned char *) NULL)
         ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
     }
-  if (IsImageGray(next_image,exception) != MagickFalse)
+  if (SetImageGray(next_image,exception) != MagickFalse)
     {
       if (next_image->compression == RLECompression)
         {
@@ -2511,7 +2511,7 @@ static MagickBooleanType WritePSDImage(const ImageInfo *image_info,Image *image,
   (void) WriteBlobMSBShort(image,psd_info.version);  /* version */
   for (i=1; i <= 6; i++)
     (void) WriteBlobByte(image, 0);  /* 6 bytes of reserved */
-  if (IsImageGray(image,exception) != MagickFalse)
+  if (SetImageGray(image,exception) != MagickFalse)
     num_channels=(image->alpha_trait != UndefinedPixelTrait ? 2UL : 1UL);
   else
     if (image->storage_class == PseudoClass)
@@ -2526,7 +2526,7 @@ static MagickBooleanType WritePSDImage(const ImageInfo *image_info,Image *image,
   (void) WriteBlobMSBShort(image,(unsigned short) num_channels);
   (void) WriteBlobMSBLong(image,(unsigned int) image->rows);
   (void) WriteBlobMSBLong(image,(unsigned int) image->columns);
-  if (IsImageGray(image,exception) != MagickFalse)
+  if (SetImageGray(image,exception) != MagickFalse)
     {
       MagickBooleanType
         monochrome;
@@ -2534,7 +2534,7 @@ static MagickBooleanType WritePSDImage(const ImageInfo *image_info,Image *image,
       /*
         Write depth & mode.
       */
-      monochrome=IsImageMonochrome(image,exception) && (image->depth == 1) ?
+      monochrome=SetImageMonochrome(image,exception) && (image->depth == 1) ?
         MagickTrue : MagickFalse;
       (void) WriteBlobMSBShort(image,(unsigned short)
         (monochrome != MagickFalse ? 1 : image->depth > 8 ? 16 : 8));
@@ -2561,7 +2561,7 @@ static MagickBooleanType WritePSDImage(const ImageInfo *image_info,Image *image,
           (void) WriteBlobMSBShort(image,CMYKMode);
         }
     }
-  if ((IsImageGray(image,exception) != MagickFalse) ||
+  if ((SetImageGray(image,exception) != MagickFalse) ||
       (image->storage_class == DirectClass) || (image->colors > 256))
     (void) WriteBlobMSBLong(image,0);
   else
@@ -2630,7 +2630,7 @@ static MagickBooleanType WritePSDImage(const ImageInfo *image_info,Image *image,
   while ( next_image != NULL )
   {
     packet_size=next_image->depth > 8 ? 2UL : 1UL;
-    if (IsImageGray(next_image,exception) != MagickFalse)
+    if (SetImageGray(next_image,exception) != MagickFalse)
       num_channels=next_image->alpha_trait != UndefinedPixelTrait ? 2UL : 1UL;
     else
       if (next_image->storage_class == PseudoClass)
@@ -2689,7 +2689,7 @@ static MagickBooleanType WritePSDImage(const ImageInfo *image_info,Image *image,
         packet_size=next_image->depth > 8 ? 2UL : 1UL;
         channel_size=(unsigned int) ((packet_size*next_image->rows*
           next_image->columns)+2);
-        if ((IsImageGray(next_image,exception) != MagickFalse) ||
+        if ((SetImageGray(next_image,exception) != MagickFalse) ||
             (next_image->storage_class == PseudoClass))
           {
              (void) WriteBlobMSBShort(image,(unsigned short)

diff --git a/coders/sgi.c b/coders/sgi.c
index 0991b19834c6f93c1e1b03cd5d38890123de0730..0be78b15053828cb2a54ec22f8b2c60b440680d4 100644 (file)
--- a/coders/sgi.c
+++ b/coders/sgi.c
@@ -944,7 +944,7 @@ static MagickBooleanType WriteSGIImage(const ImageInfo *image_info,Image *image,
     else
       {
         if ((image_info->type != TrueColorType) &&
-            (IsImageGray(image,exception) != MagickFalse))
+            (SetImageGray(image,exception) != MagickFalse))
           {
             iris_info.dimension=2;
             iris_info.depth=1;

diff --git a/coders/sun.c b/coders/sun.c
index f77d5b9b0c696e36ab0b53c09258bd2d1c5b08ad..8d605da05422674580ff7689041844d877350202 100644 (file)
--- a/coders/sun.c
+++ b/coders/sun.c
@@ -793,7 +793,7 @@ static MagickBooleanType WriteSUNImage(const ImageInfo *image_info,Image *image,
           0;
       }
     else
-      if (IsImageMonochrome(image,exception) != MagickFalse)
+      if (SetImageMonochrome(image,exception) != MagickFalse)
         {
           /*
             Monochrome SUN raster.
@@ -886,7 +886,7 @@ static MagickBooleanType WriteSUNImage(const ImageInfo *image_info,Image *image,
         pixels=(unsigned char *) RelinquishMagickMemory(pixels);
       }
     else
-      if (IsImageMonochrome(image,exception) != MagickFalse)
+      if (SetImageMonochrome(image,exception) != MagickFalse)
         {
           register unsigned char
             bit,

diff --git a/coders/tga.c b/coders/tga.c
index dc27bc581afe844dd6ad52588f250edca0e1da1a..b09638dca3c30eceda95cc085eeee1ec0165c0ac 100644 (file)
--- a/coders/tga.c
+++ b/coders/tga.c
@@ -776,7 +776,7 @@ static MagickBooleanType WriteTGAImage(const ImageInfo *image_info,Image *image,
       (image_info->type != TrueColorAlphaType) &&
       (image_info->type != PaletteType) &&
       (image->alpha_trait == UndefinedPixelTrait) &&
-      (IsImageGray(image,exception) != MagickFalse))
+      (SetImageGray(image,exception) != MagickFalse))
     tga_info.image_type=compression == RLECompression ? TGARLEMonochrome :
       TGAMonochrome;
   else

diff --git a/coders/tiff.c b/coders/tiff.c
index 43ea0a87dac05795ef13d43460ac697c021a7859..d502f564a8de25d6b681bcec5a7ee7cd31bb154e 100644 (file)
--- a/coders/tiff.c
+++ b/coders/tiff.c
@@ -3219,7 +3219,7 @@ static MagickBooleanType WriteTIFFImage(const ImageInfo *image_info,
             (image_info->type != TrueColorAlphaType))
           {
             if ((image_info->type != PaletteType) &&
-                (IsImageGray(image,exception) != MagickFalse))
+                (SetImageGray(image,exception) != MagickFalse))
               {
                 photometric=(uint16) (quantum_info->min_is_white !=
                   MagickFalse ? PHOTOMETRIC_MINISWHITE :
@@ -3227,7 +3227,7 @@ static MagickBooleanType WriteTIFFImage(const ImageInfo *image_info,
                 (void) TIFFSetField(tiff,TIFFTAG_SAMPLESPERPIXEL,1);
                 if ((image_info->depth == 0) &&
                     (image->alpha_trait == UndefinedPixelTrait) &&
-                    (IsImageMonochrome(image,exception) != MagickFalse))
+                    (SetImageMonochrome(image,exception) != MagickFalse))
                   {
                     status=SetQuantumDepth(image,quantum_info,1);
                     if (status == MagickFalse)

diff --git a/coders/viff.c b/coders/viff.c
index 923155c27162cbf7b78be16790c4d33a75070ee4..f950bdeb1eff11eb2895ffa11059a4d5e4dd503b 100644 (file)
--- a/coders/viff.c
+++ b/coders/viff.c
@@ -1011,7 +1011,7 @@ RestoreMSCWarning
         viff_info.color_space_model=VFF_CM_NONE;
         viff_info.data_storage_type=VFF_TYP_1_BYTE;
         packets=number_pixels;
-        if (IsImageGray(image,exception) == MagickFalse)
+        if (SetImageGray(image,exception) == MagickFalse)
           {
             /*
               Colormapped VIFF raster.
@@ -1112,7 +1112,7 @@ RestoreMSCWarning
         }
       }
     else
-      if (IsImageGray(image,exception) == MagickFalse)
+      if (SetImageGray(image,exception) == MagickFalse)
         {
           unsigned char
             *viff_colormap;

diff --git a/coders/vips.c b/coders/vips.c
index ab18bf5669ead4ed1597a8bdd4b64a99477fb48f..39d4dda988a1314cfe06be2d705f63ecdac2dac6 100644 (file)
--- a/coders/vips.c
+++ b/coders/vips.c
@@ -652,7 +652,7 @@ static MagickBooleanType WriteVIPSImage(const ImageInfo *image_info,
   (void) WriteBlobLong(image,(unsigned int) image->rows);
   (void) SetImageStorageClass(image,DirectClass,exception);
   channels=image->alpha_trait != UndefinedPixelTrait ? 4 : 3;
-  if (IsImageGray(image,exception) != MagickFalse)
+  if (SetImageGray(image,exception) != MagickFalse)
     channels=image->alpha_trait != UndefinedPixelTrait ? 2 : 1;
   else if (image->colorspace == CMYKColorspace)
     channels=image->alpha_trait != UndefinedPixelTrait ? 5 : 4;

diff --git a/coders/xpm.c b/coders/xpm.c
index ba5cc5cb23e059f8deca2d1f3f0c1cbad428b724..6d8229e19d2e238e3718db7723027d0b1d0f24dc 100644 (file)
--- a/coders/xpm.c
+++ b/coders/xpm.c
@@ -686,7 +686,7 @@ static MagickBooleanType WritePICONImage(const ImageInfo *image_info,
   blob_info=CloneImageInfo(image_info);
   (void) AcquireUniqueFilename(blob_info->filename);
   if ((image_info->type != TrueColorType) &&
-      (IsImageGray(image,exception) != MagickFalse))
+      (SetImageGray(image,exception) != MagickFalse))
     affinity_image=BlobToImage(blob_info,Graymap,GraymapExtent,exception);
   else
     affinity_image=BlobToImage(blob_info,Colormap,ColormapExtent,exception);