Inverse of average color

[ChuckSavage]

Hi,

I've come up with the following to inverse the average color of an image. From googling how to with ImageMagick, I saw on StackOverflow with the command line version to resize to 1,1. So I did that, then borrowing from discussion #699, I get the mean. Though in that instance they were looking for brightness. In test, I did get the pixel colors and average them and got the same value as the mean, so I'm guessing its accurate.

Anyway, I then get the HSL, invert the color via what I saw on StackOverflow, then convert back to color. Then from there to a WPF color.

Is this the best method for all of the above?

ushort mean;
using (ImageMagick.MagickImage image = new ImageMagick.MagickImage(ci.TempFile ?? ci.File))
{
    // Get average color (mean?)
    image.Resize(1, 1);
    mean = (ushort)image.Statistics().Composite().Mean;
}
ImageMagick.IMagickColor<ushort> color = new ImageMagick.MagickColor(mean, mean, mean);
// invert the color
var hsl = ImageMagick.ColorHSL.FromMagickColor(color);
hsl.Hue = (hsl.Hue + 180) % 360; // invert color
// convert to WPF solid color
color = hsl.ToMagickColor();
// var rgb = ImageMagick.ColorRGB.FromMagickColor(color); // doesn't include alpha
var bytes = color.ToByteArray(); // RGBA
var wpfBrushColor = new SolidColorBrush(Color.FromArgb(bytes[3], bytes[0], bytes[1], bytes[2]));

[ChuckSavage]

I did create this ToColorARGB extension method just now to make it a little more friendly if you want to incorporate it

public static class ImageMagickExtensions
{
    [DebuggerDisplay("Alpha({Alpha}), Red({Red}), Green({Green}), Blue({Blue})")]
    public struct ARGB
    {
        public byte Alpha;
        public byte Red;
        public byte Green;
        public byte Blue;
        public IMagickColor<ushort> Color;
    }

    public static ARGB ToColorARGB(this IMagickColor<ushort> color)
    {
        var bytes = color.ToByteArray(); // RGBA
        return new ARGB()
        {
            Alpha = bytes[3],
            Red = bytes[0],
            Green = bytes[1],
            Blue = bytes[2],
            Color = color
        };
    }
}

[ChuckSavage]

Hmm, is this issue? - I'm finding that the Hue from the mean > MagicColor > ColorHSL is always zero, same with lightness. So my end color is always a varying light gray, not my goal.

[ChuckSavage]

Okay, instead of using the mean, I knew there was color info in the single pixel I resized to, and tried that. It seemed to do the trick, and the final result is as follows. The math part of the invert color I realize could be about any number than 360, but that was what I'd seen in an example on Stackoverflow.

ImageMagick.IMagickColor<ushort> color;
using (ImageMagick.MagickImage image = new ImageMagick.MagickImage(ci.TempFile ?? ci.File))
{
    // Get average color
    image.Resize(1, 1);
    color = image.GetPixels().First().ToColor();
}

// invert the color
var hsl = ImageMagick.ColorHSL.FromMagickColor(color);
var hue360 = hsl.Hue * 360;
hue360 = (hue360 + 180) % 360;
hsl.Hue = hue360 / 360;

// Brighten the result
hsl.Saturation = 1;
if (hsl.Lightness < 0.85)
    hsl.Lightness = 0.85;

// convert to WPF solid color
var rgb = hsl.ToMagickColor().ToColorARGB();
var wpfBrushColor = new SolidColorBrush(Color.FromArgb(rgb.Alpha, rgb.Red, rgb.Green, rgb.Blue));

[ChuckSavage]

Edit: apparently the problem is in my cast of (byte)ushort is messing up the values. Trying to research the proper way of doing that now. (Maybe %255 it?)

Take the rest of this with a grain of salt.

---

I'm finding the recommended suggestion of getting the average color with image.Resize(1,1) to be wildly inaccurate. For an image like this, (this is the thumbnail) I get yellow. It has yellow, but I wouldn't say it was anywhere close to the average of it.

Yellow values in ARGB = 255, 242, 217, 125

This one is considered a dark blue: 255, 34, 54, 157

This one - light green: 255, 185, 241, 126

My code:

using (ImageMagick.MagickImage image = new ImageMagick.MagickImage(CurrentImage.File))
{
    image.Resize(1, 1);
    averageColor = image.GetPixels().First().ToColor();
    CurrentImage.AverageColor = new ARGB(averageColor);
}

And my updated ARGB class:

using System.Diagnostics;
using ImageMagick;

namespace SeaRisen.FrameITLib.Models
{
    [DebuggerDisplay("Alpha({Alpha}), Red({Red}), Green({Green}), Blue({Blue})")]
    public class ARGB
    {
        public byte Alpha
        {
            get { return (byte)Color.A; }
            set { Color.A = value; }
        }
        public byte Red
        {
            get { return (byte)Color.R; }
            set { Color.R = value; }
        }
        public byte Green
        {
            get { return (byte)Color.G; }
            set { Color.G = value; }
        }
        public byte Blue
        {
            get { return (byte)Color.B; }
            set { Color.B = value; }
        }
        public readonly IMagickColor<ushort> Color;

        public ARGB() { }

        public ARGB(byte alpha, byte red, byte green, byte blue)
        {
            Color = MagickColor.FromRgba(red, green, blue, alpha);
        }

        public ARGB(IMagickColor<ushort> color)
        {
            Color = color;
        }

        public override string ToString()
        {
            return $"{Alpha}, {Red}, {Green}, {Blue}";
        }

        /// <summary>
        /// "{Alpha}, {Red}, {Green}, {Blue}" to ARGB
        /// </summary>
        /// <param name="rgbString"></param>
        /// <returns></returns>
        public static ARGB FromString(string rgbString)
        {
            if (string.IsNullOrWhiteSpace(rgbString))
                return null;

            byte B(string b) { return byte.Parse(b?.Trim() ?? "0"); }

            var bytes = rgbString.Split(',');
            if (bytes.Length != 4) return null;
            return new ARGB(B(bytes[0]), B(bytes[1]), B(bytes[2]), B(bytes[3]));
        }

        public override int GetHashCode()
        {
            return ToString().GetHashCode();
        }

        public override bool Equals(object obj)
        {
            if (obj is ARGB rgb)
                return Alpha == rgb.Alpha &&
                       Red == rgb.Red &&
                       Green == rgb.Green &&
                       Blue == rgb.Blue;
            return false;
        }

        public static bool operator ==(ARGB a, ARGB b)
        {
            if (a is null)
                return b is null;
            return a.Equals(b);
        }

        public static bool operator !=(ARGB a, ARGB b)
        {
            return !(a == b);
        }
    }
}

[ChuckSavage]

Think I have it all figured out, and my ARGB class handles all the brains of it.

The code to compute the average, as before unchanged:

using (ImageMagick.MagickImage image = new ImageMagick.MagickImage(ci.File))
{
    image.Resize(1, 1);
    averageColor = image.GetPixels().First().ToColor();
    ciARGB = ci.AverageColor = new ARGB(averageColor);
}
var argbInverse = ciARGB.Inverse();

The ARGB class. I find the converting to and from ushort and byte to be tedious but once it works, it works. I tried an Invert(max - value), it does something, but the Inverse of the hue, saturation and lightness is better.

using System;
using System.Diagnostics;
using ImageMagick;

namespace SeaRisen.FrameITLib.Models
{
    [DebuggerDisplay("Alpha({Alpha}), Red({Red}), Green({Green}), Blue({Blue})")]
    public class ARGB
    {
        public byte Alpha
        {
            get { return (byte)(Color.A / 256); }
            set { Color.A = (ushort)(value * 256); }
        }
        public byte Red
        {
            get { return (byte)(Color.R / 256); }
            set { Color.R = (ushort)(value * 256); }
        }
        public byte Green
        {
            get { return (byte)(Color.G / 256); }
            set { Color.G = (ushort)(value * 256); }
        }
        public byte Blue
        {
            get { return (byte)(Color.B / 256); }
            set { Color.B = (ushort)(value * 256); }
        }
        public readonly IMagickColor<ushort> Color;

        public ARGB() : this(0, 0, 0, 0) { }

        public ARGB(byte alpha, byte red, byte green, byte blue)
        {
            Color = MagickColor.FromRgba(red, green, blue, alpha);
        }

        public ARGB(IMagickColor<ushort> color)
        {
            Color = new MagickColor(color);
        }

        public ARGB(System.Windows.Media.Color color)
            : this(color.A, color.R, color.G, color.B)
        {
        }

        public ARGB(ARGB argb)
            : this(argb.Color)
        {
        }

        public ARGB Clone() => new ARGB(Color);

        /// <summary>
        /// Invert the color (max - color). The Invert of an invert is the original color.
        /// </summary>
        /// <param name="argb"></param>
        /// <returns></returns>
        public static ARGB Invert(ARGB argb)
        {
            var rgb = new ARGB();
            rgb.Color.A = argb.Color.A;
            rgb.Color.R = (ushort)(ushort.MaxValue - argb.Color.R);
            rgb.Color.G = (ushort)(ushort.MaxValue - argb.Color.G);
            rgb.Color.B = (ushort)(ushort.MaxValue - argb.Color.B);
            return rgb;
        }

        /// <summary>
        /// Invert the color (max - color). The Invert of an invert is the original color.
        /// </summary>
        public ARGB Invert() => Invert(this);

        /// <summary>
        /// Inverse the color (hue + 180, 1 - saturation, 1 - lightness). The Inverse of an inverse is the original color.
        /// </summary>
        public static ARGB Inverse(ARGB argb)
        {
            // seems to be a bug, hsl modifications affect the original color - hence the new MagickColor
            var hsl = ColorHSL.FromMagickColor(new MagickColor(argb.Color));
            //var hslReverse = hsl.ToMagickColor().ToColorARGB(); // test that the reverse of hsl is the same color
            //if (hslReverse != argb)
            //    throw new Exception("Reverse of HSL invalid");

            double temp = hsl.Hue * 360;
            temp = (temp + 180) % 360; // inverse the hue
            hsl.Hue = temp / 360;
            hsl.Saturation = 1 - hsl.Saturation;
            hsl.Lightness = 1 - hsl.Lightness;
            return hsl.ToMagickColor().ToColorARGB();
        }

        /// <summary>
        /// Inverse the color (hue + 180, 1 - saturation, 1 - lightness). The Inverse of an inverse is the original color.
        /// </summary>
        public ARGB Inverse() => Inverse(this);

        /// <summary>
        /// To a System.Windows.Media.Color 
        /// </summary>
        /// <returns></returns>
        public System.Windows.Media.Color ToColorWPF()
        {
            return System.Windows.Media.Color.FromArgb(Alpha, Red, Green, Blue);
        }

        public override string ToString()
        {
            return $"{Alpha}, {Red}, {Green}, {Blue}";
        }

        /// <summary>
        /// "{Alpha}, {Red}, {Green}, {Blue}" to ARGB
        /// </summary>
        /// <param name="rgbString"></param>
        /// <returns></returns>
        public static ARGB FromString(string rgbString)
        {
            if (string.IsNullOrWhiteSpace(rgbString))
                return null;

            byte B(string b) { return byte.Parse(b?.Trim() ?? "0"); }

            var bytes = rgbString.Split(',');
            if (bytes.Length != 4) return null;
            return new ARGB(B(bytes[0]), B(bytes[1]), B(bytes[2]), B(bytes[3]));
        }

        public override int GetHashCode()
        {
            return ToString().GetHashCode();
        }

        public override bool Equals(object obj)
        {
            if (obj is ARGB rgb)
                return Alpha == rgb.Alpha &&
                       Red == rgb.Red &&
                       Green == rgb.Green &&
                       Blue == rgb.Blue;
            return false;
        }

        public static bool operator ==(ARGB a, ARGB b)
        {
            if (a is null)
                return b is null;
            return a.Equals(b);
        }

        public static bool operator !=(ARGB a, ARGB b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Average two ARGB values
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public static ARGB operator +(ARGB a, ARGB b)
        {
            var rgb = new ARGB();
            rgb.Color.A = (ushort)((a.Color.A + b.Color.A) / 2);
            rgb.Color.R = (ushort)((a.Color.R + b.Color.R) / 2);
            rgb.Color.G = (ushort)((a.Color.G + b.Color.G) / 2);
            rgb.Color.B = (ushort)((a.Color.B + b.Color.B) / 2);
            return rgb;
        }
    }
}

public static class ARGBExtensions
{
    public static ARGB ToColorARGB(this IMagickColor<ushort> color)
    {
        return new ARGB(color);
    }
}