diff --git a/Magick++/lib/Image.cpp b/Magick++/lib/Image.cpp
index a1f269e05f..28bf6f0835 100644
--- a/Magick++/lib/Image.cpp
+++ b/Magick++/lib/Image.cpp
@@ -1609,10 +1609,7 @@ Magick::ImageType Magick::Image::type(void) const
 {
   if (constOptions()->type() != UndefinedType)
     return(constOptions()->type());
-  else if (constImage()->type != UndefinedType)
-    return(constImage()->type);
-  else
-    return(determineType());
+  return(GetImageType(constImage()));
 }
 
 void Magick::Image::type(const Magick::ImageType type_)
@@ -2692,17 +2689,6 @@ void Magick::Image::despeckle(void)
   ThrowImageException;
 }
 
-Magick::ImageType Magick::Image::determineType(void) const
-{
-  ImageType
-    image_type;
-
-  GetPPException;
-  image_type=GetImageType(constImage(),exceptionInfo);
-  ThrowImageException;
-  return(image_type);
-}
-
 void Magick::Image::display(void)
 {
   GetPPException;
@@ -3234,6 +3220,17 @@ void Magick::Image::houghLine(const size_t width_,const size_t height_,
   ThrowImageException;
 }
 
+Magick::ImageType Magick::Image::identifyType(void) const
+{
+  ImageType
+    image_type;
+
+  GetPPException;
+  image_type=IdentifyImageType(constImage(),exceptionInfo);
+  ThrowImageException;
+  return(image_type);
+}
+
 void Magick::Image::implode(const double factor_)
 {
   MagickCore::Image
diff --git a/Magick++/lib/Magick++/Image.h b/Magick++/lib/Magick++/Image.h
index 3bd5a5fbb3..b59fd09904 100644
--- a/Magick++/lib/Magick++/Image.h
+++ b/Magick++/lib/Magick++/Image.h
@@ -821,10 +821,6 @@ namespace Magick
     // Despeckle image (reduce speckle noise)
     void despeckle(void);
 
-    // Determines the color type of the image. This method can be used to
-    // automaticly make the type GrayScale.
-    ImageType determineType(void) const;
-
     // Display image on screen
     void display(void);
 
@@ -978,6 +974,10 @@ namespace Magick
     void houghLine(const size_t width_,const size_t height_,
       const size_t threshold_=40);
 
+    // Identifies the potential color type of the image. This method can be
+    // used to detect if the type can be changed to GrayScale.
+    ImageType identifyType(void) const;
+
     // Implode image (special effect)
     void implode(const double factor_);
 
diff --git a/MagickCore/attribute.c b/MagickCore/attribute.c
index fcb64f75f7..9e22c38ae0 100644
--- a/MagickCore/attribute.c
+++ b/MagickCore/attribute.c
@@ -568,19 +568,68 @@ MagickExport size_t GetImageQuantumDepth(const Image *image,
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  GetImageType() returns the potential type of image:
+%  GetImageType() returns the type of image:
 %
 %        Bilevel         Grayscale        GrayscaleMatte
 %        Palette         PaletteMatte     TrueColor
 %        TrueColorMatte  ColorSeparation  ColorSeparationMatte
 %
-%  To ensure the image type matches its potential, use SetImageType():
-%
-%    (void) SetImageType(image,GetImageType(image));
-%
 %  The format of the GetImageType method is:
 %
-%      ImageType GetImageType(const Image *image,ExceptionInfo *exception)
+%      ImageType GetImageType(const Image *image)
+%
+%  A description of each parameter follows:
+%
+%    o image: the image.
+%
+*/
+MagickExport ImageType GetImageType(const Image *image)
+{
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickCoreSignature);
+  if (image->colorspace == CMYKColorspace)
+    {
+      if (image->alpha_trait == UndefinedPixelTrait)
+        return(ColorSeparationType);
+      return(ColorSeparationAlphaType);
+    }
+  if (IsImageMonochrome(image) != MagickFalse)
+    return(BilevelType);
+  if (IsImageGray(image) != MagickFalse)
+    {
+      if (image->alpha_trait != UndefinedPixelTrait)
+        return(GrayscaleAlphaType);
+      return(GrayscaleType);
+    }
+  if (IsPaletteImage(image) != MagickFalse)
+    {
+      if (image->alpha_trait != UndefinedPixelTrait)
+        return(PaletteAlphaType);
+      return(PaletteType);
+    }
+  if (image->alpha_trait != UndefinedPixelTrait)
+    return(TrueColorAlphaType);
+  return(TrueColorType);
+}
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%     I d e n t i f y I m a g e G r a y                                       %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  IdentifyImageGray() returns grayscale if all the pixels in the image have
+%  the same red, green, and blue intensities, and bi-level is the intensity is
+%  either 0 or QuantumRange. Otherwise undefined is returned.
+%
+%  The format of the IdentifyImageGray method is:
+%
+%      ImageType IdentifyImageGray(const Image *image,ExceptionInfo *exception)
 %
 %  A description of each parameter follows:
 %
@@ -589,7 +638,173 @@ MagickExport size_t GetImageQuantumDepth(const Image *image,
 %    o exception: return any errors or warnings in this structure.
 %
 */
-MagickExport ImageType GetImageType(const Image *image,ExceptionInfo *exception)
+MagickExport ImageType IdentifyImageGray(const 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 == MagickCoreSignature);
+  if (image->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+  if ((image->type == BilevelType) || (image->type == GrayscaleType) ||
+      (image->type == GrayscaleAlphaType))
+    return(image->type);
+  if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
+    return(UndefinedType);
+  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 == GrayscaleType) && (image->alpha_trait != UndefinedPixelTrait))
+    type=GrayscaleAlphaType;
+  return(type);
+}
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   I d e n t i f y I m a g e M o n o c h r o m e                             %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  IdentifyImageMonochrome() 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.
+%
+%  The format of the IdentifyImageMonochrome method is:
+%
+%      MagickBooleanType IdentifyImageMonochrome(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 IdentifyImageMonochrome(const 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 == MagickCoreSignature);
+  if (image->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+  if (image->type == BilevelType)
+    return(MagickTrue);
+  if (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 == BilevelType)
+    return(MagickTrue);
+  return(MagickFalse);
+}
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   I d e n t i f y I m a g e T y p e                                         %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  IdentifyImageType() returns the potential type of image:
+%
+%        Bilevel         Grayscale        GrayscaleMatte
+%        Palette         PaletteMatte     TrueColor
+%        TrueColorMatte  ColorSeparation  ColorSeparationMatte
+%
+%  To ensure the image type matches its potential, use SetImageType():
+%
+%    (void) SetImageType(image,IdentifyImageType(image,exception),exception);
+%
+%  The format of the IdentifyImageType method is:
+%
+%      ImageType IdentifyImageType(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 ImageType IdentifyImageType(const Image *image,
+  ExceptionInfo *exception)
 {
   assert(image != (Image *) NULL);
   assert(image->signature == MagickCoreSignature);
@@ -601,15 +816,15 @@ MagickExport ImageType GetImageType(const Image *image,ExceptionInfo *exception)
         return(ColorSeparationType);
       return(ColorSeparationAlphaType);
     }
-  if (SetImageMonochrome((Image *) image,exception) != MagickFalse)
+  if (IdentifyImageMonochrome(image,exception) != MagickFalse)
     return(BilevelType);
-  if (SetImageGray((Image *) image,exception) != MagickFalse)
+  if (IdentifyImageGray(image,exception) != MagickFalse)
     {
       if (image->alpha_trait != UndefinedPixelTrait)
         return(GrayscaleAlphaType);
       return(GrayscaleType);
     }
-  if (IsPaletteImage(image,exception) != MagickFalse)
+  if (IdentifyPaletteImage(image,exception) != MagickFalse)
     {
       if (image->alpha_trait != UndefinedPixelTrait)
         return(PaletteAlphaType);
@@ -619,7 +834,7 @@ MagickExport ImageType GetImageType(const Image *image,ExceptionInfo *exception)
     return(TrueColorAlphaType);
   return(TrueColorType);
 }
-
+
 /*
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %                                                                             %
@@ -983,177 +1198,6 @@ 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 == MagickCoreSignature);
-  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);
-}
-
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%   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 == MagickCoreSignature);
-  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);
-}
-
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%                                                                             %
-%                                                                             %
-%                                                                             %
 %   S e t I m a g e T y p e                                                   %
 %                                                                             %
 %                                                                             %
diff --git a/MagickCore/attribute.h b/MagickCore/attribute.h
index 86d494d6b1..0c5610db91 100644
--- a/MagickCore/attribute.h
+++ b/MagickCore/attribute.h
@@ -26,15 +26,16 @@ extern "C" {
 #endif
 
 extern MagickExport ImageType
-  GetImageType(const Image *,ExceptionInfo *);
+  GetImageType(const Image *),
+  IdentifyImageGray(const Image *,ExceptionInfo *),
+  IdentifyImageType(const Image *,ExceptionInfo *);
 
 extern MagickExport MagickBooleanType
+  IdentifyImageMonochrome(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/colorspace.c b/MagickCore/colorspace.c
index 350fbfb1d1..222de2966d 100644
--- a/MagickCore/colorspace.c
+++ b/MagickCore/colorspace.c
@@ -40,6 +40,7 @@
   Include declarations.
 */
 #include "MagickCore/studio.h"
+#include "MagickCore/attribute.h"
 #include "MagickCore/property.h"
 #include "MagickCore/cache.h"
 #include "MagickCore/cache-private.h"
@@ -1118,7 +1119,105 @@ MagickExport MagickBooleanType SetImageColorspace(Image *image,
   image->type=type;
   return(status);
 }
-
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%     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)
+{
+  ImageType
+    type;
+
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickCoreSignature);
+  if (image->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+  if (IsImageGray(image))
+    return(MagickTrue);
+  if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
+    return(MagickFalse);
+  type=IdentifyImageGray(image,exception);
+  if (type == UndefinedType)
+    return(MagickFalse);
+  image->colorspace=GRAYColorspace;
+  if (SyncImagePixelCache((Image *) image,exception) == MagickFalse)
+    return(MagickFalse);
+  image->type=type;
+  return(MagickTrue);
+}
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   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(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)
+{
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickCoreSignature);
+  if (image->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+  if (image->type == BilevelType)
+    return(MagickTrue);
+  if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
+    return(MagickFalse);
+  if (IdentifyImageMonochrome(image,exception) == MagickFalse)
+    return(MagickFalse);
+  image->colorspace=GRAYColorspace;
+  if (SyncImagePixelCache((Image *) image,exception) == MagickFalse)
+    return(MagickFalse);
+  image->type=BilevelType;
+  return(MagickTrue);
+}
+
 /*
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %                                                                             %
diff --git a/MagickCore/colorspace.h b/MagickCore/colorspace.h
index ba95e5473b..2c0747f77b 100644
--- a/MagickCore/colorspace.h
+++ b/MagickCore/colorspace.h
@@ -61,6 +61,8 @@ typedef enum
 
 extern MagickExport MagickBooleanType
   SetImageColorspace(Image *,const ColorspaceType,ExceptionInfo *),
+  SetImageGray(Image *,ExceptionInfo *),
+  SetImageMonochrome(Image *,ExceptionInfo *),
   TransformImageColorspace(Image *,const ColorspaceType,ExceptionInfo *);
 
 #if defined(__cplusplus) || defined(c_plusplus)
diff --git a/MagickCore/histogram.c b/MagickCore/histogram.c
index e3de5e2e8e..20aa05f7d8 100644
--- a/MagickCore/histogram.c
+++ b/MagickCore/histogram.c
@@ -605,6 +605,171 @@ static NodeInfo *GetNodeInfo(CubeInfo *cube_info,const size_t level)
   return(node_info);
 }
 
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%  I d e n t i f y P a l e t t e I m a g e                                    %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  IdentifyPaletteImage() returns MagickTrue if the image has 256 unique colors
+%  or less.
+%
+%  The format of the IdentifyPaletteImage method is:
+%
+%      MagickBooleanType IdentifyPaletteImage(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.
+%
+*/
+
+static MagickBooleanType CheckImageColors(const Image *image,
+  ExceptionInfo *exception,size_t max_colors)
+{
+  CacheView
+    *image_view;
+
+  CubeInfo
+    *cube_info;
+
+  PixelInfo
+    pixel,
+    target;
+
+  register const Quantum
+    *p;
+
+  register ssize_t
+    x;
+
+  register NodeInfo
+    *node_info;
+
+  register ssize_t
+    i;
+
+  size_t
+    id,
+    index,
+    level;
+
+  ssize_t
+    y;
+
+  if (image->storage_class == PseudoClass)
+    return((image->colors <= max_colors) ? MagickTrue : MagickFalse);
+  /*
+    Initialize color description tree.
+  */
+  cube_info=GetCubeInfo();
+  if (cube_info == (CubeInfo *) NULL)
+    {
+      (void) ThrowMagickException(exception,GetMagickModule(),
+        ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
+      return(MagickFalse);
+    }
+  GetPixelInfo(image,&pixel);
+  GetPixelInfo(image,&target);
+  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++)
+    {
+      /*
+        Start at the root and proceed level by level.
+      */
+      node_info=cube_info->root;
+      index=MaxTreeDepth-1;
+      for (level=1; level < MaxTreeDepth; level++)
+      {
+        GetPixelInfoPixel(image,p,&pixel);
+        id=ColorToNodeId(image,&pixel,index);
+        if (node_info->child[id] == (NodeInfo *) NULL)
+          {
+            node_info->child[id]=GetNodeInfo(cube_info,level);
+            if (node_info->child[id] == (NodeInfo *) NULL)
+              {
+                (void) ThrowMagickException(exception,GetMagickModule(),
+                  ResourceLimitError,"MemoryAllocationFailed","`%s'",
+                  image->filename);
+                break;
+              }
+          }
+        node_info=node_info->child[id];
+        index--;
+      }
+      if (level < MaxTreeDepth)
+        break;
+      for (i=0; i < (ssize_t) node_info->number_unique; i++)
+      {
+        target=node_info->list[i];
+        if (IsPixelInfoEquivalent(&pixel,&target) != MagickFalse)
+          break;
+      }
+      if (i < (ssize_t) node_info->number_unique)
+        node_info->list[i].count++;
+      else
+        {
+          /*
+            Add this unique color to the color list.
+          */
+          if (node_info->number_unique == 0)
+            node_info->list=(PixelInfo *) AcquireMagickMemory(
+              sizeof(*node_info->list));
+          else
+            node_info->list=(PixelInfo *) ResizeQuantumMemory(node_info->list,
+              (size_t) (i+1),sizeof(*node_info->list));
+          if (node_info->list == (PixelInfo *) NULL)
+            {
+              (void) ThrowMagickException(exception,GetMagickModule(),
+                ResourceLimitError,"MemoryAllocationFailed","`%s'",
+                image->filename);
+              break;
+            }
+          node_info->list[i].red=(double) GetPixelRed(image,p);
+          node_info->list[i].green=(double) GetPixelGreen(image,p);
+          node_info->list[i].blue=(double) GetPixelBlue(image,p);
+          if (image->colorspace == CMYKColorspace)
+            node_info->list[i].black=(double) GetPixelBlack(image,p);
+          node_info->list[i].alpha=(double) GetPixelAlpha(image,p);
+          node_info->list[i].count=1;
+          node_info->number_unique++;
+          cube_info->colors++;
+          if (cube_info->colors > max_colors)
+            break;
+        }
+      p+=GetPixelChannels(image);
+    }
+    if (x < (ssize_t) image->columns)
+      break;
+  }
+  image_view=DestroyCacheView(image_view);
+  cube_info=DestroyCubeInfo(image,cube_info);
+  return(y < (ssize_t) image->rows ? MagickFalse : MagickTrue);
+}
+
+MagickExport MagickBooleanType IdentifyPaletteImage(const Image *image,
+  ExceptionInfo *exception)
+{
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickCoreSignature);
+  if (image->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+  return(CheckImageColors(image,exception,256));
+}
+
 /*
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %                                                                             %
@@ -636,136 +801,11 @@ MagickExport MagickBooleanType IsHistogramImage(const Image *image,
 {
 #define MaximumUniqueColors  1024
 
-  CacheView
-    *image_view;
-
-  CubeInfo
-    *cube_info;
-
-  PixelInfo
-    pixel,
-    target;
-
-  register const Quantum
-    *p;
-
-  register ssize_t
-    x;
-
-  register NodeInfo
-    *node_info;
-
-  register ssize_t
-    i;
-
-  size_t
-    id,
-    index,
-    level;
-
-  ssize_t
-    y;
-
   assert(image != (Image *) NULL);
   assert(image->signature == MagickCoreSignature);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
-  if ((image->storage_class == PseudoClass) &&
-      (image->colors <= MaximumUniqueColors))
-    return(MagickTrue);
-  if (image->storage_class == PseudoClass)
-    return(MagickFalse);
-  /*
-    Initialize color description tree.
-  */
-  cube_info=GetCubeInfo();
-  if (cube_info == (CubeInfo *) NULL)
-    {
-      (void) ThrowMagickException(exception,GetMagickModule(),
-        ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
-      return(MagickFalse);
-    }
-  GetPixelInfo(image,&pixel);
-  GetPixelInfo(image,&target);
-  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++)
-    {
-      /*
-        Start at the root and proceed level by level.
-      */
-      node_info=cube_info->root;
-      index=MaxTreeDepth-1;
-      for (level=1; level < MaxTreeDepth; level++)
-      {
-        GetPixelInfoPixel(image,p,&pixel);
-        id=ColorToNodeId(image,&pixel,index);
-        if (node_info->child[id] == (NodeInfo *) NULL)
-          {
-            node_info->child[id]=GetNodeInfo(cube_info,level);
-            if (node_info->child[id] == (NodeInfo *) NULL)
-              {
-                (void) ThrowMagickException(exception,GetMagickModule(),
-                  ResourceLimitError,"MemoryAllocationFailed","`%s'",
-                  image->filename);
-                break;
-              }
-          }
-        node_info=node_info->child[id];
-        index--;
-      }
-      if (level < MaxTreeDepth)
-        break;
-      for (i=0; i < (ssize_t) node_info->number_unique; i++)
-      {
-        target=node_info->list[i];
-        if (IsPixelInfoEquivalent(&pixel,&target) != MagickFalse)
-          break;
-      }
-      if (i < (ssize_t) node_info->number_unique)
-        node_info->list[i].count++;
-      else
-        {
-          /*
-            Add this unique color to the color list.
-          */
-          if (node_info->number_unique == 0)
-            node_info->list=(PixelInfo *) AcquireMagickMemory(
-              sizeof(*node_info->list));
-          else
-            node_info->list=(PixelInfo *) ResizeQuantumMemory(node_info->list,
-              (size_t) (i+1),sizeof(*node_info->list));
-          if (node_info->list == (PixelInfo *) NULL)
-            {
-              (void) ThrowMagickException(exception,GetMagickModule(),
-                ResourceLimitError,"MemoryAllocationFailed","`%s'",
-                image->filename);
-              break;
-            }
-          node_info->list[i].red=(double) GetPixelRed(image,p);
-          node_info->list[i].green=(double) GetPixelGreen(image,p);
-          node_info->list[i].blue=(double) GetPixelBlue(image,p);
-          if (image->colorspace == CMYKColorspace)
-            node_info->list[i].black=(double) GetPixelBlack(image,p);
-          node_info->list[i].alpha=(double) GetPixelAlpha(image,p);
-          node_info->list[i].count=1;
-          node_info->number_unique++;
-          cube_info->colors++;
-          if (cube_info->colors > MaximumUniqueColors)
-            break;
-        }
-      p+=GetPixelChannels(image);
-    }
-    if (x < (ssize_t) image->columns)
-      break;
-  }
-  image_view=DestroyCacheView(image_view);
-  cube_info=DestroyCubeInfo(image,cube_info);
-  return(y < (ssize_t) image->rows ? MagickFalse : MagickTrue);
+  return(CheckImageColors(image,exception,MaximumUniqueColors));
 }
 
 /*
@@ -784,149 +824,22 @@ MagickExport MagickBooleanType IsHistogramImage(const Image *image,
 %
 %  The format of the IsPaletteImage method is:
 %
-%      MagickBooleanType IsPaletteImage(const Image *image,
-%        ExceptionInfo *exception)
+%      MagickBooleanType IsPaletteImage(const Image *image)
 %
 %  A description of each parameter follows.
 %
 %    o image: the image.
 %
-%    o exception: return any errors or warnings in this structure.
-%
 */
-MagickExport MagickBooleanType IsPaletteImage(const Image *image,
-  ExceptionInfo *exception)
+MagickExport MagickBooleanType IsPaletteImage(const Image *image)
 {
-  CacheView
-    *image_view;
-
-  CubeInfo
-    *cube_info;
-
-  PixelInfo
-    pixel,
-    target;
-
-  register const Quantum
-    *p;
-
-  register ssize_t
-    x;
-
-  register NodeInfo
-    *node_info;
-
-  register ssize_t
-    i;
-
-  size_t
-    id,
-    index,
-    level;
-
-  ssize_t
-    y;
-
   assert(image != (Image *) NULL);
   assert(image->signature == MagickCoreSignature);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
-  if ((image->storage_class == PseudoClass) && (image->colors <= 256))
-    return(MagickTrue);
-  if (image->storage_class == PseudoClass)
+  if (image->storage_class != PseudoClass)
     return(MagickFalse);
-  /*
-    Initialize color description tree.
-  */
-  cube_info=GetCubeInfo();
-  if (cube_info == (CubeInfo *) NULL)
-    {
-      (void) ThrowMagickException(exception,GetMagickModule(),
-        ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
-      return(MagickFalse);
-    }
-  GetPixelInfo(image,&pixel);
-  GetPixelInfo(image,&target);
-  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++)
-    {
-      /*
-        Start at the root and proceed level by level.
-      */
-      node_info=cube_info->root;
-      index=MaxTreeDepth-1;
-      for (level=1; level < MaxTreeDepth; level++)
-      {
-        GetPixelInfoPixel(image,p,&pixel);
-        id=ColorToNodeId(image,&pixel,index);
-        if (node_info->child[id] == (NodeInfo *) NULL)
-          {
-            node_info->child[id]=GetNodeInfo(cube_info,level);
-            if (node_info->child[id] == (NodeInfo *) NULL)
-              {
-                (void) ThrowMagickException(exception,GetMagickModule(),
-                  ResourceLimitError,"MemoryAllocationFailed","`%s'",
-                  image->filename);
-                break;
-              }
-          }
-        node_info=node_info->child[id];
-        index--;
-      }
-      if (level < MaxTreeDepth)
-        break;
-      for (i=0; i < (ssize_t) node_info->number_unique; i++)
-      {
-        target=node_info->list[i];
-        if (IsPixelInfoEquivalent(&pixel,&target) != MagickFalse)
-          break;
-      }
-      if (i < (ssize_t) node_info->number_unique)
-        node_info->list[i].count++;
-      else
-        {
-          /*
-            Add this unique color to the color list.
-          */
-          if (node_info->number_unique == 0)
-            node_info->list=(PixelInfo *) AcquireMagickMemory(
-              sizeof(*node_info->list));
-          else
-            node_info->list=(PixelInfo *) ResizeQuantumMemory(node_info->list,
-              (size_t) (i+1),sizeof(*node_info->list));
-          if (node_info->list == (PixelInfo *) NULL)
-            {
-              (void) ThrowMagickException(exception,GetMagickModule(),
-                ResourceLimitError,"MemoryAllocationFailed","`%s'",
-                image->filename);
-              break;
-            }
-          node_info->list[i]=pixel;
-          node_info->list[i].red=(double) GetPixelRed(image,p);
-          node_info->list[i].green=(double) GetPixelGreen(image,p);
-          node_info->list[i].blue=(double) GetPixelBlue(image,p);
-          if (image->colorspace == CMYKColorspace)
-            node_info->list[i].black=(double) GetPixelBlack(image,p);
-          node_info->list[i].alpha=(double) GetPixelAlpha(image,p);
-          node_info->list[i].count=1;
-          node_info->number_unique++;
-          cube_info->colors++;
-          if (cube_info->colors > 256)
-            break;
-        }
-      p+=GetPixelChannels(image);
-    }
-    if (x < (ssize_t) image->columns)
-      break;
-  }
-  image_view=DestroyCacheView(image_view);
-  cube_info=DestroyCubeInfo(image,cube_info);
-  return(y < (ssize_t) image->rows ? MagickFalse : MagickTrue);
+  return((image->colors <= 256) ? MagickTrue : MagickFalse);
 }
 
 /*
diff --git a/MagickCore/histogram.h b/MagickCore/histogram.h
index ec765931c7..a5bc2b3ad5 100644
--- a/MagickCore/histogram.h
+++ b/MagickCore/histogram.h
@@ -29,8 +29,9 @@ extern MagickExport Image
   *UniqueImageColors(const Image *,ExceptionInfo *);
 
 extern MagickExport MagickBooleanType
+  IdentifyPaletteImage(const Image *,ExceptionInfo *),
   IsHistogramImage(const Image *,ExceptionInfo *),
-  IsPaletteImage(const Image *,ExceptionInfo *),
+  IsPaletteImage(const Image *),
   MinMaxStretchImage(Image *,const double,const double,const double,
     ExceptionInfo *);
 
diff --git a/MagickCore/identify.c b/MagickCore/identify.c
index 14b549be5c..7297dcade8 100644
--- a/MagickCore/identify.c
+++ b/MagickCore/identify.c
@@ -465,6 +465,7 @@ MagickExport MagickBooleanType IdentifyImage(Image *image,FILE *file,
     user_time;
 
   ImageType
+    base_type,
     type;
 
   MagickBooleanType
@@ -489,6 +490,11 @@ MagickExport MagickBooleanType IdentifyImage(Image *image,FILE *file,
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
   if (file == (FILE *) NULL)
     file=stdout;
+  colorspace=image->colorspace;
+  type=IdentifyImageType(image,exception);
+  if ((type == BilevelType) || (type == GrayscaleType) ||
+      (type == GrayscaleAlphaType))
+    colorspace=GRAYColorspace;
   locate=GetImageArtifact(image,"identify:locate");
   if (locate != (const char *) NULL)
     {
@@ -513,9 +519,6 @@ MagickExport MagickBooleanType IdentifyImage(Image *image,FILE *file,
       channel_statistics=GetLocationStatistics(image,type,exception);
       if (channel_statistics == (ChannelStatistics *) NULL)
         return(MagickFalse);
-      colorspace=image->colorspace;
-      if (SetImageGray(image,exception) != MagickFalse)
-        colorspace=GRAYColorspace;
       (void) FormatLocaleFile(file,"Channel %s locations:\n",locate);
       switch (colorspace)
       {
@@ -635,7 +638,6 @@ MagickExport MagickBooleanType IdentifyImage(Image *image,FILE *file,
   */
   p=GetVirtualPixels(image,0,0,1,1,exception);
   ping=p == (const Quantum *) NULL ? MagickTrue : MagickFalse;
-  type=GetImageType(image,exception);
   (void) SignatureImage(image,exception);
   (void) FormatLocaleFile(file,"Image: %s\n",image->filename);
   if (*image->magick_filename != '\0')
@@ -680,9 +682,10 @@ MagickExport MagickBooleanType IdentifyImage(Image *image,FILE *file,
     MagickResolutionOptions,(ssize_t) image->units));
   (void) FormatLocaleFile(file,"  Type: %s\n",CommandOptionToMnemonic(
     MagickTypeOptions,(ssize_t) type));
-  if (image->type != UndefinedType)
+  base_type=GetImageType(image);
+  if (type != base_type)
     (void) FormatLocaleFile(file,"  Base type: %s\n",CommandOptionToMnemonic(
-      MagickTypeOptions,(ssize_t) image->type));
+      MagickTypeOptions,(ssize_t) base_type));
   (void) FormatLocaleFile(file,"  Endianess: %s\n",CommandOptionToMnemonic(
     MagickEndianOptions,(ssize_t) image->endian));
   /*
@@ -694,7 +697,6 @@ MagickExport MagickBooleanType IdentifyImage(Image *image,FILE *file,
   channel_moments=(ChannelMoments *) NULL;
   channel_phash=(ChannelPerceptualHash *) NULL;
   channel_features=(ChannelFeatures *) NULL;
-  colorspace=image->colorspace;
   scale=1.0;
   if (ping == MagickFalse)
     {
@@ -724,8 +726,6 @@ 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 (SetImageGray(image,exception) != MagickFalse)
-        colorspace=GRAYColorspace;
       switch (colorspace)
       {
         case RGBColorspace:
diff --git a/MagickCore/property.c b/MagickCore/property.c
index cb45d0bac7..1307a3a675 100644
--- a/MagickCore/property.c
+++ b/MagickCore/property.c
@@ -3004,7 +3004,7 @@ MagickExport const char *GetMagickProperty(ImageInfo *image_info,
         {
           WarnNoImageReturn("\"%%[%s]\"",property);
           string=CommandOptionToMnemonic(MagickTypeOptions,(ssize_t)
-            GetImageType(image,exception));
+            IdentifyImageType(image,exception));
           break;
         }
        break;
diff --git a/MagickCore/quantize.c b/MagickCore/quantize.c
index 68307bfacb..f8d64d3f19 100644
--- a/MagickCore/quantize.c
+++ b/MagickCore/quantize.c
@@ -1189,7 +1189,7 @@ MagickExport MagickBooleanType CompressImageColormap(Image *image,
   assert(image->signature == MagickCoreSignature);
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
-  if (IsPaletteImage(image,exception) == MagickFalse)
+  if (image->storage_class != PseudoClass)
     return(MagickFalse);
   GetQuantizeInfo(&quantize_info);
   quantize_info.number_colors=image->colors;
diff --git a/MagickWand/magick-image.c b/MagickWand/magick-image.c
index 376488232d..10a0fb2cde 100644
--- a/MagickWand/magick-image.c
+++ b/MagickWand/magick-image.c
@@ -5635,10 +5635,6 @@ WandExport size_t MagickGetImageTicksPerSecond(MagickWand *wand)
 %        Palette        PaletteMatte    TrueColor
 %        TrueColorMatte ColorSeparation ColorSeparationMatte
 %
-%  To ensure the image type matches its potential, use MagickSetImageType():
-%
-%    (void) MagickSetImageType(wand,MagickGetImageType(wand));
-%
 %  The format of the MagickGetImageType method is:
 %
 %      ImageType MagickGetImageType(MagickWand *wand)
@@ -5660,7 +5656,7 @@ WandExport ImageType MagickGetImageType(MagickWand *wand)
         "ContainsNoImages","`%s'",wand->name);
       return(UndefinedType);
     }
-  return(GetImageType(wand->images,wand->exception));
+  return(GetImageType(wand->images));
 }
 
 /*
@@ -6060,7 +6056,52 @@ WandExport char *MagickIdentifyImage(MagickWand *wand)
   (void) RelinquishUniqueFileResource(filename);
   return(description);
 }
-
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   M a g i c k I d e n t i f y I m a g e T y p e                             %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  MagickIdentifyImageType() gets the potential image type:
+%
+%        Bilevel        Grayscale       GrayscaleMatte
+%        Palette        PaletteMatte    TrueColor
+%        TrueColorMatte ColorSeparation ColorSeparationMatte
+%
+%  To ensure the image type matches its potential, use MagickSetImageType():
+%
+%    (void) MagickSetImageType(wand,MagickIdentifyImageType(wand));
+%
+%  The format of the MagickIdentifyImageType method is:
+%
+%      ImageType MagickIdentifyImageType(MagickWand *wand)
+%
+%  A description of each parameter follows:
+%
+%    o wand: the magick wand.
+%
+*/
+WandExport ImageType MagickIdentifyImageType(MagickWand *wand)
+{
+  assert(wand != (MagickWand *) NULL);
+  assert(wand->signature == MagickWandSignature);
+  if (IfMagickTrue(wand->debug))
+    (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
+  if (wand->images == (Image *) NULL)
+    {
+      (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
+        "ContainsNoImages","`%s'",wand->name);
+      return(UndefinedType);
+    }
+  return(IdentifyImageType(wand->images,wand->exception));
+}
+
 /*
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %                                                                             %
diff --git a/MagickWand/magick-image.h b/MagickWand/magick-image.h
index 589cb35d2a..fb886542c8 100644
--- a/MagickWand/magick-image.h
+++ b/MagickWand/magick-image.h
@@ -68,7 +68,8 @@ extern WandExport Image
   *GetImageFromMagickWand(const MagickWand *);
 
 extern WandExport ImageType
-  MagickGetImageType(MagickWand *);
+  MagickGetImageType(MagickWand *),
+  MagickIdentifyImageType(MagickWand *);
 
 extern WandExport InterlaceType
   MagickGetImageInterlaceScheme(MagickWand *);
diff --git a/coders/ept.c b/coders/ept.c
index 0fae7eafdb..f87f7a747b 100644
--- a/coders/ept.c
+++ b/coders/ept.c
@@ -429,8 +429,8 @@ static MagickBooleanType WriteEPTImage(const ImageInfo *image_info,Image *image,
         EPT preview requires that the image is colormapped.
       */
       GetQuantizeInfo(&quantize_info);
-      quantize_info.dither_method=IsPaletteImage(write_image,exception) ==
-        MagickFalse ? RiemersmaDitherMethod : NoDitherMethod;
+      quantize_info.dither_method=IdentifyPaletteImage(write_image,
+        exception) == MagickFalse ? RiemersmaDitherMethod : NoDitherMethod;
       (void) QuantizeImage(&quantize_info,write_image,exception);
     }
   write_info->compression=NoCompression;
diff --git a/coders/json.c b/coders/json.c
index bd335e090f..404e68c741 100644
--- a/coders/json.c
+++ b/coders/json.c
@@ -697,6 +697,7 @@ static MagickBooleanType EncodeImageAttributes(Image *image,FILE *file,
     user_time;
 
   ImageType
+    base_type,
     type;
 
   MagickBooleanType
@@ -728,7 +729,6 @@ static MagickBooleanType EncodeImageAttributes(Image *image,FILE *file,
   p=GetVirtualPixels(image,0,0,1,1,exception);
   ping=p == (const Quantum *) NULL ? MagickTrue : MagickFalse;
   (void) ping;
-  type=GetImageType(image,exception);
   (void) SignatureImage(image,exception);
   JsonFormatLocaleFile(file,"{\n  \"image\": {\n    \"name\": %s,\n",
     image->filename);
@@ -776,11 +776,17 @@ static MagickBooleanType EncodeImageAttributes(Image *image,FILE *file,
     }
   JsonFormatLocaleFile(file,"    \"units\": %s,\n",CommandOptionToMnemonic(
     MagickResolutionOptions,(ssize_t) image->units));
+  colorspace=image->colorspace;
+  type=IdentifyImageType(image,exception);
+  if ((type == BilevelType) || (type == GrayscaleType) ||
+      (type == GrayscaleAlphaType))
+    colorspace=GRAYColorspace;
   JsonFormatLocaleFile(file,"    \"type\": %s,\n",CommandOptionToMnemonic(
     MagickTypeOptions,(ssize_t) type));
-  if (image->type != UndefinedType)
+  base_type=GetImageType(image);
+  if (type != base_type)
     JsonFormatLocaleFile(file,"    \"baseType\": %s,\n",
-      CommandOptionToMnemonic(MagickTypeOptions,(ssize_t) image->type));
+      CommandOptionToMnemonic(MagickTypeOptions,(ssize_t) base_type));
   JsonFormatLocaleFile(file,"    \"endianess\": %s,\n",
     CommandOptionToMnemonic(MagickEndianOptions,(ssize_t) image->endian));
   locate=GetImageArtifact(image,"identify:locate");
@@ -811,9 +817,6 @@ static MagickBooleanType EncodeImageAttributes(Image *image,FILE *file,
       channel_statistics=GetLocationStatistics(image,type,exception);
       if (channel_statistics == (ChannelStatistics *) NULL)
         return(MagickFalse);
-      colorspace=image->colorspace;
-      if (SetImageGray(image,exception) != MagickFalse)
-        colorspace=GRAYColorspace;
       (void) FormatLocaleFile(file,"    \"channel%s\": {\n",locate);
       if (image->alpha_trait != UndefinedPixelTrait)
         (void) PrintChannelLocations(file,image,AlphaPixelChannel,"Alpha",
@@ -864,7 +867,6 @@ static MagickBooleanType EncodeImageAttributes(Image *image,FILE *file,
   channel_moments=(ChannelMoments *) NULL;
   channel_phash=(ChannelPerceptualHash *) NULL;
   channel_features=(ChannelFeatures *) NULL;
-  colorspace=image->colorspace;
   scale=1;
   channel_statistics=GetImageStatistics(image,exception);
   if (channel_statistics == (ChannelStatistics *) NULL)
@@ -890,8 +892,6 @@ static MagickBooleanType EncodeImageAttributes(Image *image,FILE *file,
   (void) FormatLocaleFile(file,"    \"baseDepth\": %.20g,\n",(double)
     image->depth);
   (void) FormatLocaleFile(file,"    \"channelDepth\": {\n");
-  if (SetImageGray(image,exception) != MagickFalse)
-    colorspace=GRAYColorspace;
   if (image->alpha_trait != UndefinedPixelTrait)
     (void) FormatLocaleFile(file,"      \"alpha\": %.20g,\n",(double)
       channel_statistics[AlphaPixelChannel].depth);
diff --git a/coders/map.c b/coders/map.c
index 15c1cdc23d..3b2bd1d981 100644
--- a/coders/map.c
+++ b/coders/map.c
@@ -380,7 +380,7 @@ static MagickBooleanType WriteMAPImage(const ImageInfo *image_info,Image *image,
   /*
     Allocate colormap.
   */
-  if (IsPaletteImage(image,exception) == MagickFalse)
+  if (IsPaletteImage(image) == MagickFalse)
     (void) SetImageType(image,PaletteType,exception);
   depth=GetImageQuantumDepth(image,MagickTrue);
   packet_size=(size_t) (depth/8);
diff --git a/coders/palm.c b/coders/palm.c
index a245f9ac29..f616771cc5 100644
--- a/coders/palm.c
+++ b/coders/palm.c
@@ -804,7 +804,7 @@ static MagickBooleanType WritePALMImage(const ImageInfo *image_info,
       {
         if (flags & PALM_HAS_COLORMAP_FLAG)  /* Write out colormap */
           {
-            quantize_info->dither_method=IsPaletteImage(image,exception)
+            quantize_info->dither_method=IdentifyPaletteImage(image,exception)
               == MagickFalse ? RiemersmaDitherMethod : NoDitherMethod;
             quantize_info->number_colors=image->colors;
             (void) QuantizeImage(quantize_info,image,exception);
diff --git a/coders/pdb.c b/coders/pdb.c
index 0e4d1ef17f..1104be5817 100644
--- a/coders/pdb.c
+++ b/coders/pdb.c
@@ -759,8 +759,7 @@ static MagickBooleanType WritePDBImage(const ImageInfo *image_info,Image *image,
   if (status == MagickFalse)
     return(status);
   (void) TransformImageColorspace(image,sRGBColorspace,exception);
-  if ((image->colors <= 2) ||
-      (GetImageType(image,exception ) == BilevelType)) {
+  if (SetImageMonochrome(image,exception) != MagickFalse) {
     bits_per_pixel=1;
   } else if (image->colors <= 4) {
     bits_per_pixel=2;
diff --git a/coders/svg.c b/coders/svg.c
index e8717cacff..9cd1d6c358 100644
--- a/coders/svg.c
+++ b/coders/svg.c
@@ -3444,7 +3444,8 @@ static MagickBooleanType TraceSVGImage(Image *image,ExceptionInfo *exception)
     */
     fitting_options=at_fitting_opts_new();
     output_options=at_output_opts_new();
-    type=GetImageType(image,exception);
+    (void) SetImageGray(image,exception);
+    type=GetImageType(image);
     number_planes=3;
     if ((type == BilevelType) || (type == GrayscaleType))
       number_planes=1;