Image auto-orient with Tesseract and ImageMagick

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using ImageMagick;
using Tesseract;

namespace JRD.Imaging
{
    #region Imaging Command Interfaces
    /// <summary>
    /// Defines an interface for command options.
    /// </summary>
    public interface IPreprocessOptions
    {
        /// <summary>
        /// Extracts serialized option data.
        /// </summary>
        /// <param name="serializedValue">The serialized option data.</param>
        void Load(string serializedValue);

        /// <summary>
        /// Gets the current option data as a serialized string.
        /// </summary>
        string Settings { get; }
    }

    /// <summary>
    /// Defines an interface for image preprocessing commands.
    /// </summary>
    public interface IPreprocess
    {
        /// <summary>
        /// Runs the command on an image stream with the provided options.
        /// </summary>
        /// <param name="image">The image stream being processed.</param>
        /// <param name="options">Command-specific options for the command.</param>
        /// <returns>The processed image in a new stream.</returns>
        MemoryStream Run(Stream image, IPreprocessOptions options);
    }
    #endregion

    #region Imaging Command Options
    public abstract class CommandOptions : IPreprocessOptions, INotifyPropertyChanged
    {
        /// <summary>
        /// Gets a serialized string representation of the options object.
        /// </summary>
        public virtual string Settings
        {
            get { return ToString(); }
        }
        /// <summary>
        /// Represents an event that is raised when a property in the object changes.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged = delegate { };

        /// <summary>
        /// Fires the PropertyChanged event.
        /// </summary>
        /// <param name="propertyName">Name of the property being changed.</param>
        protected void OnPropertyChanged(string propertyName)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }

        /// <summary>
        /// Deserializes the provided string into the current options object.
        /// </summary>
        /// <param name="serializedValue">A serialized string corresponding to the result of ToString().</param>
        public virtual void Load(string serializedValue)
        {
            // No work to do
        }

        #region Miscellaneous Helpers
        /// <summary>
        /// Convenience method for extracting a configuration setting from the settings collection.
        /// </summary>
        /// <typeparam name="T">Desired type after parsing the setting.</typeparam>
        /// <param name="settings">The settings collection.</param>
        /// <param name="key">The key name for the desired setting.</param>
        /// <param name="defaultOnEmpty">Value to return if the setting has no value.</param>
        /// <param name="parseSetting">Action for parsing a setting value string to the desired type.</param>
        /// <returns>The parsed setting value, or defaultOnEmpty if the setting had no value.</returns>
        protected T GetSetting<T>(List<KeyValuePair<string, string>> settings, string key, T defaultOnEmpty, Func<string, T> parseSetting)
        {
            var setting = settings.Find(s => s.Key.Equals(key, StringComparison.InvariantCultureIgnoreCase));
            var empty = default(KeyValuePair<string, string>);

            if (setting.Equals(empty))
            {
                return defaultOnEmpty;
            }
            else
            {
                return parseSetting(setting.Value);
            }
        }
        #endregion
    }

    /// <summary>
    /// Represents rotation options for the Rotate command.
    /// </summary>
    public class RotateOptions : CommandOptions
    {
        #region Private Fields
        private double _angle = 180.0;
        #endregion

        #region Public Properties
        /// <summary>
        /// Gets or sets the rotation angle in degrees.
        /// </summary>
        public double Angle
        {
            get { return _angle; }
            set
            {
                _angle = value;
                OnPropertyChanged("Angle");
                OnPropertyChanged("Settings");
            }
        }
        #endregion

        #region Overrides
        /// <summary>
        /// Returns a string representation of the object.
        /// </summary>
        /// <returns>The string representation of the object.</returns>
        public override string ToString()
        {
            return "Angle=" + Angle + ";" + base.ToString();
        }
        #endregion

        /// <summary>
        /// Deserializes the provided string into the current options object.
        /// </summary>
        /// <param name="serializedValue">A serialized string corresponding to the result of ToString().</param>
        public override void Load(string serializedValue)
        {
            base.Load(serializedValue);

            var settings = NameValueSettingsParser.SplitString(serializedValue);

            Angle = GetSetting<double>(settings, "Angle", 180.0, x => double.Parse(x));
        }
    }

    /// <summary>
    /// Represents options for the AutoOrient command.
    /// </summary>
    public class AutoOrientOptions : CommandOptions
    {
        // All work done in the base class
    }
    #endregion

    #region Imaging Commands
    /// <summary>
    /// Performs multi page rotation on supported images.
    /// </summary>
    public class Rotate : IPreprocess
    {
        /// <summary>
        /// Runs the command on the provided image.
        /// </summary>
        /// <param name="image">A stream representing the image bytes.</param>
        /// <param name="options">Corresponding options for the command.</param>
        /// <returns>A stream of bytes representing the result image after processing.</returns>
        public MemoryStream Run(Stream image, IPreprocessOptions options)
        {
            if (!(options is RotateOptions))
            {
                throw new ArgumentException("RotateOptions expected");
            }

            var opt = options as RotateOptions;
            var ms = new MemoryStream();

            image.Seek(0, SeekOrigin.Begin);

            using (var frames = new MagickImageCollection(image))
            {
                foreach (var frame in frames)
                {
                    frame.Rotate(opt.Angle);
                }

                frames.RePage();
                frames.Write(ms);
            }

            return ms;
        }
    }

    /// <summary>
    /// Performs auto-orientation on supported images.
    /// </summary>
    public class AutoOrient : IPreprocess
    {
        /// <summary>
        /// Runs the command on the provided image.
        /// </summary>
        /// <param name="image">A stream representing the image bytes.</param>
        /// <param name="options">Corresponding options for the command.</param>
        /// <returns>A stream of bytes representing the result image after processing.</returns>
        public MemoryStream Run(Stream image, IPreprocessOptions options)
        {
            if (!(options is AutoOrientOptions))
            {
                throw new ArgumentException("AutoOrientOptions expected");
            }

            image.Seek(0, SeekOrigin.Begin);

            var angle = 0;

            using (var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default))
            {
                // Enable orientation detection
                engine.DefaultPageSegMode = PageSegMode.AutoOsd;

                using (var file = Pix.LoadTiffFromMemory(ImageTools.GetBytes(image)))
                {
                    using (var page = engine.Process(file))
                    {
                        using (var layout = page.AnalyseLayout())
                        {
                            switch (layout.GetProperties().Orientation)
                            {
                                case Orientation.PageDown:
                                    angle = -180;
                                    break;
                                case Orientation.PageLeft:
                                    angle = 90;
                                    break;
                                case Orientation.PageRight:
                                    angle = -90;
                                    break;
                            }
                        }
                    }
                }
            }

            return new Rotate().Run(image, new RotateOptions() { Angle = angle });
        }
    }
    #endregion

    #region Helpers
    /// <summary>
    /// Provides non-command image tools.
    /// </summary>
    public static class ImageTools
    {
        /// <summary>
        /// Converts a stream to its corresponding byte array.
        /// </summary>
        /// <param name="source">The source stream.</param>
        /// <returns>The extracted content byte array.</returns>
        public static byte[] GetBytes(Stream source)
        {
            byte[] bytes;

            source.Seek(0, SeekOrigin.Begin);
            bytes = new byte[source.Length];
            source.Read(bytes, 0, bytes.Length);

            return bytes;
        }
    }
    /// <summary>
    /// Provides utilities for working with serialized name-value setting pairs.
    /// </summary>
    public class NameValueSettingsParser
    {
        /// <summary>
        /// Takes a settings serialized string and returns a list of key-value pairs with the settings.
        /// </summary>
        /// <param name="settings">String that follows the "name1=value1;name2=value2" format.</param>
        /// <param name="settingSplitChar">Default of a semicolon separating individual settings.</param>
        /// <param name="valueSplitChar">Default of an equal sign separting the name from the value of a setting.</param>
        /// <returns>A list of extracted key-value pairs.</returns>
        public static List<KeyValuePair<string, string>> SplitString(string settings, char settingSplitChar = ';', char valueSplitChar = '=')
        {
            var ret = new List<KeyValuePair<string, string>>();

            if (string.IsNullOrEmpty(settings))
            {
                return ret;
            }

            var itemSep = new char[] { settingSplitChar };
            var pairSep = new char[] { valueSplitChar };

            foreach (var item in settings.Split(itemSep, StringSplitOptions.RemoveEmptyEntries))
            {
                var setting = item.Split(pairSep, StringSplitOptions.RemoveEmptyEntries);

                if (setting.Length == 2)
                {
                    ret.Add(new KeyValuePair<string, string>(setting[0], setting[1]));
                }
            }

            return ret;
        }
    }
    #endregion
}