添加颜色模式转换

Author: lindexi

src/MediaConverters/MediaConverters.Lib/Imaging/Effect/Color/ColorModeConverter.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using DotNetCampus.MediaConverters.Imaging.Effect.Extensions;
+
+namespace DotNetCampus.MediaConverters.Imaging.Effect.Color;
+
+/// <summary>
+/// 色彩模式转换器
+/// </summary>
+public static class ColorModeConverter
+{
+    /// <summary>
+    /// RGB转HSL（参数值取值范围为0-1）
+    /// 注：Windows使用的色彩模式是HSL
+    /// </summary>
+    /// <param name="r">红色[范围0-1]</param>
+    /// <param name="g">绿色[范围0-1]</param>
+    /// <param name="b">蓝色[范围0-1]</param>
+    /// <returns> 色相[范围0-1]， 饱和度[范围0-1]， 明度[范围0-1]</returns>
+    public static (float hue, float saturation, float brightness) RgbToHsl(float r, float g, float b)
+    {
+        var max = Math.Max(Math.Max(r, g), b);
+        var min = Math.Min(Math.Min(r, g), b);
+
+        //计算色相
+        float hue;
+        var delta = max - min;
+        if (r.AlmostEquals(max))
+            hue = (g - b) / delta;
+        else if (g.AlmostEquals(max))
+            hue = (b - r) / delta + 2f;
+        else
+            hue = (r - g) / delta + 4f;
+        hue *= 60f;
+        if (hue < 0f)
+            hue += 360f;
+
+        //计算饱和度
+        var saturation = 0f;
+        if (!r.AlmostEquals(g) || b.AlmostEquals(g))
+        {
+            var div = max + min;
+            if (div > 1f)
+                div = 1f * 2 - max - min;
+            saturation = (max - min) / div;
+        }
+
+        //计算明度
+        var brightness = (max + min) / 2;
+
+        //值归一化
+        return (hue / 360f, saturation, brightness);
+    }
+
+    /// <summary>
+    /// HSL转RBG（参数值取值范围为0-1）
+    /// 注：Windows使用的色彩模式是HSL
+    /// </summary>
+    /// <param name="hue">色相[范围0-1]</param>
+    /// <param name="saturation">饱和度[范围0-1]</param>
+    /// <param name="lightness">明度[范围0-1]</param>
+    /// <returns>红色[范围0-1]， 绿色[范围0-1]， 蓝色[范围0-1]</returns>
+    public static (float, float, float) HslToRgb(float hue, float saturation, float lightness)
+    {
+        if (saturation == 0)
+        {
+            return (lightness, lightness, lightness);
+        }
+        else
+        {
+            var q = lightness < 0.5
+                ? lightness * (1 + saturation)
+                : lightness + saturation - lightness * saturation;
+            var p = 2 * lightness - q;
+            var rgb = new[] { hue + 1 / 3f, hue, hue - 1 / 3f };
+            for (var i = 0; i < 3; i++)
+            {
+                if (rgb[i] < 0)
+                    rgb[i] += 1;
+                if (rgb[i] > 1)
+                    rgb[i] -= 1;
+                if (rgb[i] * 6 < 1)
+                {
+                    rgb[i] = p + (q - p) * 6 * rgb[i];
+                }
+                else if (rgb[i] * 2 < 1)
+                {
+                    rgb[i] = q;
+                }
+                else if (rgb[i] * 3 < 2)
+                {
+                    rgb[i] = p + (q - p) * (2 / 3f - rgb[i]) * 6;
+                }
+                else
+                    rgb[i] = p;
+            }
+
+            return (rgb[0], rgb[1], rgb[2]);
+        }
+    }
+}

src/MediaConverters/MediaConverters.Lib/Imaging/Effect/Extensions/MathExtension.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DotNetCampus.MediaConverters.Imaging.Effect.Extensions;
+
+/// <summary>
+/// 数学拓展方法
+/// </summary>
+[SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
+internal static class MathExtension
+{
+    /// <summary>
+    /// 比较两个double值的大小
+    /// </summary>
+    /// <param name="a"></param>
+    /// <param name="b"></param>
+    /// <param name="epsilon"></param>
+    /// <returns></returns>
+    public static bool AlmostEquals(this double a, double b, double epsilon = 0.00001)
+    {
+        if (double.IsNaN(a) || double.IsNaN(b))
+        {
+            return false;
+        }
+
+        if (double.IsPositiveInfinity(a) || double.IsPositiveInfinity(b))
+        {
+            return a == b;
+        }
+
+        if (double.IsNegativeInfinity(a) || double.IsNegativeInfinity(b))
+        {
+            return a == b;
+        }
+
+        return Math.Abs(a - b) < epsilon;
+    }
+
+
+    /// <summary>
+    /// 比较两个float值的大小
+    /// </summary>
+    /// <param name="a"></param>
+    /// <param name="b"></param>
+    /// <param name="epsilon"></param>
+    /// <returns></returns>
+    public static bool AlmostEquals(this float a, float b, float epsilon = 0.00001f)
+    {
+        if (float.IsNaN(a) || float.IsNaN(b))
+        {
+            return false;
+        }
+
+        if (float.IsPositiveInfinity(a) || float.IsPositiveInfinity(b))
+        {
+            return a == b;
+        }
+
+        if (float.IsNegativeInfinity(a) || float.IsNegativeInfinity(b))
+        {
+            return a == b;
+        }
+
+        return Math.Abs(a - b) < epsilon;
+    }
+
+    /// <summary>
+    /// 矩阵乘法
+    /// </summary>
+    /// <param name="a"></param>
+    /// <param name="b"></param>
+    /// <returns></returns>
+    /// <exception cref="Exception"></exception>
+    public static float[,] MultiplyMatrices(float[,] a, float[,] b)
+    {
+        var aRows = a.GetLength(0);
+        var aCols = a.GetLength(1);
+        var bRows = b.GetLength(0);
+        var bCols = b.GetLength(1);
+
+        if (aCols != bRows)
+            throw new Exception("Inner matrix dimensions must match.");
+
+        var result = new float[aRows, bCols];
+
+        for (var i = 0; i < aRows; ++i)
+        {
+            for (var j = 0; j < bCols; ++j)
+            {
+                float sum = 0;
+                for (var k = 0; k < aCols; ++k)
+                {
+                    sum += (a[i, k] * b[k, j]);
+                }
+                result[i, j] = sum;
+            }
+        }
+
+        return result;
+    }
+
+}