BitmapSaver.cs

namespace ForestPlot
{
    using System;
    using System.Collections.Generic;
    using System.Drawing;
    using System.Drawing.Imaging;
    using Marshal = System.Runtime.InteropServices.Marshal;
    using StringBuilder = System.Text.StringBuilder;

    public static class BitmapSaver
    {
        private const int Opaque = unchecked((int)0xff000000);
        private static readonly Encoder SaveAsCMYK = new Encoder(new Guid("a219bbc9-0a9d-4005-a3ee-3a421b8bb06c"));
        private static readonly Guid TiffFormat = new Guid("557cf405-1a04-11d3-9a73-0000f81ef32e");
        private static readonly char[] semicolon = { ';' };
        private static readonly char[] asterisk = { '*' };

        public static void SaveRgb32(Bitmap rgb32, string filename, bool optimize, bool cmyk)
        {
            if (rgb32 == null)
            {
                throw new ArgumentNullException("rgb32");
            }

            if (string.IsNullOrEmpty(filename))
            {
                throw new ArgumentNullException("filename");
            }

            ImageCodecInfo codec = null;
            var extensions = new StringBuilder();

            foreach (var c in ImageCodecInfo.GetImageEncoders())
            {
                foreach (var e in c.FilenameExtension.Split(semicolon, StringSplitOptions.RemoveEmptyEntries))
                {
                    if (extensions.Length != 0)
                    {
                        extensions.Append(';');
                    }

                    extensions.Append(e);

                    if (filename.EndsWith(e.TrimStart(asterisk), StringComparison.OrdinalIgnoreCase))
                    {
                        codec = c;
                        break;
                    }
                }
            }

            if (codec == null)
            {
                throw new InvalidOperationException(
                    "Unrecognized file extension. Supported file types: " + extensions.ToString());
            }

            SaveRgb32(rgb32, filename, optimize, cmyk, codec);
        }

        public static void SaveRgb32(Bitmap rgb32, string filename, bool optimize, bool cmyk, ImageCodecInfo codec)
        {
            if (rgb32 == null)
            {
                throw new ArgumentNullException("rgb32");
            }

            if (string.IsNullOrEmpty(filename))
            {
                throw new ArgumentNullException("filename");
            }

            bool saved = false;

            if (cmyk && codec.Clsid == TiffFormat)
            {
                try
                {
                    using (var codecParameters = new EncoderParameters())
                    {
                        codecParameters.Param = new EncoderParameter[]
                            { new EncoderParameter(SaveAsCMYK, (long)1) };
                        rgb32.Save(filename, codec, codecParameters);
                        saved = true;
                    }
                }
                catch (Exception ex)
                {
                    if (Program.ExceptionIsDangerous(ex))
                    {
                        throw;
                    }

                    throw new InvalidOperationException("Unable to save CMYK on this computer: " + ex.Message);
                }
            }

            if (!saved && optimize)
            {
                try
                {
                    if (optimize)
                    {
                        try
                        {
                            using (var bmpOptimized = Optimize(rgb32))
                            {
                                if (bmpOptimized != null)
                                {
                                    bmpOptimized.Save(filename, codec, null);
                                    saved = true;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            if (Program.ExceptionIsDangerous(ex))
                            {
                                throw;
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    if (Program.ExceptionIsDangerous(ex))
                    {
                        throw;
                    }
                }
            }

            if (!saved)
            {
                rgb32.Save(filename, codec, null);
                saved = true;
            }

            return;
        }

        private static Bitmap Optimize(Bitmap rgb32)
        {
            Bitmap bmpOpt = null;

            var colorToIndex = new Dictionary<int, int>(256);

            var data32 = rgb32.LockBits(
                new Rectangle(0, 0, rgb32.Width, rgb32.Height),
                ImageLockMode.ReadOnly,
                PixelFormat.Format32bppRgb);
            IntPtr p32;
            int[] b32 = new int[data32.Stride / sizeof(int)];

            p32 = data32.Scan0;
            for (int line = 0; line < data32.Height; line++)
            {
                Marshal.Copy(p32, b32, 0, b32.Length);
                for (int i = 0; i < b32.Length; i++)
                {
                    int rgb = b32[i] & 0xffffff;
                    colorToIndex[rgb] = 0;
                }

                p32 = (IntPtr)((long)p32 + data32.Stride);
            }

            if (colorToIndex.Count == 2 &&
                colorToIndex.ContainsKey(0) &&
                colorToIndex.ContainsKey(0xffffff))
            {
                var bmp1 = new Bitmap(rgb32.Width, rgb32.Height, PixelFormat.Format1bppIndexed);
                bmp1.SetResolution(rgb32.HorizontalResolution, rgb32.VerticalResolution);
                var data1 = bmp1.LockBits(
                    new Rectangle(0, 0, bmp1.Width, bmp1.Height),
                    ImageLockMode.WriteOnly,
                    PixelFormat.Format1bppIndexed);
                IntPtr p1 = data1.Scan0;
                byte[] b1 = new byte[data1.Stride];

                p32 = data32.Scan0;
                for (int line = 0; line < data32.Height; line++)
                {
                    Marshal.Copy(p32, b32, 0, b32.Length);
                    byte b = 0;
                    for (int i = 0; i < b1.Length * 8; i++)
                    {
                        if (i < b32.Length)
                        {
                            b = unchecked((byte)((b << 1) | ((b32[i] & 0xffffff) == 0 ? 0 : 1)));
                        }
                        else
                        {
                            b <<= 1;
                        }

                        if (i % 8 == 7)
                        {
                            b1[i / 8] = b;
                        }
                    }

                    Marshal.Copy(b1, 0, p1, b1.Length);
                    p32 = (IntPtr)((long)p32 + data32.Stride);
                    p1 = (IntPtr)((long)p1 + data1.Stride);
                }

                bmp1.UnlockBits(data1);
                bmpOpt = bmp1;
            }
            else if (colorToIndex.Count <= 256)
            {
                var bmp8 = new Bitmap(rgb32.Width, rgb32.Height, PixelFormat.Format8bppIndexed);
                PreparePalette(colorToIndex, bmp8);
                bmp8.SetResolution(rgb32.HorizontalResolution, rgb32.VerticalResolution);
                var data8 = bmp8.LockBits(
                    new Rectangle(0, 0, bmp8.Width, bmp8.Height),
                    ImageLockMode.WriteOnly,
                    PixelFormat.Format8bppIndexed);
                IntPtr p8 = data8.Scan0;
                byte[] b8 = new byte[data8.Stride];

                p32 = data32.Scan0;
                for (int line = 0; line < data32.Height; line++)
                {
                    Marshal.Copy(p32, b32, 0, b32.Length);
                    for (int i = 0; i < b8.Length; i++)
                    {
                        if (i < b32.Length)
                        {
                            b8[i] = (byte)colorToIndex[b32[i] & 0xffffff];
                        }
                    }

                    Marshal.Copy(b8, 0, p8, b8.Length);
                    p32 = (IntPtr)((long)p32 + data32.Stride);
                    p8 = (IntPtr)((long)p8 + data8.Stride);
                }

                bmp8.UnlockBits(data8);
                bmpOpt = bmp8;
            }

            return bmpOpt;
        }

        private static void PreparePalette(Dictionary<int, int> colorToIndex, Bitmap bmp)
        {
            var palette = bmp.Palette;
            var entries = palette.Entries;
            var indexToColor = new int[colorToIndex.Count];
            var i = 0;
            foreach (var kv in colorToIndex)
            {
                indexToColor[i] = kv.Key;
                i++;
            }

            Array.Sort(indexToColor);
            for (i = 0; i < indexToColor.Length; i++)
            {
                entries[i] = Color.FromArgb(indexToColor[i] | Opaque);
                colorToIndex[indexToColor[i]] = i;
            }

            for (; i < entries.Length; i++)
            {
                entries[i] = Color.White;
            }

            bmp.Palette = palette;
        }
    }
}