What I propose is using Presentation Core's System.Windows.Media.Imaging, which exposes a the abstract BitmapDecoder class, base of all decoders that Windows Imaging directly supports:
System.Windows.Media.Imaging.BmpBitmapDecoder
System.Windows.Media.Imaging.GifBitmapDecoder
System.Windows.Media.Imaging.IconBitmapDecoder
System.Windows.Media.Imaging.JpegBitmapDecoder
System.Windows.Media.Imaging.LateBoundBitmapDecoder
System.Windows.Media.Imaging.PngBitmapDecoder
System.Windows.Media.Imaging.TiffBitmapDecoder
System.Windows.Media.Imaging.WmpBitmapDecoder
When decoding an Image file stream, the correct decoder is cast from the abstract class to the specific class.
The decoded Image frames are cast to a BitmapFrame Class, whose members translate to a BitmapSource class, which references all the decoded informations about the Image Stream.
Of interest, in this case, is the BitmapSource.Format property, which exposes a System.Windows.Media.PixelFormat Structure and its enumeration of recognized formats.
See also PixelFormats Properties
These formats include:
PixelFormats.Gray32Float
PixelFormats.Gray16
PixelFormats.Gray8
PixelFormats.Gray4
PixelFormats.Gray2
These flags can be tested as usual.
This class can be used to collect informations about a Bitmap format.
I've included a Property, IsGrayscale, which returns the result of the test of the Image PixelFormat, using the PixelFormats previously listed.
The Image Format is referenced by the BitmapInfo.Format BitmapInfo.Metadata.Format properties (different sources, for comparison.
The other properties are quite self-explanatory.
A Project that implements this class must reference:
PresentationCore
System.Xaml
WindowsBase
Properties:
ImageSize (Size) => Size of the Image
Dpi (Size) => DpiX and DpiY of the Image
PixelSize (Size) => Size in Pixels ot the Image
Masks (List) => List of Byte Masks
BitsPerPixel (int) => Bits per Pixel
PixelFormat (PixelFormat) => Pixel format as reported by the Decoder
ImageType (string) => Textual expression of the image format (GIF, JPG etc.)
HasPalette (bool) => The Image has a Palette
Palette (BitmapPalette) => Palette representation of the Image Colors
HasThumbnail (bool) => The Image includes a Thumbnail image
Thumbnail (BitmapImage) => The Image Thumbnail, in BitmapImage format
Frames (int) => Number of frames. Animated Images are represented by a sequence of frames
FramesContent (FramesInfo) => Informations about all frame included in this Image
IsMetadataSuppported (bool) => The Image has Metadata informations
Metadata (MetadataInfo) => Class referencing all the Metadata informations a Image contains
AnimationSupported (bool) => This Format supports frame Animations
Animated (bool) => The Image is a timed sequence of frames
Methods:
public enum DeepScanOptions : int {
Default = 0,
Skip,
Force
}
public bool IsGrayScale(DeepScanOptions DeepScan)
Checks whether the Image PixelFormat is to be considered GrayScale, given the image internal Palette. The DeepScanOptions enumerator is used to determine how the scan is performed.
More details in the Sample Usage part.
public enum GrayScaleInfo : int {
None = 0,
Partial,
GrayScale,
Undefined
}
public ImagingBitmapInfo.GrayScaleInfo IsGrayScaleFrames()
Reports the status of the Frames Palettes. It might return:
None: The Image has no Grayscale Frames
Partial: Some Frames are GrayScale
GrayScale: All Frames have a GrayScale Palette
Undefined: The Image probably has no Palette Information. The Image pixel format is reported by the PixelFormat property
public ImagingBitmapInfo.GrayScaleStats GrayScaleSimilarity();
This method performs a statistical evaluation (Average, (Sum(Min) <=> Sum(Max)), considering the Colors of all the internal Palettes of an Image, to verify how much the internal colorific representation can be assimilated to a GrayScale pattern.
It returns a ImagingBitmapInfo.GrayScaleStats, which exposes these Properties:
int Palettes: Number of Palette evaluated
float AverageMaxDistance: Average distance (Max) between RGB components
float AverageMinDistance: Average distance (Min) between RGB components
float AverageLogDistance: Average logical distance between RGB components
float GrayScalePercent: Percentage of similarity
float GrayScaleAveragePercent: Percentage of logical similarity
List<FrameStat> PerFrameValues: Class that reports the calculated results for each Palette entry. It exposes these Properties:
int ColorEntries: Number of Colors in the current Palette
float DistanceMax: Distance (Max) between RGB components
float DistanceMin: Distance (Min) between RGB components
float DistanceAverage: Average distance between RGB components
public void FrameSourceAddRange(BitmapFrame[] bitmapFrames)
Inserts all Image Frames information in a FramesInfo Class.
It's used internally, but can be filled manually when an instance of the main class, ImagingBitmapInfo, is created. Exposes these properties:
FramesTotalNumber: Total number of Frames included in the Image
FramesColorNumber: Number of frames that have a Color Palette
FramesGrayscaleNumber: Number of GrayScale Frames
FramesBlackWhiteNumber: Number of B&W Frames
List<Frames>: Class List of all frames. The FramesInfo Class object Exposes these properties:
FrameSize: Size of the Frame
FrameDpi: DpiX and DpiY of the Frame
PixelFormat: PixelFormat of the Frame
IsColorFrame: The frame has a Color Palette
IsGrayScaleFrame: The frame has a GrayScale Palette
IsBlackWhiteFrame: The frame has a B&W Palette
public System.Drawing.Bitmap ThumbnailToBitmap()
Converts a System.Windows.Media.Imaging BitmapImage in a System.Drawing Bitmap format that can be used in WinForms Controls/Classes. (Not properly tested at this time).
Sample usage:
The main class, ImagingBitmapInfo, is initialized passing to the BitmapFormatInfo() method a File Path or a File Stream.
ImagingBitmapInfo BitmapInfo = BitmapFormatInfo(@"[ImagePath]");
//or
ImagingBitmapInfo BitmapInfo = BitmapFormatInfo([FileStream]);
To verify whether the Image has a GrayScale PixelFormat, call the IsGrayScale(ImagingBitmapInfo.DeepScanOptions) method, specifying how this information must be retrieved.
ImagingBitmapInfo.DeepScanOptions.Default
The class decides, based on the Image Pixel Format, whether to perform a Deep Scan of the image Color Palette (if a Palette is present). If the Pixel Format already reports a GrayScale Image (e.g. PixelFormats.Gray32Float, PixelFormats.Gray16 etc.), a Deep scan is not performed. If the Pixel Format is an Indexed one, the scan is performed; if the PixelFormat is Color format, the scan is not performed.
Note that some Images (Gifs, mostly) may report a Color PixelFormat,
while the inner format (Palette) might be GrayScale.
ImagingBitmapInfo.DeepScanOptions.Force
Instructs to execute a Deep Scan of the Palettes of all Frames, no matter what PixelFormat is reported by the Image decoder.
Used to discover if a reported Color Image has one or more GrayScale Frames.
ImagingBitmapInfo.DeepScanOptions.Skip
Instructs to not perform a Deep scan of the Palettes, even if it would be normally performed, given the smelly Pixel Format.
System.Windows.Media.PixelFormat pixelFormat = BitmapInfo.PixelFormat;
bool BitmapIsGrayscale = BitmapInfo.IsGrayScale(ImagingBitmapInfo.DeepScanOptions.Force);
If the results are different from what is expected, a complete check of the Image Frames PixelFormat can be performed calling:
ImagingBitmapInfo.GrayScaleInfo GrayScaleFrames = BitmapInfo.IsGrayScaleFrames();
This method performs a complete check of all Frames and reports if any of the internal Frames have a GrayScale PixelFormat. The result can be one of the GrayScaleInfo enumerator values:
None, Partial, GrayScale, Undefined.
If the result is GrayScale, all internal Frames have a GrayScale PixelFormat.
Undefined means that the Image has no Palette informations.
To create a statistical representation of Grayscale similarity of an Image Palettes' Color entries, call the GrayScaleSimilarity() method:
ImagingBitmapInfo.GrayScaleStats Stats = BitmapInfo.GrayScaleSimilarity();
float GrayScalePercent = Stats.GrayScalePercent
float RGBAverageDistancePercent = Stats.GrayScaleAveragePercent
float RGBPatternMaxDistance = Stats.AverageMaxDistance
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;
public class ImagingBitmapInfo
{
Dictionary<string, string> ImgTypeLongNames;
readonly FramesInfo framesInfo = new FramesInfo();
public ImagingBitmapInfo(FileStream stream)
{
FillLongNameTable();
var coder = BitmapDecoder.Create(
stream,
BitmapCreateOptions.PreservePixelFormat,
BitmapCacheOption.Default);
BitmapSource source = coder.Frames[0];
var metadata = (BitmapMetadata)source.Metadata;
try {
ImageType = ImgTypeLongNames[metadata.Format.ToUpperInvariant()];
Metadata = new MetadataInfo(metadata);
}
catch (NotSupportedException) {
Metadata = null;
IsMetadataSupported = false;
}
Frames = coder.Frames.Count();
if (Frames > 0) FrameSourceAddRange(coder.Frames.ToArray());
Animated = source.HasAnimatedProperties;
AnimationSupported = coder.CodecInfo.SupportsAnimation;
BitsPerPixel = source.Format.BitsPerPixel;
Dpi = new Size((float)source.DpiX, (float)source.DpiY);
HasPalette = ((source.Palette != null) && (source.Palette.Colors.Count > 0)) ? true : false;
ImageSize = new Size((float)source.Height, (float)source.Width);
Masks = source.Format.Masks.ToList();
Palette = source.Palette;
PixelFormat = source.Format;
PixelSize = new Size(source.PixelHeight, source.PixelWidth);
HasThumbnail = coder.Thumbnail != null;
if (HasThumbnail) {
Thumbnail = (BitmapImage)coder.Thumbnail.CloneCurrentValue();
}
}
public bool Animated { get; }
public bool AnimationSupported { get; }
public int BitsPerPixel { get; }
public Size Dpi { get; }
public int Frames { get; }
public FramesInfo FramesContent => framesInfo;
public bool HasPalette { get; }
public bool HasThumbnail { get; }
public Size ImageSize { get; }
public string ImageType { get; }
public bool IsMetadataSupported { get; } = true;
public List<PixelFormatChannelMask> Masks { get; }
public MetadataInfo Metadata { get; }
public BitmapPalette Palette { get; }
public PixelFormat PixelFormat { get; }
public Size PixelSize { get; }
public BitmapImage Thumbnail { get; }
public enum DeepScanOptions : int
{
Default = 0,
Skip,
Force
}
public enum GrayScaleInfo : int
{
None = 0,
Partial,
GrayScale,
Undefined
}
private void FillLongNameTable()
{
ImgTypeLongNames = new Dictionary<string, string>
{
{ "GIF", "Unisis Graphic Interchange Format (GIF)" },
{ "JPG", "Joint Photographics Experts Group JFIF/JPEG" },
{ "PNG", "Portable Network Graphics (PNG)" },
{ "TIFF", "Tagged Image File Format (TIFF)" },
{ "BMP", "Windows Bitmap Format (BMP)" },
{ "WMP", "Windows Media Photo File (WMP)" },
{ "ICO", "Windows Icon (ICO)" }
};
}
public string GetFormatLongName(string format) => ImgTypeLongNames[format];
public class MetadataInfo {
public MetadataInfo(BitmapMetadata metadata) {
ApplicationName = metadata.ApplicationName;
Author = metadata.Author?.ToList();
Copyright = metadata.Copyright;
CameraManufacturer = metadata.CameraManufacturer;
CameraModel = metadata.CameraModel;
CameraModel = metadata.Comment;
DateTaken = metadata.DateTaken;
Format = metadata.Format;
Rating = metadata.Rating;
Subject = metadata.Subject;
Title = metadata.Title;
}
public string ApplicationName { get; }
public List<string> Author { get; }
public string Copyright { get; }
public string CameraManufacturer { get; }
public string CameraModel { get; }
public string Comment { get; }
public string DateTaken { get; }
public string Format { get; }
public int Rating { get; }
public string Subject { get; }
public string Title { get; }
}
public System.Drawing.Bitmap ThumbnailToBitmap()
{
if (Thumbnail == null) return null;
var bitmap = new System.Drawing.Bitmap(Thumbnail.DecodePixelWidth, Thumbnail.DecodePixelHeight);
var stream = new MemoryStream();
BitmapEncoder encoder = new BmpBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(Thumbnail));
encoder.Save(stream);
return (System.Drawing.Bitmap)System.Drawing.Image.FromStream(stream);
}
public void FrameSourceAddRange(BitmapFrame[] bitmapFrames)
{
if (bitmapFrames == null) return;
framesInfo.Frames.AddRange(bitmapFrames.Select(bf => new FramesInfo.Frame()
{
Palette = bf.Palette,
FrameSize = new Size(bf.PixelWidth, bf.PixelHeight),
FrameDpi = new Size(bf.DpiX, bf.DpiY),
PixelFormat = bf.Format,
IsGrayScaleFrame = CheckIfGrayScale(bf.Format, bf.Palette, DeepScanOptions.Force),
IsBlackWhiteFrame = bf.Format == PixelFormats.BlackWhite
}));
framesInfo.Frames.Where(f => (!f.IsGrayScaleFrame & !f.IsBlackWhiteFrame)).All(f => f.IsColorFrame);
}
public GrayScaleInfo IsGrayScaleFrames()
{
if (framesInfo.Frames.Count == 0) return GrayScaleInfo.Undefined;
if (framesInfo.FramesGrayscaleNumber > 0) {
return (framesInfo.FramesGrayscaleNumber == framesInfo.FramesTotalNumber)
? GrayScaleInfo.GrayScale
: GrayScaleInfo.Partial;
}
return GrayScaleInfo.None;
}
public bool IsGrayScale(DeepScanOptions DeepScan) => CheckIfGrayScale(PixelFormat, Palette, DeepScan);
private bool CheckIfGrayScale(PixelFormat pixelFormat, BitmapPalette palette, DeepScanOptions DeepScan)
{
if (pixelFormat == PixelFormats.Gray32Float ||
pixelFormat == PixelFormats.Gray16 ||
pixelFormat == PixelFormats.Gray8 ||
pixelFormat == PixelFormats.Gray4 ||
pixelFormat == PixelFormats.Gray2)
{
if (palette == null || (DeepScan != DeepScanOptions.Force)) { return true; }
}
if (pixelFormat == PixelFormats.Indexed8 ||
pixelFormat == PixelFormats.Indexed4 ||
pixelFormat == PixelFormats.Indexed2)
{
DeepScan = (DeepScan != DeepScanOptions.Skip) ? DeepScanOptions.Force : DeepScan;
}
if ((DeepScan != DeepScanOptions.Skip) & palette != null)
{
List<Color> indexedColors = palette.Colors.ToList();
return indexedColors.All(rgb => (rgb.R == rgb.G && rgb.G == rgb.B && rgb.B == rgb.R));
}
return false;
}
public GrayScaleStats GrayScaleSimilarity()
{
if (!HasPalette) return null;
return new GrayScaleStats(framesInfo.Frames);
}
public class GrayScaleStats
{
public GrayScaleStats(IEnumerable<FramesInfo.Frame> frames) {
float accumulatorMax = 0F;
float accumulatorMin = 0F;
float accumulatorAvg = 0F;
float[] distance = new float[3];
Palettes = frames.Count();
foreach (FramesInfo.Frame frame in frames) {
foreach (Color pEntry in frame.Palette.Colors) {
if (!(pEntry.R == pEntry.G && pEntry.G == pEntry.B && pEntry.B == pEntry.R)) {
distance[0] = Math.Abs(pEntry.R - pEntry.G);
distance[1] = Math.Abs(pEntry.G - pEntry.B);
distance[2] = Math.Abs(pEntry.B - pEntry.R);
accumulatorMax += distance.Max();
accumulatorMin += distance.Min();
accumulatorAvg += distance.Average();
}
}
int colorEntries = frame.Palette.Colors.Count;
var distanceAverage = (float)((accumulatorAvg / 2.56) / colorEntries);
var distanceMax = (float)((accumulatorMax / 2.56) / colorEntries);
var distanceMin = (float)((accumulatorMin / 2.56) / colorEntries);
var framestat = new FrameStat(colorEntries, distanceAverage, distanceMax, distanceMin);
PerFrameValues.Add(framestat);
accumulatorAvg = 0F;
accumulatorMax = 0F;
accumulatorMin = 0F;
}
AverageLogDistance = PerFrameValues.Average(avg => avg.DistanceAverage);
AverageMaxDistance = PerFrameValues.Max(mx => mx.DistanceMax);
AverageMinDistance = PerFrameValues.Min(mn => mn.DistanceMin);
GrayScaleAveragePercent = 100F - AverageLogDistance;
GrayScalePercent = 100F - ((AverageMaxDistance - AverageMinDistance) / 2);
}
public float AverageMaxDistance { get; }
public float AverageMinDistance { get; }
public float AverageLogDistance { get; }
public float GrayScalePercent { get; }
public float GrayScaleAveragePercent { get; }
public int Palettes { get; }
public List<FrameStat> PerFrameValues { get; } = new List<FrameStat>();
public class FrameStat
{
public FrameStat(int entries, float average, float max, float min) {
ColorEntries = entries;
DistanceAverage = average;
DistanceMax = max;
DistanceMin = min;
}
public int ColorEntries { get; private set; }
public float DistanceAverage { get; private set; }
public float DistanceMax { get; private set; }
public float DistanceMin { get; private set; }
}
}
public class FramesInfo
{
public FramesInfo() => Frames = new List<Frame>();
public int FramesTotalNumber
{
get => (Frames != null) ? Frames.Count() : 0;
private set { }
}
public int FramesColorNumber
{
get => (Frames != null) ? Frames.Where(f => f.IsColorFrame == true).Count() : 0;
private set { }
}
public int FramesGrayscaleNumber
{
get => (Frames != null) ? Frames.Where(f => f.IsGrayScaleFrame == true).Count() : 0;
private set { }
}
public int FramesBlackWhiteNumber
{
get => (Frames != null) ? Frames.Where(f => f.IsBlackWhiteFrame == true).Count() : 0;
private set { }
}
public List<Frame> Frames { get; private set; }
public class Frame
{
public BitmapPalette Palette { get; set; }
public Size FrameSize { get; set; }
public Size FrameDpi { get; set; }
public PixelFormat PixelFormat { get; set; }
public bool IsColorFrame { get; set; }
public bool IsGrayScaleFrame { get; set; }
public bool IsBlackWhiteFrame { get; set; }
}
}
}
public static ImagingBitmapInfo BitmapPixelFormat(string FileName)
{
using (var stream = new FileStream(FileName, FileMode.Open, FileAccess.Read, FileShare.None)) {
return BitmapPixelFormat(stream);
}
}
public static ImagingBitmapInfo BitmapPixelFormat(FileStream stream) => new ImagingBitmapInfo(stream);
