From a2f825dde15f9c74226146338b4ee4441ee78067 Mon Sep 17 00:00:00 2001 From: Johann Dirry Date: Tue, 9 Sep 2025 20:39:01 +0200 Subject: [PATCH 1/2] Porting material-color-utilities to dotnet #2475 Backporting to .NET 462 --- Directory.packages.props | 3 + MaterialDesignToolkit.Full.sln | 19 + .../Blend/Blend.cs | 75 + .../Contrast/Contrast.cs | 194 +++ .../Dislike/DislikeAnalyzer.cs | 43 + .../DynamicColor/ColorSpec.cs | 106 ++ .../DynamicColor/ColorSpec2021.cs | 855 ++++++++++ .../DynamicColor/ColorSpec2025.cs | 1515 +++++++++++++++++ .../DynamicColor/ColorSpecs.cs | 17 + .../DynamicColor/ContrastCurve.cs | 18 + .../DynamicColor/DeltaConstraint.cs | 8 + .../DynamicColor/DynamicColor.cs | 332 ++++ .../DynamicColor/DynamicScheme.cs | 176 ++ .../DynamicColor/MaterialDynamicColors.cs | 170 ++ .../DynamicColor/Platform.cs | 7 + .../DynamicColor/SpecVersion.cs | 7 + .../DynamicColor/ToneDeltaPair.cs | 31 + .../DynamicColor/TonePolarity.cs | 13 + .../DynamicColor/Variant.cs | 14 + .../Hct/Cam16.cs | 393 +++++ .../Hct/Hct.cs | 113 ++ .../Hct/HctSolver.cs | 440 +++++ .../Hct/ViewingConditions.cs | 134 ++ .../MaterialColorUtilities.csproj | 45 + .../Palettes/CorePalette.cs | 59 + .../Palettes/CorePalettes.cs | 12 + .../Palettes/TonalPalette.cs | 172 ++ .../Quantize/PointProvider.cs | 13 + .../Quantize/PointProviderLab.cs | 45 + .../Quantize/Quantizer.cs | 6 + .../Quantize/QuantizerCelebi.cs | 21 + .../Quantize/QuantizerMap.cs | 17 + .../Quantize/QuantizerResult.cs | 3 + .../Quantize/QuantizerWsmeans.cs | 204 +++ .../Quantize/QuantizerWu.cs | 398 +++++ .../Scheme/Scheme.cs | 158 ++ .../Scheme/SchemeContent.cs | 31 + .../Scheme/SchemeExpressive.cs | 31 + .../Scheme/SchemeFidelity.cs | 31 + .../Scheme/SchemeFruitSalad.cs | 31 + .../Scheme/SchemeMonochrome.cs | 31 + .../Scheme/SchemeNeutral.cs | 31 + .../Scheme/SchemeRainbow.cs | 31 + .../Scheme/SchemeTonalSpot.cs | 31 + .../Scheme/SchemeVibrant.cs | 31 + .../Score/Score.cs | 129 ++ .../Temperature/TemperatureCache.cs | 298 ++++ .../Utils/ColorUtils.cs | 249 +++ .../Utils/MathUtils.cs | 151 ++ .../Utils/StringUtils.cs | 18 + src/Shims/MathCompat.cs | 19 + 51 files changed, 6979 insertions(+) create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Blend/Blend.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Contrast/Contrast.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Dislike/DislikeAnalyzer.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2021.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2025.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpecs.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ContrastCurve.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DeltaConstraint.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicColor.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicScheme.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/DynamicColor/MaterialDynamicColors.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/DynamicColor/Platform.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/DynamicColor/SpecVersion.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ToneDeltaPair.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/DynamicColor/TonePolarity.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/DynamicColor/Variant.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Hct/Cam16.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Hct/Hct.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Hct/HctSolver.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Hct/ViewingConditions.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/MaterialColorUtilities.csproj create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Palettes/CorePalette.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Palettes/CorePalettes.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Palettes/TonalPalette.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Quantize/PointProvider.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Quantize/PointProviderLab.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Quantize/Quantizer.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerCelebi.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerMap.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerResult.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerWsmeans.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerWu.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Scheme/Scheme.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeContent.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeExpressive.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeFidelity.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeFruitSalad.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeMonochrome.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeNeutral.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeRainbow.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeTonalSpot.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeVibrant.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Score/Score.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Temperature/TemperatureCache.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Utils/ColorUtils.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Utils/MathUtils.cs create mode 100644 src/MaterialDesign3.MaterialColorUtilities/Utils/StringUtils.cs create mode 100644 src/Shims/MathCompat.cs diff --git a/Directory.packages.props b/Directory.packages.props index 37ca871f37..8c3acea706 100644 --- a/Directory.packages.props +++ b/Directory.packages.props @@ -29,5 +29,8 @@ + + + diff --git a/MaterialDesignToolkit.Full.sln b/MaterialDesignToolkit.Full.sln index 6414dbdcc2..0e85f04106 100644 --- a/MaterialDesignToolkit.Full.sln +++ b/MaterialDesignToolkit.Full.sln @@ -63,6 +63,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MaterialDesign3Demo", "src\ EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MaterialDesignDemo.Shared", "src\MaterialDesignDemo.Shared\MaterialDesignDemo.Shared.csproj", "{B39795A7-D66A-4F2F-9F41-050838D14048}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MaterialColorUtilities", "src\MaterialDesign3.MaterialColorUtilities\MaterialColorUtilities.csproj", "{2C29B80E-1689-43CE-85AC-71799666B4AC}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -251,6 +253,22 @@ Global {B39795A7-D66A-4F2F-9F41-050838D14048}.Release|x64.Build.0 = Release|Any CPU {B39795A7-D66A-4F2F-9F41-050838D14048}.Release|x86.ActiveCfg = Release|Any CPU {B39795A7-D66A-4F2F-9F41-050838D14048}.Release|x86.Build.0 = Release|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Debug|ARM.ActiveCfg = Debug|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Debug|ARM.Build.0 = Debug|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Debug|x64.ActiveCfg = Debug|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Debug|x64.Build.0 = Debug|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Debug|x86.ActiveCfg = Debug|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Debug|x86.Build.0 = Debug|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Release|Any CPU.Build.0 = Release|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Release|ARM.ActiveCfg = Release|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Release|ARM.Build.0 = Release|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Release|x64.ActiveCfg = Release|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Release|x64.Build.0 = Release|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Release|x86.ActiveCfg = Release|Any CPU + {2C29B80E-1689-43CE-85AC-71799666B4AC}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -262,6 +280,7 @@ Global {18401177-A30E-4330-8F6B-101DF876CE99} = {55087897-5F09-45CA-8E12-12B36B45F262} {98627CBE-F009-482E-97E9-C69C7135E91F} = {D34BE232-DE51-43C1-ABDC-B69003BB50FF} {B39795A7-D66A-4F2F-9F41-050838D14048} = {D34BE232-DE51-43C1-ABDC-B69003BB50FF} + {2C29B80E-1689-43CE-85AC-71799666B4AC} = {9E303A4A-3712-44B9-91EE-830FDC087795} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {730B2F9E-74AE-46CE-9E61-89AA5C6D5DD3} diff --git a/src/MaterialDesign3.MaterialColorUtilities/Blend/Blend.cs b/src/MaterialDesign3.MaterialColorUtilities/Blend/Blend.cs new file mode 100644 index 0000000000..eb450c3718 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Blend/Blend.cs @@ -0,0 +1,75 @@ +using static System.Math; +using static MaterialColorUtilities.MathUtils; + +namespace MaterialColorUtilities; + +/// +/// Functions for blending in HCT and CAM16. +/// +public static class Blend +{ + /// + /// Blend the design color's HCT hue towards the key color's HCT hue, in a way that + /// leaves the original color recognizable and recognizably shifted towards the key color. + /// + /// ARGB representation of an arbitrary color. + /// ARGB representation of the main theme color. + /// + /// The design color with a hue shifted towards the system's color, a slightly + /// warmer/cooler variant of the design color's hue. + /// + public static int Harmonize(int designColor, int sourceColor) + { + var fromHct = Hct.FromInt(designColor); + var toHct = Hct.FromInt(sourceColor); + var differenceDegrees = DifferenceDegrees(fromHct.Hue, toHct.Hue); + var rotationDegrees = Min(differenceDegrees * 0.5, 15.0); + var outputHue = SanitizeDegreesDouble( + fromHct.Hue + rotationDegrees * RotationDirection(fromHct.Hue, toHct.Hue)); + return Hct.From(outputHue, fromHct.Chroma, fromHct.Tone).Argb; + } + + /// + /// Blends hue from one color into another. The chroma and tone of the original color are maintained. + /// + /// ARGB representation of color. + /// ARGB representation of color. + /// How much blending to perform; 0.0 >= and <= 1.0. + /// + /// with a hue blended towards . + /// Chroma and tone are constant. + /// + public static int HctHue(int from, int to, double amount) + { + var ucs = Cam16Ucs(from, to, amount); + var ucsCam = Cam16.FromInt(ucs); + var fromCam = Cam16.FromInt(from); + var blended = Hct.From(ucsCam.GetHue(), fromCam.GetChroma(), ColorUtils.LstarFromArgb(from)); + return blended.Argb; + } + + /// + /// Blend in CAM16-UCS space. + /// + /// ARGB representation of color. + /// ARGB representation of color. + /// How much blending to perform; 0.0 >= and <= 1.0. + /// + /// , blended towards . Hue, chroma, and tone will change. + /// + public static int Cam16Ucs(int from, int to, double amount) + { + var fromCam = Cam16.FromInt(from); + var toCam = Cam16.FromInt(to); + var fromJ = fromCam.GetJstar(); + var fromA = fromCam.GetAstar(); + var fromB = fromCam.GetBstar(); + var toJ = toCam.GetJstar(); + var toA = toCam.GetAstar(); + var toB = toCam.GetBstar(); + var jstar = fromJ + (toJ - fromJ) * amount; + var astar = fromA + (toA - fromA) * amount; + var bstar = fromB + (toB - fromB) * amount; + return Cam16.FromUcs(jstar, astar, bstar).ToInt(); + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Contrast/Contrast.cs b/src/MaterialDesign3.MaterialColorUtilities/Contrast/Contrast.cs new file mode 100644 index 0000000000..53f3e58681 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Contrast/Contrast.cs @@ -0,0 +1,194 @@ +using static System.Math; + +namespace MaterialColorUtilities; + +/// +/// Color science for contrast utilities. +/// +/// Utility methods for calculating contrast given two colors, or calculating a color given one +/// color and a contrast ratio. +/// +/// Contrast ratio is calculated using XYZ's Y. When linearized to match human perception, Y +/// becomes HCT's tone and L*a*b*'s' L*. +/// +public static class Contrast +{ + // The minimum contrast ratio of two colors. + // Contrast ratio equation = lighter + 5 / darker + 5, if lighter == darker, ratio == 1. + public const double RatioMin = 1.0; + + // The maximum contrast ratio of two colors. + // Contrast ratio equation = lighter + 5 / darker + 5. Lighter and darker scale from 0 to 100. + // If lighter == 100, darker = 0, ratio == 21. + public const double RatioMax = 21.0; + + public const double Ratio30 = 3.0; + public const double Ratio45 = 4.5; + public const double Ratio70 = 7.0; + + // Given a color and a contrast ratio to reach, the luminance of a color that reaches that ratio + // with the color can be calculated. However, that luminance may not contrast as desired, i.e. the + // contrast ratio of the input color and the returned luminance may not reach the contrast ratio + // asked for. + // + // When the desired contrast ratio and the result contrast ratio differ by more than this amount, + // an error value should be returned, or the method should be documented as 'unsafe', meaning, + // it will return a valid luminance but that luminance may not meet the requested contrast ratio. + // + // 0.04 selected because it ensures the resulting ratio rounds to the same tenth. + private const double ContrastRatioEpsilon = 0.04; + + // Color spaces that measure luminance, such as Y in XYZ, L* in L*a*b*, or T in HCT, are known as + // perceptually accurate color spaces. + // + // To be displayed, they must gamut map to a "display space", one that has a defined limit on the + // number of colors. Display spaces include sRGB, more commonly understood as RGB/HSL/HSV/HSB. + // Gamut mapping is undefined and not defined by the color space. Any gamut mapping algorithm must + // choose how to sacrifice accuracy in hue, saturation, and/or lightness. + // + // A principled solution is to maintain lightness, thus maintaining contrast/a11y, maintain hue, + // thus maintaining aesthetic intent, and reduce chroma until the color is in gamut. + // + // HCT chooses this solution, but, that doesn't mean it will _exactly_ matched desired lightness, + // if only because RGB is quantized: RGB is expressed as a set of integers: there may be an RGB + // color with, for example, 47.892 lightness, but not 47.891. + // + // To allow for this inherent incompatibility between perceptually accurate color spaces and + // display color spaces, methods that take a contrast ratio and luminance, and return a luminance + // that reaches that contrast ratio for the input luminance, purposefully darken/lighten their + // result such that the desired contrast ratio will be reached even if inaccuracy is introduced. + // + // 0.4 is generous, ex. HCT requires much less delta. It was chosen because it provides a rough + // guarantee that as long as a perceptual color space gamut maps lightness such that the resulting + // lightness rounds to the same as the requested, the desired contrast ratio will be reached. + private const double LuminanceGamutMapTolerance = 0.4; + + /// + /// Contrast ratio is a measure of legibility, its used to compare the lightness of two colors. + /// This method is used commonly in industry due to its use by WCAG. + /// + /// To compare lightness, the colors are expressed in the XYZ color space, where Y is lightness, + /// also known as relative luminance. + /// + /// The equation is ratio = lighter Y + 5 / darker Y + 5. + /// + public static double RatioOfYs(double y1, double y2) + { + var lighter = y1 > y2 ? y1 : y2; + var darker = (lighter == y2) ? y1 : y2; + return (lighter + 5.0) / (darker + 5.0); + } + + /// + /// Contrast ratio of two tones. T in HCT, L* in L*a*b*. Also known as luminance or perceptual + /// luminance. + /// + /// Contrast ratio is defined using Y in XYZ, relative luminance. However, relative luminance is + /// linear to number of photons, not to perception of lightness. Perceptual luminance, L* in + /// L*a*b*, T in HCT, is. Designers prefer color spaces with perceptual luminance since they're + /// accurate to the eye. + /// + /// Y and L* are pure functions of each other, so it possible to use perceptually accurate color + /// spaces, and measure contrast, and measure contrast in a much more understandable way: instead + /// of a ratio, a linear difference. This allows a designer to determine what they need to adjust a + /// color's lightness to in order to reach their desired contrast, instead of guessing & checking + /// with hex codes. + /// + public static double RatioOfTones(double t1, double t2) + { + return RatioOfYs(ColorUtils.YFromLstar(t1), ColorUtils.YFromLstar(t2)); + } + + /// + /// Returns T in HCT, L* in L*a*b* >= tone parameter that ensures ratio with input T/L*. + /// Returns -1 if ratio cannot be achieved. + /// + /// Tone return value must contrast with. + /// Desired contrast ratio of return value and tone parameter. + public static double Lighter(double tone, double ratio) + { + if (tone is < 0.0 or > 100.0) + { + return -1.0; + } + var darkY = ColorUtils.YFromLstar(tone); + var lightY = ratio * (darkY + 5.0) - 5.0; + if (lightY is < 0.0 or > 100.0) + { + return -1.0; + } + var realContrast = RatioOfYs(lightY, darkY); + var delta = Abs(realContrast - ratio); + if (realContrast < ratio && delta > ContrastRatioEpsilon) + { + return -1.0; + } + + var returnValue = ColorUtils.LstarFromY(lightY) + LuminanceGamutMapTolerance; + if (returnValue is < 0.0 or > 100.0) + { + return -1.0; + } + return returnValue; + } + + /// + /// Tone >= tone parameter that ensures ratio. 100 if ratio cannot be achieved. + /// + /// This method is unsafe because the returned value is guaranteed to be in bounds, but, the in + /// bounds return value may not reach the desired ratio. + /// + /// Tone return value must contrast with. + /// Desired contrast ratio of return value and tone parameter. + public static double LighterUnsafe(double tone, double ratio) + { + var lighterSafe = Lighter(tone, ratio); + return lighterSafe < 0.0 ? 100.0 : lighterSafe; + } + + /// + /// Returns T in HCT, L* in L*a*b* <= tone parameter that ensures ratio with input T/L*. + /// Returns -1 if ratio cannot be achieved. + /// + /// Tone return value must contrast with. + /// Desired contrast ratio of return value and tone parameter. + public static double Darker(double tone, double ratio) + { + if (tone is < 0.0 or > 100.0) + { + return -1.0; + } + var lightY = ColorUtils.YFromLstar(tone); + var darkY = ((lightY + 5.0) / ratio) - 5.0; + if (darkY is < 0.0 or > 100.0) + { + return -1.0; + } + var realContrast = RatioOfYs(lightY, darkY); + var delta = Abs(realContrast - ratio); + if (realContrast < ratio && delta > ContrastRatioEpsilon) + { + return -1.0; + } + var returnValue = ColorUtils.LstarFromY(darkY) - LuminanceGamutMapTolerance; + if (returnValue is < 0.0 or > 100.0) + { + return -1.0; + } + return returnValue; + } + + /// + /// Tone <= tone parameter that ensures ratio. 0 if ratio cannot be achieved. + /// + /// This method is unsafe because the returned value is guaranteed to be in bounds, but, the in + /// bounds return value may not reach the desired ratio. + /// + /// Tone return value must contrast with. + /// Desired contrast ratio of return value and tone parameter. + public static double DarkerUnsafe(double tone, double ratio) + { + var darkerSafe = Darker(tone, ratio); + return Max(0.0, darkerSafe); + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Dislike/DislikeAnalyzer.cs b/src/MaterialDesign3.MaterialColorUtilities/Dislike/DislikeAnalyzer.cs new file mode 100644 index 0000000000..c579d65427 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Dislike/DislikeAnalyzer.cs @@ -0,0 +1,43 @@ +using static System.Math; + +namespace MaterialColorUtilities; + +/// +/// Check and/or fix universally disliked colors. +/// +/// Color science studies of color preference indicate universal distaste for dark yellow-greens, +/// and also show this is correlated to distaste for biological waste and rotting food. +/// +/// See Palmer and Schloss, 2010 or Schloss and Palmer's Chapter 21 in Handbook of Color +/// Psychology (2015). +/// +public static class DislikeAnalyzer +{ + /// + /// Returns true if color is disliked. + /// + /// Disliked is defined as a dark yellow-green that is not neutral. + /// + public static bool IsDisliked(Hct hct) + { + var roundedHue = Round(hct.Hue); + var roundedChroma = Round(hct.Chroma); + var roundedTone = Round(hct.Tone); + + var huePasses = roundedHue is >= 90.0 and <= 111.0; + var chromaPasses = roundedChroma > 16.0; + var tonePasses = roundedTone < 65.0; + + return huePasses && chromaPasses && tonePasses; + } + + /// + /// If color is disliked, lighten it to make it likable. + /// + public static Hct FixIfDisliked(Hct hct) + { + return IsDisliked(hct) + ? Hct.From(hct.Hue, hct.Chroma, 70.0) + : hct; + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec.cs new file mode 100644 index 0000000000..0c9e5b8f15 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec.cs @@ -0,0 +1,106 @@ +namespace MaterialColorUtilities; + +public interface ColorSpec +{ + // Main Palettes + DynamicColor PrimaryPaletteKeyColor { get; } + DynamicColor SecondaryPaletteKeyColor { get; } + DynamicColor TertiaryPaletteKeyColor { get; } + DynamicColor NeutralPaletteKeyColor { get; } + DynamicColor NeutralVariantPaletteKeyColor { get; } + DynamicColor ErrorPaletteKeyColor { get; } + + // Surfaces [S] + DynamicColor Background { get; } + DynamicColor OnBackground { get; } + DynamicColor Surface { get; } + DynamicColor SurfaceDim { get; } + DynamicColor SurfaceBright { get; } + DynamicColor SurfaceContainerLowest { get; } + DynamicColor SurfaceContainerLow { get; } + DynamicColor SurfaceContainer { get; } + DynamicColor SurfaceContainerHigh { get; } + DynamicColor SurfaceContainerHighest { get; } + DynamicColor OnSurface { get; } + DynamicColor SurfaceVariant { get; } + DynamicColor OnSurfaceVariant { get; } + DynamicColor InverseSurface { get; } + DynamicColor InverseOnSurface { get; } + DynamicColor Outline { get; } + DynamicColor OutlineVariant { get; } + DynamicColor Shadow { get; } + DynamicColor Scrim { get; } + DynamicColor SurfaceTint { get; } + + // Primaries [P] + DynamicColor Primary { get; } + DynamicColor? PrimaryDim { get; } + DynamicColor OnPrimary { get; } + DynamicColor PrimaryContainer { get; } + DynamicColor OnPrimaryContainer { get; } + DynamicColor InversePrimary { get; } + + // Secondaries [Q] + DynamicColor Secondary { get; } + DynamicColor? SecondaryDim { get; } + DynamicColor OnSecondary { get; } + DynamicColor SecondaryContainer { get; } + DynamicColor OnSecondaryContainer { get; } + + // Tertiaries [T] + DynamicColor Tertiary { get; } + DynamicColor? TertiaryDim { get; } + DynamicColor OnTertiary { get; } + DynamicColor TertiaryContainer { get; } + DynamicColor OnTertiaryContainer { get; } + + // Errors [E] + DynamicColor Error { get; } + DynamicColor? ErrorDim { get; } + DynamicColor OnError { get; } + DynamicColor ErrorContainer { get; } + DynamicColor OnErrorContainer { get; } + + // Primary Fixed Colors [PF] + DynamicColor PrimaryFixed { get; } + DynamicColor PrimaryFixedDim { get; } + DynamicColor OnPrimaryFixed { get; } + DynamicColor OnPrimaryFixedVariant { get; } + + // Secondary Fixed Colors [QF] + DynamicColor SecondaryFixed { get; } + DynamicColor SecondaryFixedDim { get; } + DynamicColor OnSecondaryFixed { get; } + DynamicColor OnSecondaryFixedVariant { get; } + + // Tertiary Fixed Colors [TF] + DynamicColor TertiaryFixed { get; } + DynamicColor TertiaryFixedDim { get; } + DynamicColor OnTertiaryFixed { get; } + DynamicColor OnTertiaryFixedVariant { get; } + + // Android-only Colors + DynamicColor ControlActivated { get; } + DynamicColor ControlNormal { get; } + DynamicColor ControlHighlight { get; } + DynamicColor TextPrimaryInverse { get; } + DynamicColor TextSecondaryAndTertiaryInverse { get; } + DynamicColor TextPrimaryInverseDisableOnly { get; } + DynamicColor TextSecondaryAndTertiaryInverseDisabled { get; } + DynamicColor TextHintInverse { get; } + + // Other + DynamicColor HighestSurface(DynamicScheme s); + + // Color value calculations + Hct GetHct(DynamicScheme scheme, DynamicColor color); + double GetTone(DynamicScheme scheme, DynamicColor color); + + // Scheme Palettes + TonalPalette GetPrimaryPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel); + TonalPalette GetSecondaryPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel); + TonalPalette GetTertiaryPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel); + TonalPalette GetNeutralPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel); + TonalPalette GetNeutralVariantPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel); + TonalPalette? GetErrorPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel); +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2021.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2021.cs new file mode 100644 index 0000000000..18abb40a60 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2021.cs @@ -0,0 +1,855 @@ +namespace MaterialColorUtilities; + +public class ColorSpec2021 : ColorSpec +{ + // Main Palettes + public DynamicColor PrimaryPaletteKeyColor => new DynamicColor.Builder() + .SetName("primary_palette_key_color") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => s.PrimaryPalette.GetKeyColor().Tone) + .Build(); + + public DynamicColor SecondaryPaletteKeyColor => new DynamicColor.Builder() + .SetName("secondary_palette_key_color") + .SetPalette(s => s.SecondaryPalette) + .SetTone(s => s.SecondaryPalette.GetKeyColor().Tone) + .Build(); + + public DynamicColor TertiaryPaletteKeyColor => new DynamicColor.Builder() + .SetName("tertiary_palette_key_color") + .SetPalette(s => s.TertiaryPalette) + .SetTone(s => s.TertiaryPalette.GetKeyColor().Tone) + .Build(); + + public DynamicColor NeutralPaletteKeyColor => new DynamicColor.Builder() + .SetName("neutral_palette_key_color") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.NeutralPalette.GetKeyColor().Tone) + .Build(); + + public DynamicColor NeutralVariantPaletteKeyColor => new DynamicColor.Builder() + .SetName("neutral_variant_palette_key_color") + .SetPalette(s => s.NeutralVariantPalette) + .SetTone(s => s.NeutralVariantPalette.GetKeyColor().Tone) + .Build(); + + public DynamicColor ErrorPaletteKeyColor => new DynamicColor.Builder() + .SetName("error_palette_key_color") + .SetPalette(s => s.ErrorPalette) + .SetTone(s => s.ErrorPalette.GetKeyColor().Tone) + .Build(); + + // Surfaces [S] + public DynamicColor Background => new DynamicColor.Builder() + .SetName("background") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? 6.0 : 98.0) + .SetIsBackground(true) + .Build(); + + public DynamicColor OnBackground => new DynamicColor.Builder() + .SetName("on_background") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? 90.0 : 10.0) + .SetBackground(_ => Background) + .SetContrastCurve(_ => new ContrastCurve(3.0, 3.0, 4.5, 7.0)) + .Build(); + + public DynamicColor Surface => new DynamicColor.Builder() + .SetName("surface") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? 6.0 : 98.0) + .SetIsBackground(true) + .Build(); + + public DynamicColor SurfaceDim => new DynamicColor.Builder() + .SetName("surface_dim") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? 6.0 : new ContrastCurve(87.0, 87.0, 80.0, 75.0).Get(s.ContrastLevel)) + .SetIsBackground(true) + .Build(); + + public DynamicColor SurfaceBright => new DynamicColor.Builder() + .SetName("surface_bright") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? new ContrastCurve(24.0, 24.0, 29.0, 34.0).Get(s.ContrastLevel) : 98.0) + .SetIsBackground(true) + .Build(); + + public DynamicColor SurfaceContainerLowest => new DynamicColor.Builder() + .SetName("surface_container_lowest") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? new ContrastCurve(4.0, 4.0, 2.0, 0.0).Get(s.ContrastLevel) : 100.0) + .SetIsBackground(true) + .Build(); + + public DynamicColor SurfaceContainerLow => new DynamicColor.Builder() + .SetName("surface_container_low") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? new ContrastCurve(10.0, 10.0, 11.0, 12.0).Get(s.ContrastLevel) : new ContrastCurve(96.0, 96.0, 96.0, 95.0).Get(s.ContrastLevel)) + .SetIsBackground(true) + .Build(); + + public DynamicColor SurfaceContainer => new DynamicColor.Builder() + .SetName("surface_container") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? new ContrastCurve(12.0, 12.0, 16.0, 20.0).Get(s.ContrastLevel) : new ContrastCurve(94.0, 94.0, 92.0, 90.0).Get(s.ContrastLevel)) + .SetIsBackground(true) + .Build(); + + public DynamicColor SurfaceContainerHigh => new DynamicColor.Builder() + .SetName("surface_container_high") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? new ContrastCurve(17.0, 17.0, 21.0, 25.0).Get(s.ContrastLevel) : new ContrastCurve(92.0, 92.0, 88.0, 85.0).Get(s.ContrastLevel)) + .SetIsBackground(true) + .Build(); + + public DynamicColor SurfaceContainerHighest => new DynamicColor.Builder() + .SetName("surface_container_highest") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? new ContrastCurve(22.0, 22.0, 26.0, 30.0).Get(s.ContrastLevel) : new ContrastCurve(90.0, 90.0, 84.0, 80.0).Get(s.ContrastLevel)) + .SetIsBackground(true) + .Build(); + + public DynamicColor OnSurface => new DynamicColor.Builder() + .SetName("on_surface") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? 90.0 : 10.0) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(4.5, 7.0, 11.0, 21.0)) + .Build(); + + public DynamicColor SurfaceVariant => new DynamicColor.Builder() + .SetName("surface_variant") + .SetPalette(s => s.NeutralVariantPalette) + .SetTone(s => s.IsDark ? 30.0 : 90.0) + .SetIsBackground(true) + .Build(); + + public DynamicColor OnSurfaceVariant => new DynamicColor.Builder() + .SetName("on_surface_variant") + .SetPalette(s => s.NeutralVariantPalette) + .SetTone(s => s.IsDark ? 80.0 : 30.0) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 11.0)) + .Build(); + + public DynamicColor InverseSurface => new DynamicColor.Builder() + .SetName("inverse_surface") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? 90.0 : 20.0) + .SetIsBackground(true) + .Build(); + + public DynamicColor InverseOnSurface => new DynamicColor.Builder() + .SetName("inverse_on_surface") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? 20.0 : 95.0) + .SetBackground(_ => InverseSurface) + .SetContrastCurve(_ => new ContrastCurve(4.5, 7.0, 11.0, 21.0)) + .Build(); + + public DynamicColor Outline => new DynamicColor.Builder() + .SetName("outline") + .SetPalette(s => s.NeutralVariantPalette) + .SetTone(s => s.IsDark ? 60.0 : 50.0) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(1.5, 3.0, 4.5, 7.0)) + .Build(); + + public DynamicColor OutlineVariant => new DynamicColor.Builder() + .SetName("outline_variant") + .SetPalette(s => s.NeutralVariantPalette) + .SetTone(s => s.IsDark ? 30.0 : 80.0) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) + .Build(); + + public DynamicColor Shadow => new DynamicColor.Builder() + .SetName("shadow") + .SetPalette(s => s.NeutralPalette) + .SetTone(_ => 0.0) + .Build(); + + public DynamicColor Scrim => new DynamicColor.Builder() + .SetName("scrim") + .SetPalette(s => s.NeutralPalette) + .SetTone(_ => 0.0) + .Build(); + + public DynamicColor SurfaceTint => new DynamicColor.Builder() + .SetName("surface_tint") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => s.IsDark ? 80.0 : 40.0) + .SetIsBackground(true) + .Build(); + + // Primaries [P] + public DynamicColor Primary => new DynamicColor.Builder() + .SetName("primary") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => IsMonochrome(s) ? (s.IsDark ? 100.0 : 0.0) : (s.IsDark ? 80.0 : 40.0)) + .SetIsBackground(true) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 7.0)) + .SetToneDeltaPair(_ => new ToneDeltaPair(PrimaryContainer, Primary, 10.0, TonePolarity.NEARER, false)) + .Build(); + + public DynamicColor? PrimaryDim => null; + + public DynamicColor OnPrimary => new DynamicColor.Builder() + .SetName("on_primary") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => IsMonochrome(s) ? (s.IsDark ? 10.0 : 90.0) : (s.IsDark ? 20.0 : 100.0)) + .SetBackground(_ => Primary) + .SetContrastCurve(_ => new ContrastCurve(4.5, 7.0, 11.0, 21.0)) + .Build(); + + public DynamicColor PrimaryContainer => new DynamicColor.Builder() + .SetName("primary_container") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => + { + if (IsFidelity(s)) return s.SourceColorHct.Tone; + if (IsMonochrome(s)) return s.IsDark ? 85.0 : 25.0; + return s.IsDark ? 30.0 : 90.0; + }) + .SetIsBackground(true) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) + .SetToneDeltaPair(_ => new ToneDeltaPair(PrimaryContainer, Primary, 10.0, TonePolarity.NEARER, false)) + .Build(); + + public DynamicColor OnPrimaryContainer => new DynamicColor.Builder() + .SetName("on_primary_container") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => + { + if (IsFidelity(s)) return DynamicColor.ForegroundTone(PrimaryContainer.GetTone(s), 4.5); + if (IsMonochrome(s)) return s.IsDark ? 0.0 : 100.0; + return s.IsDark ? 90.0 : 30.0; + }) + .SetBackground(_ => PrimaryContainer) + .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 11.0)) + .Build(); + + public DynamicColor InversePrimary => new DynamicColor.Builder() + .SetName("inverse_primary") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => s.IsDark ? 40.0 : 80.0) + .SetBackground(_ => InverseSurface) + .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 7.0)) + .Build(); + + // Secondaries [Q] + public DynamicColor Secondary => new DynamicColor.Builder() + .SetName("secondary") + .SetPalette(s => s.SecondaryPalette) + .SetTone(s => s.IsDark ? 80.0 : 40.0) + .SetIsBackground(true) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 7.0)) + .SetToneDeltaPair(_ => new ToneDeltaPair(SecondaryContainer, Secondary, 10.0, TonePolarity.NEARER, false)) + .Build(); + + public DynamicColor? SecondaryDim => null; + + public DynamicColor OnSecondary => new DynamicColor.Builder() + .SetName("on_secondary") + .SetPalette(s => s.SecondaryPalette) + .SetTone(s => IsMonochrome(s) ? (s.IsDark ? 10.0 : 100.0) : (s.IsDark ? 20.0 : 100.0)) + .SetBackground(_ => Secondary) + .SetContrastCurve(_ => new ContrastCurve(4.5, 7.0, 11.0, 21.0)) + .Build(); + + public DynamicColor SecondaryContainer => new DynamicColor.Builder() + .SetName("secondary_container") + .SetPalette(s => s.SecondaryPalette) + .SetTone(s => + { + var initialTone = s.IsDark ? 30.0 : 90.0; + if (IsMonochrome(s)) return s.IsDark ? 30.0 : 85.0; + if (!IsFidelity(s)) return initialTone; + return FindDesiredChromaByTone(s.SecondaryPalette.GetHue(), s.SecondaryPalette.GetChroma(), initialTone, !s.IsDark); + }) + .SetIsBackground(true) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) + .SetToneDeltaPair(_ => new ToneDeltaPair(SecondaryContainer, Secondary, 10.0, TonePolarity.NEARER, false)) + .Build(); + + public DynamicColor OnSecondaryContainer => new DynamicColor.Builder() + .SetName("on_secondary_container") + .SetPalette(s => s.SecondaryPalette) + .SetTone(s => + { + if (IsMonochrome(s)) return s.IsDark ? 90.0 : 10.0; + if (!IsFidelity(s)) return s.IsDark ? 90.0 : 30.0; + return DynamicColor.ForegroundTone(SecondaryContainer.GetTone(s), 4.5); + }) + .SetBackground(_ => SecondaryContainer) + .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 11.0)) + .Build(); + + // Tertiaries [T] + public DynamicColor Tertiary => new DynamicColor.Builder() + .SetName("tertiary") + .SetPalette(s => s.TertiaryPalette) + .SetTone(s => IsMonochrome(s) ? (s.IsDark ? 90.0 : 25.0) : (s.IsDark ? 80.0 : 40.0)) + .SetIsBackground(true) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 7.0)) + .SetToneDeltaPair(_ => new ToneDeltaPair(TertiaryContainer, Tertiary, 10.0, TonePolarity.NEARER, false)) + .Build(); + + public DynamicColor? TertiaryDim => null; + + public DynamicColor OnTertiary => new DynamicColor.Builder() + .SetName("on_tertiary") + .SetPalette(s => s.TertiaryPalette) + .SetTone(s => IsMonochrome(s) ? (s.IsDark ? 10.0 : 90.0) : (s.IsDark ? 20.0 : 100.0)) + .SetBackground(_ => Tertiary) + .SetContrastCurve(_ => new ContrastCurve(4.5, 7.0, 11.0, 21.0)) + .Build(); + + public DynamicColor TertiaryContainer => new DynamicColor.Builder() + .SetName("tertiary_container") + .SetPalette(s => s.TertiaryPalette) + .SetTone(s => + { + if (IsMonochrome(s)) return s.IsDark ? 60.0 : 49.0; + if (!IsFidelity(s)) return s.IsDark ? 30.0 : 90.0; + var proposed = s.TertiaryPalette.GetHct(s.SourceColorHct.Tone); + return DislikeAnalyzer.FixIfDisliked(proposed).Tone; + }) + .SetIsBackground(true) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) + .SetToneDeltaPair(_ => new ToneDeltaPair(TertiaryContainer, Tertiary, 10.0, TonePolarity.NEARER, false)) + .Build(); + + public DynamicColor OnTertiaryContainer => new DynamicColor.Builder() + .SetName("on_tertiary_container") + .SetPalette(s => s.TertiaryPalette) + .SetTone(s => + { + if (IsMonochrome(s)) return s.IsDark ? 0.0 : 100.0; + if (!IsFidelity(s)) return s.IsDark ? 90.0 : 30.0; + return DynamicColor.ForegroundTone(TertiaryContainer.GetTone(s), 4.5); + }) + .SetBackground(_ => TertiaryContainer) + .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 11.0)) + .Build(); + + // Errors [E] + public DynamicColor Error => new DynamicColor.Builder() + .SetName("error") + .SetPalette(s => s.ErrorPalette) + .SetTone(s => s.IsDark ? 80.0 : 40.0) + .SetIsBackground(true) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 7.0)) + .SetToneDeltaPair(_ => new ToneDeltaPair(ErrorContainer, Error, 10.0, TonePolarity.NEARER, false)) + .Build(); + + public DynamicColor? ErrorDim => null; + + public DynamicColor OnError => new DynamicColor.Builder() + .SetName("on_error") + .SetPalette(s => s.ErrorPalette) + .SetTone(s => s.IsDark ? 20.0 : 100.0) + .SetBackground(_ => Error) + .SetContrastCurve(_ => new ContrastCurve(4.5, 7.0, 11.0, 21.0)) + .Build(); + + public DynamicColor ErrorContainer => new DynamicColor.Builder() + .SetName("error_container") + .SetPalette(s => s.ErrorPalette) + .SetTone(s => s.IsDark ? 30.0 : 90.0) + .SetIsBackground(true) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) + .SetToneDeltaPair(_ => new ToneDeltaPair(ErrorContainer, Error, 10.0, TonePolarity.NEARER, false)) + .Build(); + + public DynamicColor OnErrorContainer => new DynamicColor.Builder() + .SetName("on_error_container") + .SetPalette(s => s.ErrorPalette) + .SetTone(s => IsMonochrome(s) ? (s.IsDark ? 90.0 : 10.0) : (s.IsDark ? 90.0 : 30.0)) + .SetBackground(_ => ErrorContainer) + .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 11.0)) + .Build(); + + // Primary Fixed Colors [PF] + public DynamicColor PrimaryFixed => new DynamicColor.Builder() + .SetName("primary_fixed") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => IsMonochrome(s) ? 40.0 : 90.0) + .SetIsBackground(true) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) + .SetToneDeltaPair(_ => new ToneDeltaPair(PrimaryFixed, PrimaryFixedDim, 10.0, TonePolarity.LIGHTER, true)) + .Build(); + + public DynamicColor PrimaryFixedDim => new DynamicColor.Builder() + .SetName("primary_fixed_dim") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => IsMonochrome(s) ? 30.0 : 80.0) + .SetIsBackground(true) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) + .SetToneDeltaPair(_ => new ToneDeltaPair(PrimaryFixed, PrimaryFixedDim, 10.0, TonePolarity.LIGHTER, true)) + .Build(); + + public DynamicColor OnPrimaryFixed => new DynamicColor.Builder() + .SetName("on_primary_fixed") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => IsMonochrome(s) ? 100.0 : 10.0) + .SetBackground(_ => PrimaryFixedDim) + .SetSecondBackground(_ => PrimaryFixed) + .SetContrastCurve(_ => new ContrastCurve(4.5, 7.0, 11.0, 21.0)) + .Build(); + + public DynamicColor OnPrimaryFixedVariant => new DynamicColor.Builder() + .SetName("on_primary_fixed_variant") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => IsMonochrome(s) ? 90.0 : 30.0) + .SetBackground(_ => PrimaryFixedDim) + .SetSecondBackground(_ => PrimaryFixed) + .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 11.0)) + .Build(); + + // Secondary Fixed Colors [QF] + public DynamicColor SecondaryFixed => new DynamicColor.Builder() + .SetName("secondary_fixed") + .SetPalette(s => s.SecondaryPalette) + .SetTone(s => IsMonochrome(s) ? 80.0 : 90.0) + .SetIsBackground(true) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) + .SetToneDeltaPair(_ => new ToneDeltaPair(SecondaryFixed, SecondaryFixedDim, 10.0, TonePolarity.LIGHTER, true)) + .Build(); + + public DynamicColor SecondaryFixedDim => new DynamicColor.Builder() + .SetName("secondary_fixed_dim") + .SetPalette(s => s.SecondaryPalette) + .SetTone(s => IsMonochrome(s) ? 70.0 : 80.0) + .SetIsBackground(true) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) + .SetToneDeltaPair(_ => new ToneDeltaPair(SecondaryFixed, SecondaryFixedDim, 10.0, TonePolarity.LIGHTER, true)) + .Build(); + + public DynamicColor OnSecondaryFixed => new DynamicColor.Builder() + .SetName("on_secondary_fixed") + .SetPalette(s => s.SecondaryPalette) + .SetTone(_ => 10.0) + .SetBackground(_ => SecondaryFixedDim) + .SetSecondBackground(_ => SecondaryFixed) + .SetContrastCurve(_ => new ContrastCurve(4.5, 7.0, 11.0, 21.0)) + .Build(); + + public DynamicColor OnSecondaryFixedVariant => new DynamicColor.Builder() + .SetName("on_secondary_fixed_variant") + .SetPalette(s => s.SecondaryPalette) + .SetTone(s => IsMonochrome(s) ? 25.0 : 30.0) + .SetBackground(_ => SecondaryFixedDim) + .SetSecondBackground(_ => SecondaryFixed) + .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 11.0)) + .Build(); + + // Tertiary Fixed Colors [TF] + public DynamicColor TertiaryFixed => new DynamicColor.Builder() + .SetName("tertiary_fixed") + .SetPalette(s => s.TertiaryPalette) + .SetTone(s => IsMonochrome(s) ? 40.0 : 90.0) + .SetIsBackground(true) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) + .SetToneDeltaPair(_ => new ToneDeltaPair(TertiaryFixed, TertiaryFixedDim, 10.0, TonePolarity.LIGHTER, true)) + .Build(); + + public DynamicColor TertiaryFixedDim => new DynamicColor.Builder() + .SetName("tertiary_fixed_dim") + .SetPalette(s => s.TertiaryPalette) + .SetTone(s => IsMonochrome(s) ? 30.0 : 80.0) + .SetIsBackground(true) + .SetBackground(HighestSurface) + .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) + .SetToneDeltaPair(_ => new ToneDeltaPair(TertiaryFixed, TertiaryFixedDim, 10.0, TonePolarity.LIGHTER, true)) + .Build(); + + public DynamicColor OnTertiaryFixed => new DynamicColor.Builder() + .SetName("on_tertiary_fixed") + .SetPalette(s => s.TertiaryPalette) + .SetTone(s => IsMonochrome(s) ? 100.0 : 10.0) + .SetBackground(_ => TertiaryFixedDim) + .SetSecondBackground(_ => TertiaryFixed) + .SetContrastCurve(_ => new ContrastCurve(4.5, 7.0, 11.0, 21.0)) + .Build(); + + public DynamicColor OnTertiaryFixedVariant => new DynamicColor.Builder() + .SetName("on_tertiary_fixed_variant") + .SetPalette(s => s.TertiaryPalette) + .SetTone(s => IsMonochrome(s) ? 90.0 : 30.0) + .SetBackground(_ => TertiaryFixedDim) + .SetSecondBackground(_ => TertiaryFixed) + .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 11.0)) + .Build(); + + // Android-only Colors + public DynamicColor ControlActivated => new DynamicColor.Builder() + .SetName("control_activated") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => s.IsDark ? 30.0 : 90.0) + .SetIsBackground(true) + .Build(); + + public DynamicColor ControlNormal => new DynamicColor.Builder() + .SetName("control_normal") + .SetPalette(s => s.NeutralVariantPalette) + .SetTone(s => s.IsDark ? 80.0 : 30.0) + .Build(); + + public DynamicColor ControlHighlight => new DynamicColor.Builder() + .SetName("control_highlight") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? 100.0 : 0.0) + .SetOpacity(s => s.IsDark ? 0.20 : 0.12) + .Build(); + + public DynamicColor TextPrimaryInverse => new DynamicColor.Builder() + .SetName("text_primary_inverse") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? 10.0 : 90.0) + .Build(); + + public DynamicColor TextSecondaryAndTertiaryInverse => new DynamicColor.Builder() + .SetName("text_secondary_and_tertiary_inverse") + .SetPalette(s => s.NeutralVariantPalette) + .SetTone(s => s.IsDark ? 30.0 : 80.0) + .Build(); + + public DynamicColor TextPrimaryInverseDisableOnly => new DynamicColor.Builder() + .SetName("text_primary_inverse_disable_only") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? 10.0 : 90.0) + .Build(); + + public DynamicColor TextSecondaryAndTertiaryInverseDisabled => new DynamicColor.Builder() + .SetName("text_secondary_and_tertiary_inverse_disabled") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? 10.0 : 90.0) + .Build(); + + public DynamicColor TextHintInverse => new DynamicColor.Builder() + .SetName("text_hint_inverse") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? 10.0 : 90.0) + .Build(); + + // Other + public DynamicColor HighestSurface(DynamicScheme s) => s.IsDark ? SurfaceBright : SurfaceDim; + + private static bool IsFidelity(DynamicScheme scheme) => scheme.Variant == Variant.FIDELITY || scheme.Variant == Variant.CONTENT; + private static bool IsMonochrome(DynamicScheme scheme) => scheme.Variant == Variant.MONOCHROME; + + private static double FindDesiredChromaByTone(double hue, double chroma, double tone, bool byDecreasingTone) + { + var answer = tone; + var closest = Hct.From(hue, chroma, tone); + if (closest.Chroma < chroma) + { + var chromaPeak = closest.Chroma; + while (closest.Chroma < chroma) + { + answer += byDecreasingTone ? -1.0 : 1.0; + var potential = Hct.From(hue, chroma, answer); + if (chromaPeak > potential.Chroma) + { + break; + } + if (System.Math.Abs(potential.Chroma - chroma) < 0.4) + { + break; + } + var potentialDelta = System.Math.Abs(potential.Chroma - chroma); + var currentDelta = System.Math.Abs(closest.Chroma - chroma); + if (potentialDelta < currentDelta) + { + closest = potential; + } + chromaPeak = System.Math.Max(chromaPeak, potential.Chroma); + } + } + return answer; + } + + // Color value calculations + public Hct GetHct(DynamicScheme scheme, DynamicColor color) + { + var tone = GetTone(scheme, color); + return color.palette(scheme).GetHct(tone); + } + + public double GetTone(DynamicScheme scheme, DynamicColor color) + { + var decreasingContrast = scheme.ContrastLevel < 0; + var toneDeltaPair = color.toneDeltaPair == null ? null : color.toneDeltaPair(scheme); + + if (toneDeltaPair != null) + { + var roleA = toneDeltaPair.RoleA; + var roleB = toneDeltaPair.RoleB; + var delta = toneDeltaPair.Delta; + var polarity = toneDeltaPair.Polarity; + var stayTogether = toneDeltaPair.StayTogether; + + var aIsNearer = (polarity == TonePolarity.NEARER + || (polarity == TonePolarity.LIGHTER && !scheme.IsDark) + || (polarity == TonePolarity.DARKER && !scheme.IsDark)); + var nearer = aIsNearer ? roleA : roleB; + var farther = aIsNearer ? roleB : roleA; + var amNearer = color.name.Equals(nearer.name, System.StringComparison.Ordinal); + var expansionDir = scheme.IsDark ? 1 : -1; + var nTone = nearer.tone(scheme); + var fTone = farther.tone(scheme); + + if (color.background != null && nearer.contrastCurve != null && farther.contrastCurve != null) + { + var bg = color.background(scheme); + var nCurve = nearer.contrastCurve(scheme); + var fCurve = farther.contrastCurve(scheme); + if (bg != null && nCurve != null && fCurve != null) + { + var nContrast = nCurve.Get(scheme.ContrastLevel); + var fContrast = fCurve.Get(scheme.ContrastLevel); + var bgTone = bg.GetTone(scheme); + if (Contrast.RatioOfTones(bgTone, nTone) < nContrast) + { + nTone = DynamicColor.ForegroundTone(bgTone, nContrast); + } + if (Contrast.RatioOfTones(bgTone, fTone) < fContrast) + { + fTone = DynamicColor.ForegroundTone(bgTone, fContrast); + } + if (decreasingContrast) + { + nTone = DynamicColor.ForegroundTone(bgTone, nContrast); + fTone = DynamicColor.ForegroundTone(bgTone, fContrast); + } + } + } + + if ((fTone - nTone) * expansionDir < delta) + { + fTone = MathUtils.ClampDouble(0, 100, nTone + delta * expansionDir); + if ((fTone - nTone) * expansionDir < delta) + { + nTone = MathUtils.ClampDouble(0, 100, fTone - delta * expansionDir); + } + } + + if (50 <= nTone && nTone < 60) + { + if (expansionDir > 0) + { + nTone = 60; + fTone = System.Math.Max(fTone, nTone + delta * expansionDir); + } + else + { + nTone = 49; + fTone = System.Math.Min(fTone, nTone + delta * expansionDir); + } + } + else if (50 <= fTone && fTone < 60) + { + if (stayTogether) + { + if (expansionDir > 0) + { + nTone = 60; + fTone = System.Math.Max(fTone, nTone + delta * expansionDir); + } + else + { + nTone = 49; + fTone = System.Math.Min(fTone, nTone + delta * expansionDir); + } + } + else + { + if (expansionDir > 0) + { + fTone = 60; + } + else + { + fTone = 49; + } + } + } + return amNearer ? nTone : fTone; + } + else + { + var answer = color.tone(scheme); + if (color.background == null || color.background(scheme) == null || color.contrastCurve == null || color.contrastCurve(scheme) == null) + { + return answer; + } + var bgTone = color.background(scheme).GetTone(scheme); + var desiredRatio = color.contrastCurve(scheme).Get(scheme.ContrastLevel); + if (Contrast.RatioOfTones(bgTone, answer) < desiredRatio) + { + answer = DynamicColor.ForegroundTone(bgTone, desiredRatio); + } + if (decreasingContrast) + { + answer = DynamicColor.ForegroundTone(bgTone, desiredRatio); + } + if (color.isBackground && 50 <= answer && answer < 60) + { + if (Contrast.RatioOfTones(49, bgTone) >= desiredRatio) + { + answer = 49; + } + else + { + answer = 60; + } + } + if (color.secondBackground == null || color.secondBackground(scheme) == null) + { + return answer; + } + var bgTone1 = color.background(scheme).GetTone(scheme); + var bgTone2 = color.secondBackground(scheme).GetTone(scheme); + var upper = System.Math.Max(bgTone1, bgTone2); + var lower = System.Math.Min(bgTone1, bgTone2); + if (Contrast.RatioOfTones(upper, answer) >= desiredRatio && Contrast.RatioOfTones(lower, answer) >= desiredRatio) + { + return answer; + } + var lightOption = Contrast.Lighter(upper, desiredRatio); + var darkOption = Contrast.Darker(lower, desiredRatio); + var prefersLight = DynamicColor.TonePrefersLightForeground(bgTone1) || DynamicColor.TonePrefersLightForeground(bgTone2); + if (prefersLight) + { + return lightOption == -1 ? 100 : lightOption; + } + if (lightOption != -1 && darkOption == -1) + { + return lightOption; + } + return darkOption == -1 ? 0 : darkOption; + } + } + + // Scheme Palettes + public TonalPalette GetPrimaryPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel) + { + return variant switch + { + Variant.CONTENT or Variant.FIDELITY => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, sourceColorHct.Chroma), + Variant.FRUIT_SALAD => TonalPalette.FromHueAndChroma(MathUtils.SanitizeDegreesDouble(sourceColorHct.Hue - 50.0), 48.0), + Variant.MONOCHROME => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 0.0), + Variant.NEUTRAL => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 12.0), + Variant.RAINBOW => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 48.0), + Variant.TONAL_SPOT => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 36.0), + Variant.EXPRESSIVE => TonalPalette.FromHueAndChroma(MathUtils.SanitizeDegreesDouble(sourceColorHct.Hue + 240.0), 40.0), + Variant.VIBRANT => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 200.0), + _ => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, sourceColorHct.Chroma), + }; + } + + public TonalPalette GetSecondaryPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel) + { + return variant switch + { + Variant.CONTENT or Variant.FIDELITY => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, System.Math.Max(sourceColorHct.Chroma - 32.0, sourceColorHct.Chroma * 0.5)), + Variant.FRUIT_SALAD => TonalPalette.FromHueAndChroma(MathUtils.SanitizeDegreesDouble(sourceColorHct.Hue - 50.0), 36.0), + Variant.MONOCHROME => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 0.0), + Variant.NEUTRAL => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 8.0), + Variant.RAINBOW => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 16.0), + Variant.TONAL_SPOT => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 16.0), + Variant.EXPRESSIVE => TonalPalette.FromHueAndChroma( + DynamicScheme.GetRotatedHue( + sourceColorHct, + [0.0, 21.0, 51.0, 121.0, 151.0, 191.0, 271.0, 321.0, 360.0], + [45.0, 95.0, 45.0, 20.0, 45.0, 90.0, 45.0, 45.0, 45.0] + ), 24.0), + Variant.VIBRANT => TonalPalette.FromHueAndChroma( + DynamicScheme.GetRotatedHue( + sourceColorHct, + [0.0, 41.0, 61.0, 101.0, 131.0, 181.0, 251.0, 301.0, 360.0], + [18.0, 15.0, 10.0, 12.0, 15.0, 18.0, 15.0, 12.0, 12.0] + ), 24.0), + _ => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, sourceColorHct.Chroma), + }; + } + + public TonalPalette GetTertiaryPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel) + { + return variant switch + { + Variant.CONTENT => TonalPalette.FromHct(DislikeAnalyzer.FixIfDisliked(new TemperatureCache(sourceColorHct).GetAnalogousColors(3, 6)[2])), + Variant.FIDELITY => TonalPalette.FromHct(DislikeAnalyzer.FixIfDisliked(new TemperatureCache(sourceColorHct).GetComplement())), + Variant.FRUIT_SALAD => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 36.0), + Variant.MONOCHROME => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 0.0), + Variant.NEUTRAL => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 16.0), + Variant.RAINBOW or Variant.TONAL_SPOT => TonalPalette.FromHueAndChroma(MathUtils.SanitizeDegreesDouble(sourceColorHct.Hue + 60.0), 24.0), + Variant.EXPRESSIVE => TonalPalette.FromHueAndChroma( + DynamicScheme.GetRotatedHue( + sourceColorHct, + [0.0, 21.0, 51.0, 121.0, 151.0, 191.0, 271.0, 321.0, 360.0], + [120.0, 120.0, 20.0, 45.0, 20.0, 15.0, 20.0, 120.0, 120.0] + ), 32.0), + Variant.VIBRANT => TonalPalette.FromHueAndChroma( + DynamicScheme.GetRotatedHue( + sourceColorHct, + [0.0, 41.0, 61.0, 101.0, 131.0, 181.0, 251.0, 301.0, 360.0], + [35.0, 30.0, 20.0, 25.0, 30.0, 35.0, 30.0, 25.0, 25.0] + ), 32.0), + _ => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, sourceColorHct.Chroma), + }; + } + + public TonalPalette GetNeutralPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel) + { + return variant switch + { + Variant.CONTENT or Variant.FIDELITY => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, sourceColorHct.Chroma / 8.0), + Variant.FRUIT_SALAD => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 10.0), + Variant.MONOCHROME => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 0.0), + Variant.NEUTRAL => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 2.0), + Variant.RAINBOW => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 0.0), + Variant.TONAL_SPOT => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 6.0), + Variant.EXPRESSIVE => TonalPalette.FromHueAndChroma(MathUtils.SanitizeDegreesDouble(sourceColorHct.Hue + 15.0), 8.0), + Variant.VIBRANT => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 10.0), + _ => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, sourceColorHct.Chroma), + }; + } + + public TonalPalette GetNeutralVariantPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel) + { + return variant switch + { + Variant.CONTENT or Variant.FIDELITY => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, (sourceColorHct.Chroma / 8.0) + 4.0), + Variant.FRUIT_SALAD => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 16.0), + Variant.MONOCHROME => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 0.0), + Variant.NEUTRAL => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 2.0), + Variant.RAINBOW => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 0.0), + Variant.TONAL_SPOT => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 8.0), + Variant.EXPRESSIVE => TonalPalette.FromHueAndChroma(MathUtils.SanitizeDegreesDouble(sourceColorHct.Hue + 15.0), 12.0), + Variant.VIBRANT => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 12.0), + _ => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, sourceColorHct.Chroma), + }; + } + + public TonalPalette? GetErrorPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel) + { + return null; + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2025.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2025.cs new file mode 100644 index 0000000000..c8c6f316d3 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2025.cs @@ -0,0 +1,1515 @@ +namespace MaterialColorUtilities; + +public class ColorSpec2025 : ColorSpec2021 +{ + // Surfaces [S] + public new DynamicColor Background + { + get + { + // Remap to surface for 2025 + var color2025 = Surface.ToBuilder().SetName("background").Build(); + return base.Background.ToBuilder() + .ExtendSpecVersion(SpecVersion.SPEC_2025, color2025) + .Build(); + } + } + + public new DynamicColor OnBackground + { + get + { + // Remap to onSurface for 2025; watch tweaks tone to 100 + var color2025Builder = OnSurface.ToBuilder().SetName("on_background"); + color2025Builder.SetTone(s => s.PlatformType == Platform.WATCH ? 100.0 : OnSurface.GetTone(s)); + return base.OnBackground.ToBuilder() + .ExtendSpecVersion(SpecVersion.SPEC_2025, color2025Builder.Build()) + .Build(); + } + } + + public new DynamicColor Surface + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("surface") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => + { + if (s.PlatformType == Platform.PHONE) + { + if (s.IsDark) return 4.0; + if (Hct.IsYellow(s.NeutralPalette.GetHue())) return 99.0; + if (s.Variant == Variant.VIBRANT) return 97.0; + return 98.0; + } + else + { + return 0.0; + } + }) + .SetIsBackground(true) + .Build(); + return base.Surface.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor SurfaceDim + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("surface_dim") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => + { + if (s.IsDark) return 4.0; + if (Hct.IsYellow(s.NeutralPalette.GetHue())) return 90.0; + if (s.Variant == Variant.VIBRANT) return 85.0; + return 87.0; + }) + .SetIsBackground(true) + .SetChromaMultiplier(s => + { + if (!s.IsDark) + { + if (s.Variant == Variant.NEUTRAL) return 2.5; + if (s.Variant == Variant.TONAL_SPOT) return 1.7; + if (s.Variant == Variant.EXPRESSIVE) return Hct.IsYellow(s.NeutralPalette.GetHue()) ? 2.7 : 1.75; + if (s.Variant == Variant.VIBRANT) return 1.36; + } + return 1.0; + }) + .Build(); + return base.SurfaceDim.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor SurfaceBright + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("surface_bright") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => + { + if (s.IsDark) return 18.0; + if (Hct.IsYellow(s.NeutralPalette.GetHue())) return 99.0; + if (s.Variant == Variant.VIBRANT) return 97.0; + return 98.0; + }) + .SetIsBackground(true) + .SetChromaMultiplier(s => + { + if (s.IsDark) + { + if (s.Variant == Variant.NEUTRAL) return 2.5; + if (s.Variant == Variant.TONAL_SPOT) return 1.7; + if (s.Variant == Variant.EXPRESSIVE) return Hct.IsYellow(s.NeutralPalette.GetHue()) ? 2.7 : 1.75; + if (s.Variant == Variant.VIBRANT) return 1.36; + } + return 1.0; + }) + .Build(); + return base.SurfaceBright.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor SurfaceContainerLowest + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("surface_container_lowest") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? 0.0 : 100.0) + .SetIsBackground(true) + .Build(); + return base.SurfaceContainerLowest.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor SurfaceContainerLow + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("surface_container_low") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => + { + if (s.PlatformType == Platform.PHONE) + { + if (s.IsDark) return 6.0; + if (Hct.IsYellow(s.NeutralPalette.GetHue())) return 98.0; + if (s.Variant == Variant.VIBRANT) return 95.0; + return 96.0; + } + return 15.0; + }) + .SetIsBackground(true) + .SetChromaMultiplier(s => + { + if (s.PlatformType == Platform.PHONE) + { + if (s.Variant == Variant.NEUTRAL) return 1.3; + if (s.Variant == Variant.TONAL_SPOT) return 1.25; + if (s.Variant == Variant.EXPRESSIVE) return Hct.IsYellow(s.NeutralPalette.GetHue()) ? 1.3 : 1.15; + if (s.Variant == Variant.VIBRANT) return 1.08; + } + return 1.0; + }) + .Build(); + return base.SurfaceContainerLow.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor SurfaceContainer + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("surface_container") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => + { + if (s.PlatformType == Platform.PHONE) + { + if (s.IsDark) return 9.0; + if (Hct.IsYellow(s.NeutralPalette.GetHue())) return 96.0; + if (s.Variant == Variant.VIBRANT) return 92.0; + return 94.0; + } + return 20.0; + }) + .SetIsBackground(true) + .SetChromaMultiplier(s => + { + if (s.PlatformType == Platform.PHONE) + { + if (s.Variant == Variant.NEUTRAL) return 1.6; + if (s.Variant == Variant.TONAL_SPOT) return 1.4; + if (s.Variant == Variant.EXPRESSIVE) return Hct.IsYellow(s.NeutralPalette.GetHue()) ? 1.6 : 1.3; + if (s.Variant == Variant.VIBRANT) return 1.15; + } + return 1.0; + }) + .Build(); + return base.SurfaceContainer.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor SurfaceContainerHigh + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("surface_container_high") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => + { + if (s.PlatformType == Platform.PHONE) + { + if (s.IsDark) return 12.0; + if (Hct.IsYellow(s.NeutralPalette.GetHue())) return 94.0; + if (s.Variant == Variant.VIBRANT) return 90.0; + return 92.0; + } + return 25.0; + }) + .SetIsBackground(true) + .SetChromaMultiplier(s => + { + if (s.PlatformType == Platform.PHONE) + { + if (s.Variant == Variant.NEUTRAL) return 1.9; + if (s.Variant == Variant.TONAL_SPOT) return 1.5; + if (s.Variant == Variant.EXPRESSIVE) return Hct.IsYellow(s.NeutralPalette.GetHue()) ? 1.95 : 1.45; + if (s.Variant == Variant.VIBRANT) return 1.22; + } + return 1.0; + }) + .Build(); + return base.SurfaceContainerHigh.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor SurfaceContainerHighest + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("surface_container_highest") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => + { + if (s.IsDark) return 15.0; + if (Hct.IsYellow(s.NeutralPalette.GetHue())) return 92.0; + if (s.Variant == Variant.VIBRANT) return 88.0; + return 90.0; + }) + .SetIsBackground(true) + .SetChromaMultiplier(s => + { + if (s.Variant == Variant.NEUTRAL) return 2.2; + if (s.Variant == Variant.TONAL_SPOT) return 1.7; + if (s.Variant == Variant.EXPRESSIVE) return Hct.IsYellow(s.NeutralPalette.GetHue()) ? 2.3 : 1.6; + if (s.Variant == Variant.VIBRANT) return 1.29; + return 1.0; + }) + .Build(); + return base.SurfaceContainerHighest.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor OnSurface + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_surface") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => + { + if (s.Variant == Variant.VIBRANT) + { + return TMaxC(s.NeutralPalette, 0, 100, 1.1); + } + else + { + return DynamicColor.GetInitialToneFromBackground( + scheme => + { + if (scheme.PlatformType == Platform.PHONE) + { + return scheme.IsDark ? SurfaceBright : SurfaceDim; + } + else + { + return SurfaceContainerHigh; + } + } + )(s); + } + }) + .SetChromaMultiplier(s => + { + if (s.PlatformType == Platform.PHONE) + { + if (s.Variant == Variant.NEUTRAL) return 2.2; + if (s.Variant == Variant.TONAL_SPOT) return 1.7; + if (s.Variant == Variant.EXPRESSIVE) return Hct.IsYellow(s.NeutralPalette.GetHue()) ? (s.IsDark ? 3.0 : 2.3) : 1.6; + } + return 1.0; + }) + .SetBackground(s => + { + if (s.PlatformType == Platform.PHONE) + { + return s.IsDark ? SurfaceBright : SurfaceDim; + } + else + { + return SurfaceContainerHigh; + } + }) + .SetContrastCurve(s => s.IsDark ? GetContrastCurve(11) : GetContrastCurve(9)) + .Build(); + return base.OnSurface.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor SurfaceVariant + { + get + { + var color2025 = SurfaceContainerHighest.ToBuilder().SetName("surface_variant").Build(); + return base.SurfaceVariant.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor OnSurfaceVariant + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_surface_variant") + .SetPalette(s => s.NeutralPalette) + .SetChromaMultiplier(s => + { + if (s.PlatformType == Platform.PHONE) + { + if (s.Variant == Variant.NEUTRAL) return 2.2; + if (s.Variant == Variant.TONAL_SPOT) return 1.7; + if (s.Variant == Variant.EXPRESSIVE) return Hct.IsYellow(s.NeutralPalette.GetHue()) ? (s.IsDark ? 3.0 : 2.3) : 1.6; + } + return 1.0; + }) + .SetBackground(s => + { + if (s.PlatformType == Platform.PHONE) + { + return s.IsDark ? SurfaceBright : SurfaceDim; + } + else + { + return SurfaceContainerHigh; + } + }) + .SetContrastCurve(s => + s.PlatformType == Platform.PHONE + ? (s.IsDark ? GetContrastCurve(6) : GetContrastCurve(4.5)) + : GetContrastCurve(7)) + .Build(); + return base.OnSurfaceVariant.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor InverseSurface + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("inverse_surface") + .SetPalette(s => s.NeutralPalette) + .SetTone(s => s.IsDark ? 98.0 : 4.0) + .SetIsBackground(true) + .Build(); + return base.InverseSurface.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor InverseOnSurface + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("inverse_on_surface") + .SetPalette(s => s.NeutralPalette) + .SetBackground(s => InverseSurface) + .SetContrastCurve(s => GetContrastCurve(7)) + .Build(); + return base.InverseOnSurface.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor Outline + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("outline") + .SetPalette(s => s.NeutralPalette) + .SetChromaMultiplier(s => + { + if (s.PlatformType == Platform.PHONE) + { + if (s.Variant == Variant.NEUTRAL) return 2.2; + if (s.Variant == Variant.TONAL_SPOT) return 1.7; + if (s.Variant == Variant.EXPRESSIVE) return Hct.IsYellow(s.NeutralPalette.GetHue()) ? (s.IsDark ? 3.0 : 2.3) : 1.6; + } + return 1.0; + }) + .SetBackground(s => + { + if (s.PlatformType == Platform.PHONE) + { + return s.IsDark ? SurfaceBright : SurfaceDim; + } + else + { + return SurfaceContainerHigh; + } + }) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(3) : GetContrastCurve(4.5)) + .Build(); + return base.Outline.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor OutlineVariant + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("outline_variant") + .SetPalette(s => s.NeutralPalette) + .SetChromaMultiplier(s => + { + if (s.PlatformType == Platform.PHONE) + { + if (s.Variant == Variant.NEUTRAL) return 2.2; + if (s.Variant == Variant.TONAL_SPOT) return 1.7; + if (s.Variant == Variant.EXPRESSIVE) return Hct.IsYellow(s.NeutralPalette.GetHue()) ? (s.IsDark ? 3.0 : 2.3) : 1.6; + } + return 1.0; + }) + .SetBackground(s => + { + if (s.PlatformType == Platform.PHONE) + { + return s.IsDark ? SurfaceBright : SurfaceDim; + } + else + { + return SurfaceContainerHigh; + } + }) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(1.5) : GetContrastCurve(3)) + .Build(); + return base.OutlineVariant.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor SurfaceTint + { + get + { + // Remapped to primary + var color2025 = Primary.ToBuilder().SetName("surface_tint").Build(); + return base.SurfaceTint.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + // Primaries [P] + public new DynamicColor Primary + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("primary") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => + { + if (s.Variant == Variant.NEUTRAL) + { + if (s.PlatformType == Platform.PHONE) return s.IsDark ? 80.0 : 40.0; + return 90.0; + } + else if (s.Variant == Variant.TONAL_SPOT) + { + if (s.PlatformType == Platform.PHONE) + { + if (s.IsDark) return 80.0; + return TMaxC(s.PrimaryPalette); + } + else + { + return TMaxC(s.PrimaryPalette, 0, 90); + } + } + else if (s.Variant == Variant.EXPRESSIVE) + { + return TMaxC( + s.PrimaryPalette, + 0, + Hct.IsYellow(s.PrimaryPalette.GetHue()) ? 25 : (Hct.IsCyan(s.PrimaryPalette.GetHue()) ? 88 : 98)); + } + else // VIBRANT + { + return TMaxC(s.PrimaryPalette, 0, Hct.IsCyan(s.PrimaryPalette.GetHue()) ? 88 : 98); + } + }) + .SetIsBackground(true) + .SetBackground(s => + { + if (s.PlatformType == Platform.PHONE) return s.IsDark ? SurfaceBright : SurfaceDim; + return SurfaceContainerHigh; + }) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(4.5) : GetContrastCurve(7)) + .SetToneDeltaPair(s => s.PlatformType == Platform.PHONE + ? new ToneDeltaPair(PrimaryContainer, Primary, 5.0, TonePolarity.RELATIVE_LIGHTER, DeltaConstraint.FARTHER) + : null!) + .Build(); + return base.Primary.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor? PrimaryDim + { + get + { + return new DynamicColor.Builder() + .SetName("primary_dim") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => + { + if (s.Variant == Variant.NEUTRAL) return 85.0; + if (s.Variant == Variant.TONAL_SPOT) return TMaxC(s.PrimaryPalette, 0, 90); + return TMaxC(s.PrimaryPalette); + }) + .SetIsBackground(true) + .SetBackground(s => SurfaceContainerHigh) + .SetContrastCurve(s => GetContrastCurve(4.5)) + .SetToneDeltaPair(s => new ToneDeltaPair(PrimaryDim!, Primary, 5.0, TonePolarity.DARKER, DeltaConstraint.FARTHER)) + .Build(); + } + } + + public new DynamicColor OnPrimary + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_primary") + .SetPalette(s => s.PrimaryPalette) + .SetBackground(s => s.PlatformType == Platform.PHONE ? Primary : PrimaryDim!) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(6) : GetContrastCurve(7)) + .Build(); + return base.OnPrimary.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor PrimaryContainer + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("primary_container") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => + { + if (s.PlatformType == Platform.WATCH) return 30.0; + if (s.Variant == Variant.NEUTRAL) return s.IsDark ? 30.0 : 90.0; + if (s.Variant == Variant.TONAL_SPOT) return s.IsDark ? TMinC(s.PrimaryPalette, 35, 93) : TMaxC(s.PrimaryPalette, 0, 90); + if (s.Variant == Variant.EXPRESSIVE) return s.IsDark ? TMaxC(s.PrimaryPalette, 30, 93) : TMaxC(s.PrimaryPalette, 78, Hct.IsCyan(s.PrimaryPalette.GetHue()) ? 88 : 90); + // VIBRANT + return s.IsDark ? TMinC(s.PrimaryPalette, 66, 93) : TMaxC(s.PrimaryPalette, 66, Hct.IsCyan(s.PrimaryPalette.GetHue()) ? 88 : 93); + }) + .SetIsBackground(true) + .SetBackground(s => + { + if (s.PlatformType == Platform.PHONE) return s.IsDark ? SurfaceBright : SurfaceDim; + return null!; + }) + .SetToneDeltaPair(s => s.PlatformType == Platform.WATCH ? new ToneDeltaPair(PrimaryContainer, PrimaryDim!, 10.0, TonePolarity.DARKER, DeltaConstraint.FARTHER) : null!) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE && s.ContrastLevel > 0 ? GetContrastCurve(1.5) : null!) + .Build(); + return base.PrimaryContainer.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor OnPrimaryContainer + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_primary_container") + .SetPalette(s => s.PrimaryPalette) + .SetBackground(s => PrimaryContainer) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(6) : GetContrastCurve(7)) + .Build(); + return base.OnPrimaryContainer.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor InversePrimary + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("inverse_primary") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => TMaxC(s.PrimaryPalette)) + .SetBackground(s => InverseSurface) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(6) : GetContrastCurve(7)) + .Build(); + return base.InversePrimary.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + // Secondaries [Q] + public new DynamicColor Secondary + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("secondary") + .SetPalette(s => s.SecondaryPalette) + .SetTone(s => + { + if (s.PlatformType == Platform.WATCH) return s.Variant == Variant.NEUTRAL ? 90.0 : TMaxC(s.SecondaryPalette, 0, 90); + if (s.Variant == Variant.NEUTRAL) return s.IsDark ? TMinC(s.SecondaryPalette, 0, 98) : TMaxC(s.SecondaryPalette); + if (s.Variant == Variant.VIBRANT) return TMaxC(s.SecondaryPalette, 0, s.IsDark ? 90 : 98); + // EXPRESSIVE, TONAL_SPOT + return s.IsDark ? 80.0 : TMaxC(s.SecondaryPalette); + }) + .SetIsBackground(true) + .SetBackground(s => + { + if (s.PlatformType == Platform.PHONE) return s.IsDark ? SurfaceBright : SurfaceDim; + return SurfaceContainerHigh; + }) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(4.5) : GetContrastCurve(7)) + .SetToneDeltaPair(s => s.PlatformType == Platform.PHONE + ? new ToneDeltaPair(SecondaryContainer, Secondary, 5.0, TonePolarity.RELATIVE_LIGHTER, DeltaConstraint.FARTHER) + : null!) + .Build(); + return base.Secondary.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor? SecondaryDim + { + get + { + return new DynamicColor.Builder() + .SetName("secondary_dim") + .SetPalette(s => s.SecondaryPalette) + .SetTone(s => + { + if (s.Variant == Variant.NEUTRAL) return 85.0; + return TMaxC(s.SecondaryPalette, 0, 90); + }) + .SetIsBackground(true) + .SetBackground(s => SurfaceContainerHigh) + .SetContrastCurve(s => GetContrastCurve(4.5)) + .SetToneDeltaPair(s => new ToneDeltaPair(SecondaryDim!, Secondary, 5.0, TonePolarity.DARKER, DeltaConstraint.FARTHER)) + .Build(); + } + } + + public new DynamicColor OnSecondary + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_secondary") + .SetPalette(s => s.SecondaryPalette) + .SetBackground(s => s.PlatformType == Platform.PHONE ? Secondary : SecondaryDim!) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(6) : GetContrastCurve(7)) + .Build(); + return base.OnSecondary.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor SecondaryContainer + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("secondary_container") + .SetPalette(s => s.SecondaryPalette) + .SetTone(s => + { + if (s.PlatformType == Platform.WATCH) return 30.0; + if (s.Variant == Variant.VIBRANT) return s.IsDark ? TMinC(s.SecondaryPalette, 30, 40) : TMaxC(s.SecondaryPalette, 84, 90); + if (s.Variant == Variant.EXPRESSIVE) return s.IsDark ? 15.0 : TMaxC(s.SecondaryPalette, 90, 95); + return s.IsDark ? 25.0 : 90.0; + }) + .SetIsBackground(true) + .SetBackground(s => + { + if (s.PlatformType == Platform.PHONE) return s.IsDark ? SurfaceBright : SurfaceDim; + return null!; + }) + .SetToneDeltaPair(s => s.PlatformType == Platform.WATCH ? new ToneDeltaPair(SecondaryContainer, SecondaryDim!, 10.0, TonePolarity.DARKER, DeltaConstraint.FARTHER) : null!) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE && s.ContrastLevel > 0 ? GetContrastCurve(1.5) : null!) + .Build(); + return base.SecondaryContainer.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor OnSecondaryContainer + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_secondary_container") + .SetPalette(s => s.SecondaryPalette) + .SetBackground(s => SecondaryContainer) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(6) : GetContrastCurve(7)) + .Build(); + return base.OnSecondaryContainer.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + // Tertiaries [T] + public new DynamicColor Tertiary + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("tertiary") + .SetPalette(s => s.TertiaryPalette) + .SetTone(s => + { + if (s.PlatformType == Platform.WATCH) + { + return s.Variant == Variant.TONAL_SPOT ? TMaxC(s.TertiaryPalette, 0, 90) : TMaxC(s.TertiaryPalette); + } + else if (s.Variant == Variant.EXPRESSIVE || s.Variant == Variant.VIBRANT) + { + return TMaxC(s.TertiaryPalette, 0, Hct.IsCyan(s.TertiaryPalette.GetHue()) ? 88 : (s.IsDark ? 98 : 100)); + } + else // NEUTRAL, TONAL_SPOT + { + return s.IsDark ? TMaxC(s.TertiaryPalette, 0, 98) : TMaxC(s.TertiaryPalette); + } + }) + .SetIsBackground(true) + .SetBackground(s => + { + if (s.PlatformType == Platform.PHONE) return s.IsDark ? SurfaceBright : SurfaceDim; + return SurfaceContainerHigh; + }) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(4.5) : GetContrastCurve(7)) + .SetToneDeltaPair(s => s.PlatformType == Platform.PHONE ? new ToneDeltaPair(TertiaryContainer, Tertiary, 5.0, TonePolarity.RELATIVE_LIGHTER, DeltaConstraint.FARTHER) : null!) + .Build(); + return base.Tertiary.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor? TertiaryDim + { + get + { + return new DynamicColor.Builder() + .SetName("tertiary_dim") + .SetPalette(s => s.TertiaryPalette) + .SetTone(s => s.Variant == Variant.TONAL_SPOT ? TMaxC(s.TertiaryPalette, 0, 90) : TMaxC(s.TertiaryPalette)) + .SetIsBackground(true) + .SetBackground(s => SurfaceContainerHigh) + .SetContrastCurve(s => GetContrastCurve(4.5)) + .SetToneDeltaPair(s => new ToneDeltaPair(TertiaryDim!, Tertiary, 5.0, TonePolarity.DARKER, DeltaConstraint.FARTHER)) + .Build(); + } + } + + public new DynamicColor OnTertiary + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_tertiary") + .SetPalette(s => s.TertiaryPalette) + .SetBackground(s => s.PlatformType == Platform.PHONE ? Tertiary : TertiaryDim!) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(6) : GetContrastCurve(7)) + .Build(); + return base.OnTertiary.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor TertiaryContainer + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("tertiary_container") + .SetPalette(s => s.TertiaryPalette) + .SetTone(s => + { + if (s.PlatformType == Platform.WATCH) + { + return s.Variant == Variant.TONAL_SPOT ? TMaxC(s.TertiaryPalette, 0, 90) : TMaxC(s.TertiaryPalette); + } + else + { + if (s.Variant == Variant.NEUTRAL) + { + return s.IsDark ? TMaxC(s.TertiaryPalette, 0, 93) : TMaxC(s.TertiaryPalette, 0, 96); + } + else if (s.Variant == Variant.TONAL_SPOT) + { + return TMaxC(s.TertiaryPalette, 0, s.IsDark ? 93 : 100); + } + else if (s.Variant == Variant.EXPRESSIVE) + { + return TMaxC(s.TertiaryPalette, 75, Hct.IsCyan(s.TertiaryPalette.GetHue()) ? 88 : (s.IsDark ? 93 : 100)); + } + else // VIBRANT + { + return s.IsDark ? TMaxC(s.TertiaryPalette, 0, 93) : TMaxC(s.TertiaryPalette, 72, 100); + } + } + }) + .SetIsBackground(true) + .SetBackground(s => + { + if (s.PlatformType == Platform.PHONE) return s.IsDark ? SurfaceBright : SurfaceDim; + return null!; + }) + .SetToneDeltaPair(s => s.PlatformType == Platform.WATCH ? new ToneDeltaPair(TertiaryContainer, TertiaryDim!, 10.0, TonePolarity.DARKER, DeltaConstraint.FARTHER) : null!) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE && s.ContrastLevel > 0 ? GetContrastCurve(1.5) : null!) + .Build(); + return base.TertiaryContainer.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor OnTertiaryContainer + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_tertiary_container") + .SetPalette(s => s.TertiaryPalette) + .SetBackground(s => TertiaryContainer) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(6) : GetContrastCurve(7)) + .Build(); + return base.OnTertiaryContainer.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + // Errors [E] + public new DynamicColor Error + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("error") + .SetPalette(s => s.ErrorPalette) + .SetTone(s => + { + if (s.PlatformType == Platform.PHONE) return s.IsDark ? TMinC(s.ErrorPalette, 0, 98) : TMaxC(s.ErrorPalette); + return TMinC(s.ErrorPalette); + }) + .SetIsBackground(true) + .SetBackground(s => s.PlatformType == Platform.PHONE ? (s.IsDark ? SurfaceBright : SurfaceDim) : SurfaceContainerHigh) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(4.5) : GetContrastCurve(7)) + .SetToneDeltaPair(s => s.PlatformType == Platform.PHONE ? new ToneDeltaPair(ErrorContainer, Error, 5.0, TonePolarity.RELATIVE_LIGHTER, DeltaConstraint.FARTHER) : null!) + .Build(); + return base.Error.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor? ErrorDim + { + get + { + return new DynamicColor.Builder() + .SetName("error_dim") + .SetPalette(s => s.ErrorPalette) + .SetTone(s => TMinC(s.ErrorPalette)) + .SetIsBackground(true) + .SetBackground(s => SurfaceContainerHigh) + .SetContrastCurve(s => GetContrastCurve(4.5)) + .SetToneDeltaPair(s => new ToneDeltaPair(ErrorDim!, Error, 5.0, TonePolarity.DARKER, DeltaConstraint.FARTHER)) + .Build(); + } + } + + public new DynamicColor OnError + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_error") + .SetPalette(s => s.ErrorPalette) + .SetBackground(s => s.PlatformType == Platform.PHONE ? Error : ErrorDim!) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(6) : GetContrastCurve(7)) + .Build(); + return base.OnError.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor ErrorContainer + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("error_container") + .SetPalette(s => s.ErrorPalette) + .SetTone(s => + { + if (s.PlatformType == Platform.WATCH) return 30.0; + return s.IsDark ? TMinC(s.ErrorPalette, 30, 93) : TMaxC(s.ErrorPalette, 0, 90); + }) + .SetIsBackground(true) + .SetBackground(s => s.PlatformType == Platform.PHONE ? (s.IsDark ? SurfaceBright : SurfaceDim) : null!) + .SetToneDeltaPair(s => s.PlatformType == Platform.WATCH ? new ToneDeltaPair(ErrorContainer, ErrorDim!, 10.0, TonePolarity.DARKER, DeltaConstraint.FARTHER) : null!) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE && s.ContrastLevel > 0 ? GetContrastCurve(1.5) : null!) + .Build(); + return base.ErrorContainer.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor OnErrorContainer + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_error_container") + .SetPalette(s => s.ErrorPalette) + .SetBackground(s => ErrorContainer) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(4.5) : GetContrastCurve(7)) + .Build(); + return base.OnErrorContainer.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + // Primary Fixed Colors [PF] + public new DynamicColor PrimaryFixed + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("primary_fixed") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => + { + var tempS = DynamicScheme.From(s, false, 0.0); + return PrimaryContainer.GetTone(tempS); + }) + .SetIsBackground(true) + .SetBackground(s => s.PlatformType == Platform.PHONE ? (s.IsDark ? SurfaceBright : SurfaceDim) : null!) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE && s.ContrastLevel > 0 ? GetContrastCurve(1.5) : null!) + .Build(); + return base.PrimaryFixed.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor PrimaryFixedDim + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("primary_fixed_dim") + .SetPalette(s => s.PrimaryPalette) + .SetTone(s => PrimaryFixed.GetTone(s)) + .SetIsBackground(true) + .SetToneDeltaPair(s => new ToneDeltaPair(PrimaryFixedDim, PrimaryFixed, 5.0, TonePolarity.DARKER, DeltaConstraint.EXACT)) + .Build(); + return base.PrimaryFixedDim.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor OnPrimaryFixed + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_primary_fixed") + .SetPalette(s => s.PrimaryPalette) + .SetBackground(s => PrimaryFixedDim) + .SetContrastCurve(s => GetContrastCurve(7)) + .Build(); + return base.OnPrimaryFixed.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor OnPrimaryFixedVariant + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_primary_fixed_variant") + .SetPalette(s => s.PrimaryPalette) + .SetBackground(s => PrimaryFixedDim) + .SetContrastCurve(s => GetContrastCurve(4.5)) + .Build(); + return base.OnPrimaryFixedVariant.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + // Secondary Fixed Colors [QF] + public new DynamicColor SecondaryFixed + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("secondary_fixed") + .SetPalette(s => s.SecondaryPalette) + .SetTone(s => + { + var tempS = DynamicScheme.From(s, false, 0.0); + return SecondaryContainer.GetTone(tempS); + }) + .SetIsBackground(true) + .SetBackground(s => s.PlatformType == Platform.PHONE ? (s.IsDark ? SurfaceBright : SurfaceDim) : null!) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE && s.ContrastLevel > 0 ? GetContrastCurve(1.5) : null!) + .Build(); + return base.SecondaryFixed.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor SecondaryFixedDim + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("secondary_fixed_dim") + .SetPalette(s => s.SecondaryPalette) + .SetTone(s => SecondaryFixed.GetTone(s)) + .SetIsBackground(true) + .SetToneDeltaPair(s => new ToneDeltaPair(SecondaryFixedDim, SecondaryFixed, 5.0, TonePolarity.DARKER, DeltaConstraint.EXACT)) + .Build(); + return base.SecondaryFixedDim.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor OnSecondaryFixed + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_secondary_fixed") + .SetPalette(s => s.SecondaryPalette) + .SetBackground(s => SecondaryFixedDim) + .SetContrastCurve(s => GetContrastCurve(7)) + .Build(); + return base.OnSecondaryFixed.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor OnSecondaryFixedVariant + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_secondary_fixed_variant") + .SetPalette(s => s.SecondaryPalette) + .SetBackground(s => SecondaryFixedDim) + .SetContrastCurve(s => GetContrastCurve(4.5)) + .Build(); + return base.OnSecondaryFixedVariant.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + // Tertiary Fixed Colors [TF] + public new DynamicColor TertiaryFixed + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("tertiary_fixed") + .SetPalette(s => s.TertiaryPalette) + .SetTone(s => + { + var tempS = DynamicScheme.From(s, false, 0.0); + return TertiaryContainer.GetTone(tempS); + }) + .SetIsBackground(true) + .SetBackground(s => s.PlatformType == Platform.PHONE ? (s.IsDark ? SurfaceBright : SurfaceDim) : null!) + .SetContrastCurve(s => s.PlatformType == Platform.PHONE && s.ContrastLevel > 0 ? GetContrastCurve(1.5) : null!) + .Build(); + return base.TertiaryFixed.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor TertiaryFixedDim + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("tertiary_fixed_dim") + .SetPalette(s => s.TertiaryPalette) + .SetTone(s => TertiaryFixed.GetTone(s)) + .SetIsBackground(true) + .SetToneDeltaPair(s => new ToneDeltaPair(TertiaryFixedDim, TertiaryFixed, 5.0, TonePolarity.DARKER, DeltaConstraint.EXACT)) + .Build(); + return base.TertiaryFixedDim.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor OnTertiaryFixed + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_tertiary_fixed") + .SetPalette(s => s.TertiaryPalette) + .SetBackground(s => TertiaryFixedDim) + .SetContrastCurve(s => GetContrastCurve(7)) + .Build(); + return base.OnTertiaryFixed.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor OnTertiaryFixedVariant + { + get + { + var color2025 = new DynamicColor.Builder() + .SetName("on_tertiary_fixed_variant") + .SetPalette(s => s.TertiaryPalette) + .SetBackground(s => TertiaryFixedDim) + .SetContrastCurve(s => GetContrastCurve(4.5)) + .Build(); + return base.OnTertiaryFixedVariant.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + // Android-only colors + public new DynamicColor ControlActivated + { + get + { + var color2025 = PrimaryContainer.ToBuilder().SetName("control_activated").Build(); + return base.ControlActivated.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor ControlNormal + { + get + { + var color2025 = OnSurfaceVariant.ToBuilder().SetName("control_normal").Build(); + return base.ControlNormal.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + public new DynamicColor TextPrimaryInverse + { + get + { + var color2025 = InverseOnSurface.ToBuilder().SetName("text_primary_inverse").Build(); + return base.TextPrimaryInverse.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); + } + } + + // Other helpers + private static double FindBestToneForChroma(double hue, double chroma, double tone, bool byDecreasingTone) + { + var answer = tone; + var bestCandidate = Hct.From(hue, chroma, answer); + while (bestCandidate.Chroma < chroma) + { + if (tone < 0 || tone > 100) break; + tone += byDecreasingTone ? -1.0 : 1.0; + var newCandidate = Hct.From(hue, chroma, tone); + if (bestCandidate.Chroma < newCandidate.Chroma) + { + bestCandidate = newCandidate; + answer = tone; + } + } + return answer; + } + + private static double TMaxC(TonalPalette palette) + { + return TMaxC(palette, 0, 100); + } + + private static double TMaxC(TonalPalette palette, double lowerBound, double upperBound) + { + return TMaxC(palette, lowerBound, upperBound, 1.0); + } + + private static double TMaxC(TonalPalette palette, double lowerBound, double upperBound, double chromaMultiplier) + { + var answer = FindBestToneForChroma(palette.GetHue(), palette.GetChroma() * chromaMultiplier, 100, true); + return MathUtils.ClampDouble(lowerBound, upperBound, answer); + } + + private static double TMinC(TonalPalette palette) + { + return TMinC(palette, 0, 100); + } + + private static double TMinC(TonalPalette palette, double lowerBound, double upperBound) + { + var answer = FindBestToneForChroma(palette.GetHue(), palette.GetChroma(), 0, false); + return MathUtils.ClampDouble(lowerBound, upperBound, answer); + } + + private static ContrastCurve GetContrastCurve(double @default) + { + if (@default == 1.5) return new ContrastCurve(1.5, 1.5, 3, 4.5); + if (@default == 3.0) return new ContrastCurve(3, 3, 4.5, 7); + if (@default == 4.5) return new ContrastCurve(4.5, 4.5, 7, 11); + if (@default == 6.0) return new ContrastCurve(6, 6, 7, 11); + if (@default == 7.0) return new ContrastCurve(7, 7, 11, 21); + if (@default == 9.0) return new ContrastCurve(9, 9, 11, 21); + if (@default == 11.0) return new ContrastCurve(11, 11, 21, 21); + if (@default == 21.0) return new ContrastCurve(21, 21, 21, 21); + return new ContrastCurve(@default, @default, 7, 21); + } + + // Color value calculations (2025 overrides) + public new Hct GetHct(DynamicScheme scheme, DynamicColor color) + { + var palette = color.palette(scheme); + var tone = GetTone(scheme, color); + var hue = palette.GetHue(); + var chromaMultiplier = color.chromaMultiplier?.Invoke(scheme) ?? 1.0; + var chroma = palette.GetChroma() * chromaMultiplier; + return Hct.From(hue, chroma, tone); + } + + public new double GetTone(DynamicScheme scheme, DynamicColor color) + { + var toneDeltaPair = color.toneDeltaPair == null ? null : color.toneDeltaPair(scheme); + + if (toneDeltaPair != null) + { + var roleA = toneDeltaPair.RoleA; + var roleB = toneDeltaPair.RoleB; + var polarity = toneDeltaPair.Polarity; + var constraint = toneDeltaPair.Constraint; + var absoluteDelta = (polarity == TonePolarity.DARKER || (polarity == TonePolarity.RELATIVE_LIGHTER && scheme.IsDark) || (polarity == TonePolarity.RELATIVE_DARKER && !scheme.IsDark)) + ? -toneDeltaPair.Delta : toneDeltaPair.Delta; + + var amRoleA = color.name.Equals(roleA.name); + var selfRole = amRoleA ? roleA : roleB; + var referenceRole = amRoleA ? roleB : roleA; + var selfTone = selfRole.tone(scheme); + var referenceTone = referenceRole.GetTone(scheme); + var relativeDelta = absoluteDelta * (amRoleA ? 1 : -1); + + switch (constraint) + { + case DeltaConstraint.EXACT: + selfTone = MathUtils.ClampDouble(0, 100, referenceTone + relativeDelta); + break; + case DeltaConstraint.NEARER: + if (relativeDelta > 0) + { + selfTone = MathUtils.ClampDouble(0, 100, MathUtils.ClampDouble(referenceTone, referenceTone + relativeDelta, selfTone)); + } + else + { + selfTone = MathUtils.ClampDouble(0, 100, MathUtils.ClampDouble(referenceTone + relativeDelta, referenceTone, selfTone)); + } + break; + case DeltaConstraint.FARTHER: + if (relativeDelta > 0) + { + selfTone = MathUtils.ClampDouble(referenceTone + relativeDelta, 100, selfTone); + } + else + { + selfTone = MathUtils.ClampDouble(0, referenceTone + relativeDelta, selfTone); + } + break; + } + + if (color.background != null && color.contrastCurve != null) + { + var background = color.background(scheme); + var contrastCurve = color.contrastCurve(scheme); + if (background != null && contrastCurve != null) + { + var bgTone = background.GetTone(scheme); + var selfContrast = contrastCurve.Get(scheme.ContrastLevel); + selfTone = (Contrast.RatioOfTones(bgTone, selfTone) >= selfContrast && scheme.ContrastLevel >= 0) + ? selfTone + : DynamicColor.ForegroundTone(bgTone, selfContrast); + } + } + + // Avoid awkward tones for backgrounds (except *_fixed_dim) + if (color.isBackground && !color.name.EndsWith("_fixed_dim")) + { + if (selfTone >= 57) + { + selfTone = MathUtils.ClampDouble(65, 100, selfTone); + } + else + { + selfTone = MathUtils.ClampDouble(0, 49, selfTone); + } + } + + return selfTone; + } + else + { + var answer = color.tone(scheme); + + if (color.background == null || color.background(scheme) == null || color.contrastCurve == null || color.contrastCurve(scheme) == null) + { + return answer; + } + + var bgTone = color.background(scheme).GetTone(scheme); + var desiredRatio = color.contrastCurve(scheme).Get(scheme.ContrastLevel); + + answer = (Contrast.RatioOfTones(bgTone, answer) >= desiredRatio && scheme.ContrastLevel >= 0) + ? answer + : DynamicColor.ForegroundTone(bgTone, desiredRatio); + + // Avoid awkward tones for backgrounds (except *_fixed_dim) + if (color.isBackground && !color.name.EndsWith("_fixed_dim")) + { + if (answer >= 57) + { + answer = MathUtils.ClampDouble(65, 100, answer); + } + else + { + answer = MathUtils.ClampDouble(0, 49, answer); + } + } + + if (color.secondBackground == null || color.secondBackground(scheme) == null) + { + return answer; + } + + var bgTone1 = color.background(scheme).GetTone(scheme); + var bgTone2 = color.secondBackground(scheme).GetTone(scheme); + var upper = System.Math.Max(bgTone1, bgTone2); + var lower = System.Math.Min(bgTone1, bgTone2); + + if (Contrast.RatioOfTones(upper, answer) >= desiredRatio && Contrast.RatioOfTones(lower, answer) >= desiredRatio) + { + return answer; + } + + var lightOption = Contrast.Lighter(upper, desiredRatio); + var darkOption = Contrast.Darker(lower, desiredRatio); + + var prefersLight = DynamicColor.TonePrefersLightForeground(bgTone1) || DynamicColor.TonePrefersLightForeground(bgTone2); + if (prefersLight) + { + return (lightOption < 0) ? 100 : lightOption; + } + if (lightOption >= 0 && darkOption < 0) + { + return lightOption; + } + return (darkOption < 0) ? 0 : darkOption; + } + } + + // Scheme Palettes + public new TonalPalette GetPrimaryPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel) + { + return variant switch + { + Variant.NEUTRAL => TonalPalette.FromHueAndChroma( + sourceColorHct.Hue, + platform == Platform.PHONE ? (Hct.IsBlue(sourceColorHct.Hue) ? 12 : 8) : (Hct.IsBlue(sourceColorHct.Hue) ? 16 : 12)), + Variant.TONAL_SPOT => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, platform == Platform.PHONE && isDark ? 26 : 32), + Variant.EXPRESSIVE => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, platform == Platform.PHONE ? (isDark ? 36 : 48) : 40), + Variant.VIBRANT => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, platform == Platform.PHONE ? 74 : 56), + _ => base.GetPrimaryPalette(variant, sourceColorHct, isDark, platform, contrastLevel), + }; + } + + public new TonalPalette GetSecondaryPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel) + { + return variant switch + { + Variant.NEUTRAL => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, platform == Platform.PHONE ? (Hct.IsBlue(sourceColorHct.Hue) ? 6 : 4) : (Hct.IsBlue(sourceColorHct.Hue) ? 10 : 6)), + Variant.TONAL_SPOT => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, 16), + Variant.EXPRESSIVE => TonalPalette.FromHueAndChroma( + DynamicScheme.GetRotatedHue( + sourceColorHct, + [0.0, 105.0, 140.0, 204.0, 253.0, 278.0, 300.0, 333.0, 360.0], + [-160.0, 155.0, -100.0, 96.0, -96.0, -156.0, -165.0, -160.0] + ), platform == Platform.PHONE ? (isDark ? 16 : 24) : 24), + Variant.VIBRANT => TonalPalette.FromHueAndChroma( + DynamicScheme.GetRotatedHue( + sourceColorHct, + [0.0, 38.0, 105.0, 140.0, 333.0, 360.0], + [-14.0, 10.0, -14.0, 10.0, -14.0] + ), platform == Platform.PHONE ? 56 : 36), + _ => base.GetSecondaryPalette(variant, sourceColorHct, isDark, platform, contrastLevel), + }; + } + + public new TonalPalette GetTertiaryPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel) + { + return variant switch + { + Variant.NEUTRAL => TonalPalette.FromHueAndChroma( + DynamicScheme.GetRotatedHue( + sourceColorHct, + [0.0, 38.0, 105.0, 161.0, 204.0, 278.0, 333.0, 360.0], + [-32.0, 26.0, 10.0, -39.0, 24.0, -15.0, -32.0] + ), platform == Platform.PHONE ? 20 : 36), + Variant.TONAL_SPOT => TonalPalette.FromHueAndChroma( + DynamicScheme.GetRotatedHue( + sourceColorHct, + [0.0, 20.0, 71.0, 161.0, 333.0, 360.0], + [-40.0, 48.0, -32.0, 40.0, -32.0] + ), platform == Platform.PHONE ? 28 : 32), + Variant.EXPRESSIVE => TonalPalette.FromHueAndChroma( + DynamicScheme.GetRotatedHue( + sourceColorHct, + [0.0, 105.0, 140.0, 204.0, 253.0, 278.0, 300.0, 333.0, 360.0], + [-165.0, 160.0, -105.0, 101.0, -101.0, -160.0, -170.0, -165.0] + ), 48), + Variant.VIBRANT => TonalPalette.FromHueAndChroma( + DynamicScheme.GetRotatedHue( + sourceColorHct, + [0.0, 38.0, 71.0, 105.0, 140.0, 161.0, 253.0, 333.0, 360.0], + [-72.0, 35.0, 24.0, -24.0, 62.0, 50.0, 62.0, -72.0] + ), 56), + _ => base.GetTertiaryPalette(variant, sourceColorHct, isDark, platform, contrastLevel), + }; + } + + public new TonalPalette GetNeutralPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel) + { + return variant switch + { + Variant.NEUTRAL => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, platform == Platform.PHONE ? 1.4 : 6.0), + Variant.TONAL_SPOT => TonalPalette.FromHueAndChroma(sourceColorHct.Hue, platform == Platform.PHONE ? 5.0 : 10.0), + Variant.EXPRESSIVE => TonalPalette.FromHueAndChroma(GetExpressiveNeutralHue(sourceColorHct), GetExpressiveNeutralChroma(sourceColorHct, isDark, platform)), + Variant.VIBRANT => TonalPalette.FromHueAndChroma(GetVibrantNeutralHue(sourceColorHct), GetVibrantNeutralChroma(sourceColorHct, platform)), + _ => base.GetNeutralPalette(variant, sourceColorHct, isDark, platform, contrastLevel), + }; + } + + public new TonalPalette GetNeutralVariantPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel) + { + switch (variant) + { + case Variant.NEUTRAL: + return TonalPalette.FromHueAndChroma(sourceColorHct.Hue, (platform == Platform.PHONE ? 1.4 : 6.0) * 2.2); + case Variant.TONAL_SPOT: + return TonalPalette.FromHueAndChroma(sourceColorHct.Hue, (platform == Platform.PHONE ? 5.0 : 10.0) * 1.7); + case Variant.EXPRESSIVE: + var expressiveNeutralHue = GetExpressiveNeutralHue(sourceColorHct); + var expressiveNeutralChroma = GetExpressiveNeutralChroma(sourceColorHct, isDark, platform); + return TonalPalette.FromHueAndChroma( + expressiveNeutralHue, + expressiveNeutralChroma * (expressiveNeutralHue >= 105 && expressiveNeutralHue < 125 ? 1.6 : 2.3)); + case Variant.VIBRANT: + var vibrantNeutralHue = GetVibrantNeutralHue(sourceColorHct); + var vibrantNeutralChroma = GetVibrantNeutralChroma(sourceColorHct, platform); + return TonalPalette.FromHueAndChroma(vibrantNeutralHue, vibrantNeutralChroma * 1.29); + default: + return base.GetNeutralVariantPalette(variant, sourceColorHct, isDark, platform, contrastLevel); + } + } + + public new TonalPalette? GetErrorPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel) + { + var errorHue = DynamicScheme.GetPiecewiseValue( + sourceColorHct, + [0.0, 3.0, 13.0, 23.0, 33.0, 43.0, 153.0, 273.0, 360.0], + [12.0, 22.0, 32.0, 12.0, 22.0, 32.0, 22.0, 12.0]); + return variant switch + { + Variant.NEUTRAL => TonalPalette.FromHueAndChroma(errorHue, platform == Platform.PHONE ? 50.0 : 40.0), + Variant.TONAL_SPOT => TonalPalette.FromHueAndChroma(errorHue, platform == Platform.PHONE ? 60.0 : 48.0), + Variant.EXPRESSIVE => TonalPalette.FromHueAndChroma(errorHue, platform == Platform.PHONE ? 64.0 : 48.0), + Variant.VIBRANT => TonalPalette.FromHueAndChroma(errorHue, platform == Platform.PHONE ? 80.0 : 60.0), + _ => base.GetErrorPalette(variant, sourceColorHct, isDark, platform, contrastLevel), + }; + } + + private static double GetExpressiveNeutralHue(Hct sourceColorHct) + { + return DynamicScheme.GetRotatedHue( + sourceColorHct, + [0.0, 71.0, 124.0, 253.0, 278.0, 300.0, 360.0], + [10.0, 0.0, 10.0, 0.0, 10.0, 0.0]); + } + + private static double GetExpressiveNeutralChroma(Hct sourceColorHct, bool isDark, Platform platform) + { + var neutralHue = GetExpressiveNeutralHue(sourceColorHct); + return platform == Platform.PHONE ? (isDark ? (Hct.IsYellow(neutralHue) ? 6.0 : 14.0) : 18.0) : 12.0; + } + + private static double GetVibrantNeutralHue(Hct sourceColorHct) + { + return DynamicScheme.GetRotatedHue( + sourceColorHct, + [0.0, 38.0, 105.0, 140.0, 333.0, 360.0], + [-14.0, 10.0, -14.0, 10.0, -14.0]); + } + + private static double GetVibrantNeutralChroma(Hct sourceColorHct, Platform platform) + { + var neutralHue = GetVibrantNeutralHue(sourceColorHct); + return platform == Platform.PHONE ? 28.0 : (Hct.IsBlue(neutralHue) ? 28.0 : 20.0); + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpecs.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpecs.cs new file mode 100644 index 0000000000..255a979daa --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpecs.cs @@ -0,0 +1,17 @@ +namespace MaterialColorUtilities; + +public static class ColorSpecs +{ + private static readonly ColorSpec SPEC_2021 = new ColorSpec2021(); + private static readonly ColorSpec SPEC_2025 = new ColorSpec2025(); + + public static ColorSpec Get() + { + return Get(SpecVersion.SPEC_2021); + } + + public static ColorSpec Get(SpecVersion specVersion) + { + return specVersion == SpecVersion.SPEC_2025 ? SPEC_2025 : SPEC_2021; + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ContrastCurve.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ContrastCurve.cs new file mode 100644 index 0000000000..fc39fb332d --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ContrastCurve.cs @@ -0,0 +1,18 @@ +using static MaterialColorUtilities.MathUtils; + +namespace MaterialColorUtilities; + +public record ContrastCurve(double Low, double Normal, double Medium, double High) +{ + public double Get(double contrastLevel) + { + return contrastLevel switch + { + <= -1.0 => Low, + < 0.0 => Lerp(Low, Normal, (contrastLevel - -1.0) / 1.0), + < 0.5 => Lerp(Normal, Medium, (contrastLevel - 0.0) / 0.5), + < 1.0 => Lerp(Medium, High, (contrastLevel - 0.5) / 0.5), + _ => High + }; + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DeltaConstraint.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DeltaConstraint.cs new file mode 100644 index 0000000000..1f8d9acb12 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DeltaConstraint.cs @@ -0,0 +1,8 @@ +namespace MaterialColorUtilities; + +public enum DeltaConstraint +{ + EXACT, + NEARER, + FARTHER +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicColor.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicColor.cs new file mode 100644 index 0000000000..8aba4a353a --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicColor.cs @@ -0,0 +1,332 @@ +using static System.Math; + +namespace MaterialColorUtilities; + +public sealed class DynamicColor +{ + public readonly string name; + public readonly Func palette; + public readonly Func tone; + public readonly bool isBackground; + public readonly Func? chromaMultiplier; + public readonly Func? background; + public readonly Func? secondBackground; + public readonly Func? contrastCurve; + public readonly Func? toneDeltaPair; + public readonly Func? opacity; + + private readonly Dictionary hctCache = new(); + + public DynamicColor( + string name, + Func palette, + Func tone, + bool isBackground, + Func? background, + Func? secondBackground, + ContrastCurve? contrastCurve, + Func? toneDeltaPair) + : this( + name, + palette, + tone, + isBackground, + null, + background, + secondBackground, + contrastCurve == null ? null : _ => contrastCurve, + toneDeltaPair, + null) + { + } + + public DynamicColor( + string name, + Func palette, + Func tone, + bool isBackground, + Func? background, + Func? secondBackground, + ContrastCurve? contrastCurve, + Func? toneDeltaPair, + Func? opacity) + : this( + name, + palette, + tone, + isBackground, + null, + background, + secondBackground, + contrastCurve == null ? null : _ => contrastCurve, + toneDeltaPair, + opacity) + { + } + + public DynamicColor( + string name, + Func palette, + Func tone, + bool isBackground, + Func? chromaMultiplier, + Func? background, + Func? secondBackground, + Func? contrastCurve, + Func? toneDeltaPair, + Func? opacity) + { + this.name = name; + this.palette = palette; + this.tone = tone; + this.isBackground = isBackground; + this.chromaMultiplier = chromaMultiplier; + this.background = background; + this.secondBackground = secondBackground; + this.contrastCurve = contrastCurve; + this.toneDeltaPair = toneDeltaPair; + this.opacity = opacity; + } + + public static DynamicColor FromPalette( + string name, + Func palette, + Func tone) + { + return new DynamicColor( + name, + palette, + tone, + false, + null, + null, + null, + null); + } + + public static DynamicColor FromPalette( + string name, + Func palette, + Func tone, + bool isBackground) + { + return new DynamicColor( + name, + palette, + tone, + isBackground, + null, + null, + null, + null); + } + + public static DynamicColor FromArgb(string name, int argb) + { + var hct = Hct.FromInt(argb); + var palette = TonalPalette.FromInt(argb); + return FromPalette(name, _ => palette, _ => hct.Tone); + } + + public int GetArgb(DynamicScheme scheme) + { + var argb = GetHct(scheme).Argb; + if (opacity == null) + { + return argb; + } + var percentage = opacity(scheme); + var alpha = MathUtils.ClampInt(0, 255, (int)Round(percentage * 255.0)); + return (argb & 0x00ffffff) | (alpha << 24); + } + + public Hct GetHct(DynamicScheme scheme) + { + if (hctCache.TryGetValue(scheme, out var cached)) + { + return cached; + } + var answer = ColorSpecs.Get(scheme.SpecVersion).GetHct(scheme, this); + if (hctCache.Count > 4) + { + hctCache.Clear(); + } + hctCache[scheme] = answer; + return answer; + } + + public double GetTone(DynamicScheme scheme) + { + return ColorSpecs.Get(scheme.SpecVersion).GetTone(scheme, this); + } + + public static double ForegroundTone(double bgTone, double ratio) + { + var lighterTone = Contrast.LighterUnsafe(bgTone, ratio); + var darkerTone = Contrast.DarkerUnsafe(bgTone, ratio); + var lighterRatio = Contrast.RatioOfTones(lighterTone, bgTone); + var darkerRatio = Contrast.RatioOfTones(darkerTone, bgTone); + var preferLighter = TonePrefersLightForeground(bgTone); + + if (preferLighter) + { + var negligibleDifference = + Abs(lighterRatio - darkerRatio) < 0.1 && lighterRatio < ratio && darkerRatio < ratio; + if (lighterRatio >= ratio || lighterRatio >= darkerRatio || negligibleDifference) + { + return lighterTone; + } + else + { + return darkerTone; + } + } + else + { + return (darkerRatio >= ratio || darkerRatio >= lighterRatio) ? darkerTone : lighterTone; + } + } + + public static double EnableLightForeground(double tone) + { + if (TonePrefersLightForeground(tone) && !ToneAllowsLightForeground(tone)) + { + return 49.0; + } + return tone; + } + + public static bool TonePrefersLightForeground(double tone) + { + return Round(tone) < 60.0; + } + + public static bool ToneAllowsLightForeground(double tone) + { + return Round(tone) <= 49.0; + } + + public static Func GetInitialToneFromBackground( + Func? background) + { + if (background == null) + { + return _ => 50.0; + } + + return s => + { + var bg = background(s); + return bg?.GetTone(s) ?? 50.0; + }; + } + + public Builder ToBuilder() + { + return new Builder() + .SetName(name) + .SetPalette(palette) + .SetTone(tone) + .SetIsBackground(isBackground) + .SetChromaMultiplier(chromaMultiplier ?? (_ => 1.0)) + .SetBackground(background ?? (_ => null!)) + .SetSecondBackground(secondBackground ?? (_ => null!)) + .SetContrastCurve(contrastCurve ?? (_ => null!)) + .SetToneDeltaPair(toneDeltaPair ?? (_ => null!)) + .SetOpacity(opacity ?? (_ => 1.0)); + } + + public sealed class Builder + { + private string? _name; + private Func? _palette; + private Func? _tone; + private bool _isBackground; + private Func? _chromaMultiplier; + private Func? _background; + private Func? _secondBackground; + private Func? _contrastCurve; + private Func? _toneDeltaPair; + private Func? _opacity; + + public Builder SetName(string name) { _name = name; return this; } + public Builder SetPalette(Func palette) { _palette = palette; return this; } + public Builder SetTone(Func tone) { _tone = tone; return this; } + public Builder SetIsBackground(bool isBackground) { _isBackground = isBackground; return this; } + public Builder SetChromaMultiplier(Func chromaMultiplier) { _chromaMultiplier = chromaMultiplier; return this; } + public Builder SetBackground(Func background) { _background = background; return this; } + public Builder SetSecondBackground(Func secondBackground) { _secondBackground = secondBackground; return this; } + public Builder SetContrastCurve(Func contrastCurve) { _contrastCurve = contrastCurve; return this; } + public Builder SetToneDeltaPair(Func toneDeltaPair) { _toneDeltaPair = toneDeltaPair; return this; } + public Builder SetOpacity(Func opacity) { _opacity = opacity; return this; } + + public Builder ExtendSpecVersion(SpecVersion specVersion, DynamicColor extendedColor) + { + ValidateExtendedColor(specVersion, extendedColor); + + var prevName = _name; + var prevIsBg = _isBackground; + var prevPalette = _palette; + var prevTone = _tone; + var prevChromaMultiplier = _chromaMultiplier; + var prevBackground = _background; + var prevSecondBackground = _secondBackground; + var prevContrastCurve = _contrastCurve; + var prevToneDeltaPair = _toneDeltaPair; + var prevOpacity = _opacity; + + return new Builder() + .SetName(prevName!) + .SetIsBackground(prevIsBg) + .SetPalette(s => (s.SpecVersion == specVersion ? extendedColor.palette : prevPalette)!.Invoke(s)) + .SetTone(s => (s.SpecVersion == specVersion ? extendedColor.tone : prevTone ?? GetInitialToneFromBackground(prevBackground!))(s)) + .SetChromaMultiplier(s => (s.SpecVersion == specVersion ? extendedColor.chromaMultiplier : prevChromaMultiplier)?.Invoke(s) ?? 1.0) + .SetBackground(s => (s.SpecVersion == specVersion ? extendedColor.background : prevBackground)?.Invoke(s)!) + .SetSecondBackground(s => (s.SpecVersion == specVersion ? extendedColor.secondBackground : prevSecondBackground)?.Invoke(s)!) + .SetContrastCurve(s => (s.SpecVersion == specVersion ? extendedColor.contrastCurve : prevContrastCurve)?.Invoke(s)!) + .SetToneDeltaPair(s => (s.SpecVersion == specVersion ? extendedColor.toneDeltaPair : prevToneDeltaPair)?.Invoke(s)!) + .SetOpacity(s => (s.SpecVersion == specVersion ? extendedColor.opacity : prevOpacity)?.Invoke(s) ?? 1.0); + } + + public DynamicColor Build() + { + if (_background == null && _secondBackground != null) + { + throw new ArgumentException($"Color {_name} has secondBackground defined, but background is not defined."); + } + if (_background == null && _contrastCurve != null) + { + throw new ArgumentException($"Color {_name} has contrastCurve defined, but background is not defined."); + } + if (_background != null && _contrastCurve == null) + { + throw new ArgumentException($"Color {_name} has background defined, but contrastCurve is not defined."); + } + + var finalTone = _tone ?? GetInitialToneFromBackground(_background); + return new DynamicColor( + _name!, + _palette!, + finalTone!, + _isBackground, + _chromaMultiplier, + _background, + _secondBackground, + _contrastCurve, + _toneDeltaPair, + _opacity); + } + + private void ValidateExtendedColor(SpecVersion specVersion, DynamicColor extendedColor) + { + if (!string.Equals(_name, extendedColor.name, StringComparison.Ordinal)) + { + throw new ArgumentException($"Attempting to extend color {_name} with color {extendedColor.name} of different name for spec version {specVersion}."); + } + if (_isBackground != extendedColor.isBackground) + { + throw new ArgumentException($"Attempting to extend color {_name} as a {(_isBackground ? "background" : "foreground")} with color {extendedColor.name} as a {(extendedColor.isBackground ? "background" : "foreground")} for spec version {specVersion}."); + } + } + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicScheme.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicScheme.cs new file mode 100644 index 0000000000..4d53b40371 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicScheme.cs @@ -0,0 +1,176 @@ +using static System.Math; + +namespace MaterialColorUtilities; + +public class DynamicScheme +{ + public static readonly SpecVersion DEFAULT_SPEC_VERSION = SpecVersion.SPEC_2021; + public static readonly Platform DEFAULT_PLATFORM = Platform.PHONE; + + // Core properties + public int SourceColorArgb { get; private set; } + public Hct SourceColorHct { get; } + public Variant Variant { get; } + public bool IsDark { get; } + public Platform PlatformType { get; } + public double ContrastLevel { get; } + public SpecVersion SpecVersion { get; } + + public TonalPalette PrimaryPalette { get; } + public TonalPalette SecondaryPalette { get; } + public TonalPalette TertiaryPalette { get; } + public TonalPalette NeutralPalette { get; } + public TonalPalette NeutralVariantPalette { get; } + public TonalPalette ErrorPalette { get; } + + public DynamicScheme() + { + throw new NotImplementedException(); + } + + public DynamicScheme( + Hct sourceColorHct, + Variant variant, + bool isDark, + double contrastLevel, + TonalPalette primaryPalette, + TonalPalette secondaryPalette, + TonalPalette tertiaryPalette, + TonalPalette neutralPalette, + TonalPalette neutralVariantPalette) + : this( + sourceColorHct, + variant, + isDark, + contrastLevel, + Platform.PHONE, + SpecVersion.SPEC_2021, + primaryPalette, + secondaryPalette, + tertiaryPalette, + neutralPalette, + neutralVariantPalette, + null) + { + } + + public DynamicScheme( + Hct sourceColorHct, + Variant variant, + bool isDark, + double contrastLevel, + TonalPalette primaryPalette, + TonalPalette secondaryPalette, + TonalPalette tertiaryPalette, + TonalPalette neutralPalette, + TonalPalette neutralVariantPalette, + TonalPalette? errorPalette) + : this( + sourceColorHct, + variant, + isDark, + contrastLevel, + Platform.PHONE, + SpecVersion.SPEC_2021, + primaryPalette, + secondaryPalette, + tertiaryPalette, + neutralPalette, + neutralVariantPalette, + errorPalette) + { + } + + public DynamicScheme( + Hct sourceColorHct, + Variant variant, + bool isDark, + double contrastLevel, + Platform platform, + SpecVersion specVersion, + TonalPalette primaryPalette, + TonalPalette secondaryPalette, + TonalPalette tertiaryPalette, + TonalPalette neutralPalette, + TonalPalette neutralVariantPalette, + TonalPalette? errorPalette) + { + SourceColorArgb = sourceColorHct.Argb; + SourceColorHct = sourceColorHct; + Variant = variant; + IsDark = isDark; + ContrastLevel = contrastLevel; + PlatformType = platform; + SpecVersion = specVersion; + + PrimaryPalette = primaryPalette; + SecondaryPalette = secondaryPalette; + TertiaryPalette = tertiaryPalette; + NeutralPalette = neutralPalette; + NeutralVariantPalette = neutralVariantPalette; + ErrorPalette = errorPalette ?? TonalPalette.FromHueAndChroma(25.0, 84.0); + } + + public static DynamicScheme From(DynamicScheme other, bool isDark) + { + return From(other, isDark, other.ContrastLevel); + } + + public static DynamicScheme From(DynamicScheme other, bool isDark, double contrastLevel) + { + return new DynamicScheme( + other.SourceColorHct, + other.Variant, + isDark, + contrastLevel, + other.PlatformType, + other.SpecVersion, + other.PrimaryPalette, + other.SecondaryPalette, + other.TertiaryPalette, + other.NeutralPalette, + other.NeutralVariantPalette, + other.ErrorPalette); + } + + public static double GetPiecewiseValue(Hct sourceColorHct, double[] hueBreakpoints, double[] hues) + { + var size = Min(hueBreakpoints.Length - 1, hues.Length); + var sourceHue = sourceColorHct.Hue; + for (var i = 0; i < size; i++) + { + if (sourceHue >= hueBreakpoints[i] && sourceHue < hueBreakpoints[i + 1]) + { + return MathUtils.SanitizeDegreesDouble(hues[i]); + } + } + // No condition matched, return the source value. + return sourceHue; + } + + public static double GetRotatedHue(Hct sourceColorHct, double[] hueBreakpoints, double[] rotations) + { + var rotation = GetPiecewiseValue(sourceColorHct, hueBreakpoints, rotations); + if (Min(hueBreakpoints.Length - 1, rotations.Length) <= 0) + { + rotation = 0; + } + return MathUtils.SanitizeDegreesDouble(sourceColorHct.Hue + rotation); + } + + public Hct GetHct(DynamicColor dynamicColor) + { + return dynamicColor.GetHct(this); + } + + public int GetArgb(DynamicColor dynamicColor) + { + return dynamicColor.GetArgb(this); + } + + public override string ToString() + { + var mode = IsDark ? "dark" : "light"; + return $"Scheme: variant={Variant}, mode={mode}, platform={PlatformType.ToString().ToLowerInvariant()}, contrastLevel={ContrastLevel:0.0}, seed={SourceColorHct}, specVersion={SpecVersion}"; + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/MaterialDynamicColors.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/MaterialDynamicColors.cs new file mode 100644 index 0000000000..32793d29a5 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/MaterialDynamicColors.cs @@ -0,0 +1,170 @@ +namespace MaterialColorUtilities; + +public sealed class MaterialDynamicColors +{ + private static readonly ColorSpec colorSpec = new ColorSpec2025(); + + public DynamicColor HighestSurface(DynamicScheme s) + { + return colorSpec.HighestSurface(s); + } + + // Main Palettes + public DynamicColor PrimaryPaletteKeyColor => colorSpec.PrimaryPaletteKeyColor; + public DynamicColor SecondaryPaletteKeyColor => colorSpec.SecondaryPaletteKeyColor; + public DynamicColor TertiaryPaletteKeyColor => colorSpec.TertiaryPaletteKeyColor; + public DynamicColor NeutralPaletteKeyColor => colorSpec.NeutralPaletteKeyColor; + public DynamicColor NeutralVariantPaletteKeyColor => colorSpec.NeutralVariantPaletteKeyColor; + public DynamicColor ErrorPaletteKeyColor => colorSpec.ErrorPaletteKeyColor; + + // Surfaces [S] + public DynamicColor Background => colorSpec.Background; + public DynamicColor OnBackground => colorSpec.OnBackground; + public DynamicColor Surface => colorSpec.Surface; + public DynamicColor SurfaceDim => colorSpec.SurfaceDim; + public DynamicColor SurfaceBright => colorSpec.SurfaceBright; + public DynamicColor SurfaceContainerLowest => colorSpec.SurfaceContainerLowest; + public DynamicColor SurfaceContainerLow => colorSpec.SurfaceContainerLow; + public DynamicColor SurfaceContainer => colorSpec.SurfaceContainer; + public DynamicColor SurfaceContainerHigh => colorSpec.SurfaceContainerHigh; + public DynamicColor SurfaceContainerHighest => colorSpec.SurfaceContainerHighest; + public DynamicColor OnSurface => colorSpec.OnSurface; + public DynamicColor SurfaceVariant => colorSpec.SurfaceVariant; + public DynamicColor OnSurfaceVariant => colorSpec.OnSurfaceVariant; + public DynamicColor InverseSurface => colorSpec.InverseSurface; + public DynamicColor InverseOnSurface => colorSpec.InverseOnSurface; + public DynamicColor Outline => colorSpec.Outline; + public DynamicColor OutlineVariant => colorSpec.OutlineVariant; + public DynamicColor Shadow => colorSpec.Shadow; + public DynamicColor Scrim => colorSpec.Scrim; + public DynamicColor SurfaceTint => colorSpec.SurfaceTint; + + // Primaries [P] + public DynamicColor Primary => colorSpec.Primary; + public DynamicColor? PrimaryDim => colorSpec.PrimaryDim; + public DynamicColor OnPrimary => colorSpec.OnPrimary; + public DynamicColor PrimaryContainer => colorSpec.PrimaryContainer; + public DynamicColor OnPrimaryContainer => colorSpec.OnPrimaryContainer; + public DynamicColor InversePrimary => colorSpec.InversePrimary; + + // Secondaries [Q] + public DynamicColor Secondary => colorSpec.Secondary; + public DynamicColor? SecondaryDim => colorSpec.SecondaryDim; + public DynamicColor OnSecondary => colorSpec.OnSecondary; + public DynamicColor SecondaryContainer => colorSpec.SecondaryContainer; + public DynamicColor OnSecondaryContainer => colorSpec.OnSecondaryContainer; + + // Secondary Fixed [QF] + public DynamicColor SecondaryFixed => colorSpec.SecondaryFixed; + public DynamicColor SecondaryFixedDim => colorSpec.SecondaryFixedDim; + public DynamicColor OnSecondaryFixed => colorSpec.OnSecondaryFixed; + public DynamicColor OnSecondaryFixedVariant => colorSpec.OnSecondaryFixedVariant; + + // Tertiaries [T] + public DynamicColor Tertiary => colorSpec.Tertiary; + public DynamicColor? TertiaryDim => colorSpec.TertiaryDim; + public DynamicColor OnTertiary => colorSpec.OnTertiary; + public DynamicColor TertiaryContainer => colorSpec.TertiaryContainer; + public DynamicColor OnTertiaryContainer => colorSpec.OnTertiaryContainer; + + // Tertiary Fixed [TF] + public DynamicColor TertiaryFixed => colorSpec.TertiaryFixed; + public DynamicColor TertiaryFixedDim => colorSpec.TertiaryFixedDim; + public DynamicColor OnTertiaryFixed => colorSpec.OnTertiaryFixed; + public DynamicColor OnTertiaryFixedVariant => colorSpec.OnTertiaryFixedVariant; + + // Errors [E] + public DynamicColor Error => colorSpec.Error; + public DynamicColor? ErrorDim => colorSpec.ErrorDim; + public DynamicColor OnError => colorSpec.OnError; + public DynamicColor ErrorContainer => colorSpec.ErrorContainer; + public DynamicColor OnErrorContainer => colorSpec.OnErrorContainer; + + // Primary Fixed + public DynamicColor PrimaryFixed => colorSpec.PrimaryFixed; + public DynamicColor PrimaryFixedDim => colorSpec.PrimaryFixedDim; + public DynamicColor OnPrimaryFixed => colorSpec.OnPrimaryFixed; + public DynamicColor OnPrimaryFixedVariant => colorSpec.OnPrimaryFixedVariant; + + // Android-only + public DynamicColor ControlActivated => colorSpec.ControlActivated; + public DynamicColor ControlNormal => colorSpec.ControlNormal; + public DynamicColor ControlHighlight => colorSpec.ControlHighlight; + public DynamicColor TextPrimaryInverse => colorSpec.TextPrimaryInverse; + public DynamicColor TextSecondaryAndTertiaryInverse => colorSpec.TextSecondaryAndTertiaryInverse; + public DynamicColor TextPrimaryInverseDisableOnly => colorSpec.TextPrimaryInverseDisableOnly; + public DynamicColor TextSecondaryAndTertiaryInverseDisabled => colorSpec.TextSecondaryAndTertiaryInverseDisabled; + public DynamicColor TextHintInverse => colorSpec.TextHintInverse; + + // All colors + public IEnumerable AllDynamicColors() + { + yield return PrimaryPaletteKeyColor; + yield return SecondaryPaletteKeyColor; + yield return TertiaryPaletteKeyColor; + yield return NeutralPaletteKeyColor; + yield return NeutralVariantPaletteKeyColor; + yield return ErrorPaletteKeyColor; + yield return Background; + yield return OnBackground; + yield return Surface; + yield return SurfaceDim; + yield return SurfaceBright; + yield return SurfaceContainerLowest; + yield return SurfaceContainerLow; + yield return SurfaceContainer; + yield return SurfaceContainerHigh; + yield return SurfaceContainerHighest; + yield return OnSurface; + yield return SurfaceVariant; + yield return OnSurfaceVariant; + yield return Outline; + yield return OutlineVariant; + yield return InverseSurface; + yield return InverseOnSurface; + yield return Shadow; + yield return Scrim; + yield return SurfaceTint; + yield return Primary; + yield return PrimaryDim!; + yield return OnPrimary; + yield return PrimaryContainer; + yield return OnPrimaryContainer; + yield return PrimaryFixed; + yield return PrimaryFixedDim; + yield return OnPrimaryFixed; + yield return OnPrimaryFixedVariant; + yield return InversePrimary; + yield return Secondary; + yield return SecondaryDim!; + yield return OnSecondary; + yield return SecondaryContainer; + yield return OnSecondaryContainer; + yield return SecondaryFixed; + yield return SecondaryFixedDim; + yield return OnSecondaryFixed; + yield return OnSecondaryFixedVariant; + yield return Tertiary; + yield return TertiaryDim!; + yield return OnTertiary; + yield return TertiaryContainer; + yield return OnTertiaryContainer; + yield return TertiaryFixed; + yield return TertiaryFixedDim; + yield return OnTertiaryFixed; + yield return OnTertiaryFixedVariant; + yield return Error; + yield return ErrorDim!; + yield return OnError; + yield return ErrorContainer; + yield return OnErrorContainer; + yield return ControlActivated; + yield return ControlNormal; + yield return ControlHighlight; + yield return TextPrimaryInverse; + yield return TextSecondaryAndTertiaryInverse; + yield return TextPrimaryInverseDisableOnly; + yield return TextSecondaryAndTertiaryInverseDisabled; + yield return TextHintInverse; + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/Platform.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/Platform.cs new file mode 100644 index 0000000000..7424b46ce0 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/Platform.cs @@ -0,0 +1,7 @@ +namespace MaterialColorUtilities; + +public enum Platform +{ + PHONE, + WATCH +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/SpecVersion.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/SpecVersion.cs new file mode 100644 index 0000000000..701256cade --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/SpecVersion.cs @@ -0,0 +1,7 @@ +namespace MaterialColorUtilities; + +public enum SpecVersion +{ + SPEC_2021, + SPEC_2025, +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ToneDeltaPair.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ToneDeltaPair.cs new file mode 100644 index 0000000000..61f7c8bed0 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ToneDeltaPair.cs @@ -0,0 +1,31 @@ +namespace MaterialColorUtilities; + +public sealed class ToneDeltaPair +{ + public DynamicColor RoleA { get; } + public DynamicColor RoleB { get; } + public double Delta { get; } + public TonePolarity Polarity { get; } + public bool StayTogether { get; } + public DeltaConstraint Constraint { get; } + + public ToneDeltaPair(DynamicColor roleA, DynamicColor roleB, double delta, TonePolarity polarity, bool stayTogether) + { + RoleA = roleA; + RoleB = roleB; + Delta = delta; + Polarity = polarity; + StayTogether = stayTogether; + Constraint = DeltaConstraint.EXACT; + } + + public ToneDeltaPair(DynamicColor roleA, DynamicColor roleB, double delta, TonePolarity polarity, DeltaConstraint constraint) + { + RoleA = roleA; + RoleB = roleB; + Delta = delta; + Polarity = polarity; + StayTogether = true; + Constraint = constraint; + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/TonePolarity.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/TonePolarity.cs new file mode 100644 index 0000000000..c4979b3fef --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/TonePolarity.cs @@ -0,0 +1,13 @@ +namespace MaterialColorUtilities; + +public enum TonePolarity +{ + DARKER, + LIGHTER, + RELATIVE_DARKER, + RELATIVE_LIGHTER, + [Obsolete("Use DeltaConstraint instead.")] + NEARER, + [Obsolete("Use DeltaConstraint instead.")] + FARTHER, +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/Variant.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/Variant.cs new file mode 100644 index 0000000000..dcb2c77277 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/Variant.cs @@ -0,0 +1,14 @@ +namespace MaterialColorUtilities; + +public enum Variant +{ + MONOCHROME, + NEUTRAL, + TONAL_SPOT, + VIBRANT, + EXPRESSIVE, + FIDELITY, + CONTENT, + RAINBOW, + FRUIT_SALAD +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Hct/Cam16.cs b/src/MaterialDesign3.MaterialColorUtilities/Hct/Cam16.cs new file mode 100644 index 0000000000..e683336d20 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Hct/Cam16.cs @@ -0,0 +1,393 @@ +using static System.Math; +using static MaterialColorUtilities.MathUtils; + +namespace MaterialColorUtilities; + +/// +/// CAM16, a color appearance model with CAM16-UCS coordinates for measuring distances. +/// +public sealed class Cam16 +{ + /// + /// Transforms XYZ color space coordinates to 'cone'/'RGB' responses in CAM16. + /// + internal static double[][] XYZ_TO_CAM16RGB = + [ + [0.401288, 0.650173, -0.051461], + [-0.250268, 1.204414, 0.045854], + [-0.002079, 0.048952, 0.953127] + ]; + + /// + /// Transforms 'cone'/'RGB' responses in CAM16 to XYZ color space coordinates. + /// + internal static double[][] CAM16RGB_TO_XYZ = + [ + [1.8620678, -1.0112547, 0.14918678], + [0.38752654, 0.62144744, -0.00897398], + [-0.01584150, -0.03412294, 1.0499644] + ]; + + // CAM16 color dimensions + public double Hue { get; private set; } + public double Chroma { get; private set; } + public double J { get; private set; } + public double Q { get; private set; } + public double M { get; private set; } + public double S { get; private set; } + + // Coordinates in UCS space. + public double Jstar { get; private set; } + public double Astar { get; private set; } + public double Bstar { get; private set; } + + // Avoid allocations during conversion by pre-allocating an array. + private readonly double[] _tempArray = [0.0, 0.0, 0.0]; + + /// + /// CAM16-UCS distance between this color and another. + /// + public double Distance(Cam16 other) + { + var dJ = Jstar - other.Jstar; + var dA = Astar - other.Astar; + var dB = Bstar - other.Bstar; + var dEPrime = Sqrt(dJ * dJ + dA * dA + dB * dB); + var dE = 1.41 * Pow(dEPrime, 0.63); + return dE; + } + + /// + /// Hue in CAM16. + /// + public double GetHue() + { + return Hue; + } + + /// + /// Chroma in CAM16. + /// + public double GetChroma() + { + return Chroma; + } + + /// + /// Lightness in CAM16. + /// + public double GetJ() + { + return J; + } + + /// + /// Brightness in CAM16. Prefer lightness. + /// + public double GetQ() + { + return Q; + } + + /// + /// Colorfulness in CAM16. Prefer chroma. + /// + public double GetM() + { + return M; + } + + /// + /// Saturation in CAM16. Prefer chroma. + /// + public double GetS() + { + return S; + } + + /// + /// Lightness coordinate in CAM16-UCS. + /// + public double GetJstar() + { + return Jstar; + } + + /// + /// a* coordinate in CAM16-UCS. + /// + public double GetAstar() + { + return Astar; + } + + /// + /// b* coordinate in CAM16-UCS. + /// + public double GetBstar() + { + return Bstar; + } + + /// + /// Constructor that sets all CAM16 and CAM16-UCS dimensions. + /// + private Cam16( + double hue, + double chroma, + double j, + double q, + double m, + double s, + double jstar, + double astar, + double bstar) + { + Hue = hue; + Chroma = chroma; + J = j; + Q = q; + M = m; + S = s; + Jstar = jstar; + Astar = astar; + Bstar = bstar; + } + + /// + /// Create a CAM16 color from an ARGB color in default viewing conditions. + /// + public static Cam16 FromInt(int argb) + { + return FromIntInViewingConditions(argb, ViewingConditions.DEFAULT); + } + + /// + /// Create a CAM16 color from an ARGB color in defined viewing conditions. + /// + internal static Cam16 FromIntInViewingConditions(int argb, ViewingConditions viewingConditions) + { + // Transform ARGB int to XYZ + int red = (argb & 0x00ff0000) >> 16; + int green = (argb & 0x0000ff00) >> 8; + int blue = (argb & 0x000000ff); + double redL = ColorUtils.Linearized(red); + double greenL = ColorUtils.Linearized(green); + double blueL = ColorUtils.Linearized(blue); + double x = 0.41233895 * redL + 0.35762064 * greenL + 0.18051042 * blueL; + double y = 0.2126 * redL + 0.7152 * greenL + 0.0722 * blueL; + double z = 0.01932141 * redL + 0.11916382 * greenL + 0.95034478 * blueL; + + return FromXyzInViewingConditions(x, y, z, viewingConditions); + } + + internal static Cam16 FromXyzInViewingConditions( + double x, double y, double z, ViewingConditions viewingConditions) + { + // Transform XYZ to 'cone'/'rgb' responses + double[][] matrix = XYZ_TO_CAM16RGB; + double rT = (x * matrix[0][0]) + (y * matrix[0][1]) + (z * matrix[0][2]); + double gT = (x * matrix[1][0]) + (y * matrix[1][1]) + (z * matrix[1][2]); + double bT = (x * matrix[2][0]) + (y * matrix[2][1]) + (z * matrix[2][2]); + + // Discount illuminant + double rD = viewingConditions.RgbD[0] * rT; + double gD = viewingConditions.RgbD[1] * gT; + double bD = viewingConditions.RgbD[2] * bT; + + // Chromatic adaptation + double rAF = Pow(viewingConditions.Fl * Abs(rD) / 100.0, 0.42); + double gAF = Pow(viewingConditions.Fl * Abs(gD) / 100.0, 0.42); + double bAF = Pow(viewingConditions.Fl * Abs(bD) / 100.0, 0.42); + double rA = Sign(rD) * 400.0 * rAF / (rAF + 27.13); + double gA = Sign(gD) * 400.0 * gAF / (gAF + 27.13); + double bA = Sign(bD) * 400.0 * bAF / (bAF + 27.13); + + // redness-greenness + double a = (11.0 * rA + -12.0 * gA + bA) / 11.0; + // yellowness-blueness + double bb = (rA + gA - 2.0 * bA) / 9.0; + + // auxiliary components + double u = (20.0 * rA + 20.0 * gA + 21.0 * bA) / 20.0; + double p2 = (40.0 * rA + 20.0 * gA + bA) / 20.0; + + // hue + double atan2 = Atan2(bb, a); + double atanDegrees = atan2 * (180.0 / PI); + double hue = + atanDegrees < 0 + ? atanDegrees + 360.0 + : atanDegrees >= 360 ? atanDegrees - 360.0 : atanDegrees; + double hueRadians = hue * (PI / 180.0); + + // achromatic response to color + double ac = p2 * viewingConditions.Nbb; + + // CAM16 lightness and brightness + double j = + 100.0 + * Pow( + ac / viewingConditions.Aw, + viewingConditions.C * viewingConditions.Z); + double q = + 4.0 + / viewingConditions.C + * Sqrt(j / 100.0) + * (viewingConditions.Aw + 4.0) + * viewingConditions.FlRoot; + + // CAM16 chroma, colorfulness, and saturation. + double huePrime = (hue < 20.14) ? hue + 360 : hue; + double eHue = 0.25 * (Cos(huePrime * (PI / 180.0) + 2.0) + 3.8); + double p1 = 50000.0 / 13.0 * eHue * viewingConditions.Nc * viewingConditions.Ncb; + double t = p1 * Hypot(a, bb) / (u + 0.305); + double alpha = + Pow(1.64 - Pow(0.29, viewingConditions.N), 0.73) * Pow(t, 0.9); + // CAM16 chroma, colorfulness, saturation + double c = alpha * Sqrt(j / 100.0); + double m = c * viewingConditions.FlRoot; + double s = + 50.0 * Sqrt((alpha * viewingConditions.C) / (viewingConditions.Aw + 4.0)); + + // CAM16-UCS components + double jstar = (1.0 + 100.0 * 0.007) * j / (1.0 + 0.007 * j); + double mstar = 1.0 / 0.0228 * Log1p(0.0228 * m); + double astar = mstar * Cos(hueRadians); + double bstar = mstar * Sin(hueRadians); + + return new Cam16(hue, c, j, q, m, s, jstar, astar, bstar); + } + + /// + /// Create CAM16 from J, C, and H. + /// + internal static Cam16 FromJch(double j, double c, double h) + { + return FromJchInViewingConditions(j, c, h, ViewingConditions.DEFAULT); + } + + /// + /// Create CAM16 from J, C, H and viewing conditions. + /// + private static Cam16 FromJchInViewingConditions(double j, double c, double h, ViewingConditions viewingConditions) + { + double q = + 4.0 + / viewingConditions.C + * Sqrt(j / 100.0) + * (viewingConditions.Aw + 4.0) + * viewingConditions.FlRoot; + double m = c * viewingConditions.FlRoot; + double alpha = c / Sqrt(j / 100.0); + double s = + 50.0 * Sqrt((alpha * viewingConditions.C) / (viewingConditions.Aw + 4.0)); + + double hueRadians = h * (PI / 180.0); + double jstar = (1.0 + 100.0 * 0.007) * j / (1.0 + 0.007 * j); + double mstar = 1.0 / 0.0228 * Log1p(0.0228 * m); + double astar = mstar * Cos(hueRadians); + double bstar = mstar * Sin(hueRadians); + return new Cam16(h, c, j, q, m, s, jstar, astar, bstar); + } + + /// + /// Create CAM16 from CAM16-UCS coordinates in default viewing conditions. + /// + public static Cam16 FromUcs(double jstar, double astar, double bstar) + { + return FromUcsInViewingConditions(jstar, astar, bstar, ViewingConditions.DEFAULT); + } + + /// + /// Create CAM16 from CAM16-UCS coordinates in defined viewing conditions. + /// + public static Cam16 FromUcsInViewingConditions(double jstar, double astar, double bstar, ViewingConditions viewingConditions) + { + double m = Hypot(astar, bstar); + double m2 = Expm1(m * 0.0228) / 0.0228; + double c = m2 / viewingConditions.FlRoot; + double h = Atan2(bstar, astar) * (180.0 / PI); + if (h < 0.0) + { + h += 360.0; + } + double j = jstar / (1.0 - (jstar - 100.0) * 0.007); + return FromJchInViewingConditions(j, c, h, viewingConditions); + } + + /// + /// ARGB representation of this color in default viewing conditions. + /// + public int ToInt() + { + return Viewed(ViewingConditions.DEFAULT); + } + + /// + /// ARGB representation of this color in specified viewing conditions. + /// + internal int Viewed(ViewingConditions viewingConditions) + { + double[] xyz = XyzInViewingConditions(viewingConditions, _tempArray); + return ColorUtils.ArgbFromXyz(xyz[0], xyz[1], xyz[2]); + } + + internal double[] XyzInViewingConditions(ViewingConditions viewingConditions, double[] returnArray) + { + double alpha = + (Chroma == 0.0 || J == 0.0) ? 0.0 : Chroma / Sqrt(J / 100.0); + + double t = + Pow( + alpha / Pow(1.64 - Pow(0.29, viewingConditions.N), 0.73), 1.0 / 0.9); + double hRad = Hue * (PI / 180.0); + + double eHue = 0.25 * (Cos(hRad + 2.0) + 3.8); + double ac = + viewingConditions.Aw + * Pow(J / 100.0, 1.0 / viewingConditions.C / viewingConditions.Z); + double p1 = eHue * (50000.0 / 13.0) * viewingConditions.Nc * viewingConditions.Ncb; + double p2 = (ac / viewingConditions.Nbb); + + double hSin = Sin(hRad); + double hCos = Cos(hRad); + + double gamma = 23.0 * (p2 + 0.305) * t / (23.0 * p1 + 11.0 * t * hCos + 108.0 * t * hSin); + double a = gamma * hCos; + double b = gamma * hSin; + double rA = (460.0 * p2 + 451.0 * a + 288.0 * b) / 1403.0; + double gA = (460.0 * p2 - 891.0 * a - 261.0 * b) / 1403.0; + double bA = (460.0 * p2 - 220.0 * a - 6300.0 * b) / 1403.0; + + double rCBase = Max(0, (27.13 * Abs(rA)) / (400.0 - Abs(rA))); + double rC = + Sign(rA) * (100.0 / viewingConditions.Fl) * Pow(rCBase, 1.0 / 0.42); + double gCBase = Max(0, (27.13 * Abs(gA)) / (400.0 - Abs(gA))); + double gC = + Sign(gA) * (100.0 / viewingConditions.Fl) * Pow(gCBase, 1.0 / 0.42); + double bCBase = Max(0, (27.13 * Abs(bA)) / (400.0 - Abs(bA))); + double bC = + Sign(bA) * (100.0 / viewingConditions.Fl) * Pow(bCBase, 1.0 / 0.42); + double rF = rC / viewingConditions.RgbD[0]; + double gF = gC / viewingConditions.RgbD[1]; + double bF = bC / viewingConditions.RgbD[2]; + + double[][] matrix = CAM16RGB_TO_XYZ; + double x = (rF * matrix[0][0]) + (gF * matrix[0][1]) + (bF * matrix[0][2]); + double y = (rF * matrix[1][0]) + (gF * matrix[1][1]) + (bF * matrix[1][2]); + double z = (rF * matrix[2][0]) + (gF * matrix[2][1]) + (bF * matrix[2][2]); + + if (returnArray != null) + { + returnArray[0] = x; + returnArray[1] = y; + returnArray[2] = z; + return returnArray; + } + else + { + return [x, y, z]; + } + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Hct/Hct.cs b/src/MaterialDesign3.MaterialColorUtilities/Hct/Hct.cs new file mode 100644 index 0000000000..9cb00e67b3 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Hct/Hct.cs @@ -0,0 +1,113 @@ +using static System.Math; + +namespace MaterialColorUtilities; + +/// +/// HCT, hue, chroma, and tone. A color system that provides a perceptually accurate color +/// measurement system that can also accurately render what colors will appear as in different +/// lighting environments. +/// +public sealed class Hct +{ + public int Argb { get; set; } + public double Hue { get; set; } + public double Chroma { get; set; } + public double Tone { get; set; } + + /// + /// Create an HCT color from hue, chroma, and tone. + /// + public static Hct From(double hue, double chroma, double tone) + { + int argb = HctSolver.SolveToInt(hue, chroma, tone); + return new Hct(argb); + } + + /// + /// Create an HCT color from an ARGB color. + /// + public static Hct FromInt(int argb) + { + return new Hct(argb); + } + + private Hct(int argb) + { + SetInternalState(argb); + } + + /// + /// Set the hue of this color. Chroma may decrease because chroma has a different maximum for any + /// given hue and tone. + /// + public void SetHue(double newHue) + { + SetInternalState(HctSolver.SolveToInt(newHue, Chroma, Tone)); + } + + /// + /// Set the chroma of this color. Chroma may decrease because chroma has a different maximum for + /// any given hue and tone. + /// + public void SetChroma(double newChroma) + { + SetInternalState(HctSolver.SolveToInt(Hue, newChroma, Tone)); + } + + /// + /// Set the tone of this color. Chroma may decrease because chroma has a different maximum for any + /// given hue and tone. + /// + public void SetTone(double newTone) + { + SetInternalState(HctSolver.SolveToInt(Hue, Chroma, newTone)); + } + + public override string ToString() + { + return $"HCT({(int)Round(Hue)}, {(int)Round(Chroma)}, {(int)Round(Tone)})"; + } + + public static bool IsBlue(double hue) + { + return hue is >= 250 and < 270; + } + + public static bool IsYellow(double hue) + { + return hue is >= 105 and < 125; + } + + public static bool IsCyan(double hue) + { + return hue is >= 170 and < 207; + } + + /// + /// Translate a color into different ViewingConditions. + /// + public Hct InViewingConditions(ViewingConditions vc) + { + // 1. Use CAM16 to find XYZ coordinates of color in specified VC. + Cam16 cam16 = Cam16.FromInt(Argb); + double[] viewedInVc = cam16.XyzInViewingConditions(vc, null); + + // 2. Create CAM16 of those XYZ coordinates in default VC. + Cam16 recastInVc = + Cam16.FromXyzInViewingConditions( + viewedInVc[0], viewedInVc[1], viewedInVc[2], ViewingConditions.DEFAULT); + + // 3. Create HCT from CAM16 (default VC) with XYZ from specified VC and L* from Y in that VC. + return Hct.From( + recastInVc.GetHue(), recastInVc.GetChroma(), ColorUtils.LstarFromY(viewedInVc[1])); + } + + private void SetInternalState(int argb) + { + Argb = argb; + Cam16 cam = Cam16.FromInt(argb); + Hue = cam.GetHue(); + Chroma = cam.GetChroma(); + Tone = ColorUtils.LstarFromArgb(argb); + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Hct/HctSolver.cs b/src/MaterialDesign3.MaterialColorUtilities/Hct/HctSolver.cs new file mode 100644 index 0000000000..1663d9f92b --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Hct/HctSolver.cs @@ -0,0 +1,440 @@ +using static System.Math; + +namespace MaterialColorUtilities; + +/// +/// A class that solves the HCT equation. +/// +public static class HctSolver +{ + // Matrices and constants translated from Java. + internal static readonly double[][] SCALED_DISCOUNT_FROM_LINRGB = + [ + [0.001200833568784504, 0.002389694492170889, 0.0002795742885861124], + [0.0005891086651375999, 0.0029785502573438758, 0.0003270666104008398], + [0.00010146692491640572, 0.0005364214359186694, 0.0032979401770712076], + ]; + + internal static readonly double[][] LINRGB_FROM_SCALED_DISCOUNT = + [ + [ 1373.2198709594231, -1100.4251190754821, -7.278681089101213 ], + [ -271.815969077903, 559.6580465940733, -32.46047482791194 ], + [ 1.9622899599665666, -57.173814538844006, 308.7233197812385 ], + ]; + + internal static readonly double[] Y_FROM_LINRGB = [0.2126, 0.7152, 0.0722]; + + internal static readonly double[] CRITICAL_PLANES = + [ + 0.015176349177441876, 0.045529047532325624, 0.07588174588720938, 0.10623444424209313, + 0.13658714259697685, 0.16693984095186062, 0.19729253930674434, 0.2276452376616281, + 0.2579979360165119, 0.28835063437139563, 0.3188300904430532, 0.350925934958123, + 0.3848314933096426, 0.42057480301049466, 0.458183274052838, 0.4976837250274023, + 0.5391024159806381, 0.5824650784040898, 0.6277969426914107, 0.6751227633498623, + 0.7244668422128921, 0.775853049866786, 0.829304845476233, 0.8848452951698498, + 0.942497089126609, 1.0022825574869039, 1.0642236851973577, 1.1283421258858297, + 1.1946592148522128, 1.2631959812511864, 1.3339731595349034, 1.407011200216447, + 1.4823302800086415, 1.5599503113873272, 1.6398909516233677, 1.7221716113234105, + 1.8068114625156377, 1.8938294463134073, 1.9832442801866852, 2.075074464868551, + 2.1693382909216234, 2.2660538449872063, 2.36523901573795, 2.4669114995532007, + 2.5710888059345764, 2.6777882626779785, 2.7870270208169257, 2.898822059350997, + 3.0131901897720907, 3.1301480604002863, 3.2497121605402226, 3.3718988244681087, + 3.4967242352587946, 3.624204428461639, 3.754355295633311, 3.887192587735158, + 4.022731918402185, 4.160988767090289, 4.301978482107941, 4.445716283538092, + 4.592217266055746, 4.741496401646282, 4.893568542229298, 5.048448422192488, + 5.20615066083972, 5.3666897647573375, 5.5300801301023865, 5.696336044816294, + 5.865471690767354, 6.037501145825082, 6.212438385869475, 6.390297286737924, + 6.571091626112461, 6.7548350853498045, 6.941541251256611, 7.131223617812143, + 7.323895587840543, 7.5195704746346665, 7.7182615035334345, 7.919981813454504, + 8.124744458384042, 8.332562408825165, 8.543448553206703, 8.757415699253682, + 8.974476575321063, 9.194643831691977, 9.417930041841839, 9.644347703669503, + 9.873909240696694, 10.106627003236781, 10.342513269534024, 10.58158024687427, + 10.8238400726681, 11.069304815507364, 11.317986476196008, 11.569896988756009, + 11.825048221409341, 12.083451977536606, 12.345119996613247, 12.610063955123938, + 12.878295467455942, 13.149826086772048, 13.42466730586372, 13.702830557985108, + 13.984327217668513, 14.269168601521828, 14.55736596900856, 14.848930523210871, + 15.143873411576273, 15.44220572664832, 15.743938506781891, 16.04908273684337, + 16.35764934889634, 16.66964922287304, 16.985093187232053, 17.30399201960269, + 17.62635644741625, 17.95219714852476, 18.281524751807332, 18.614349837764564, + 18.95068293910138, 19.290534541298456, 19.633915083172692, 19.98083495742689, + 20.331304511189067, 20.685334046541502, 21.042933821039977, 21.404114048223256, + 21.76888489811322, 22.137256497705877, 22.50923893145328, 22.884842241736916, + 23.264076429332462, 23.6469514538663, 24.033477234264016, 24.42366364919083, + 24.817520537484558, 25.21505769858089, 25.61628489293138, 26.021211842414342, + 26.429848230738664, 26.842203703840827, 27.258287870275353, 27.678110301598522, + 28.10168053274597, 28.529008062403893, 28.96010235337422, 29.39497283293396, + 29.83362889318845, 30.276079891419332, 30.722335150426627, 31.172403958865512, + 31.62629557157785, 32.08401920991837, 32.54558406207592, 33.010999283389665, + 33.4802739966603, 33.953417292456834, 34.430438229418264, 34.911345834551085, + 35.39614910352207, 35.88485700094671, 36.37747846067349, 36.87402238606382, + 37.37449765026789, 37.87891309649659, 38.38727753828926, 38.89959975977785, + 39.41588851594697, 39.93615253289054, 40.460400508064545, 40.98864111053629, + 41.520882981230194, 42.05713473317016, 42.597404951718396, 43.141702194811224, + 43.6900349931913, 44.24241185063697, 44.798841244188324, 45.35933162437017, + 45.92389141541209, 46.49252901546552, 47.065252796817916, 47.64207110610409, + 48.22299226451468, 48.808024568002054, 49.3971762874833, 49.9904556690408, + 50.587870934119984, 51.189430279724725, 51.79514187861014, 52.40501387947288, + 53.0190544071392, 53.637271562750364, 54.259673423945976, 54.88626804504493, + 55.517063457223934, 56.15206766869424, 56.79128866487574, 57.43473440856916, + 58.08241284012621, 58.734331877617365, 59.39049941699807, 60.05092333227251, + 60.715611475655585, 61.38457167773311, 62.057811747619894, 62.7353394731159, + 63.417162620860914, 64.10328893648692, 64.79372614476921, 65.48848194977529, + 66.18756403501224, 66.89098006357258, 67.59873767827808, 68.31084450182222, + 69.02730813691093, 69.74813616640164, 70.47333615344107, 71.20291564160104, + 71.93688215501312, 72.67524319850172, 73.41800625771542, 74.16517879925733, + 74.9167682708136, 75.67278210128072, 76.43322770089146, 77.1981124613393, + 77.96744375590167, 78.74122893956174, 79.51947534912904, 80.30219030335869, + 81.08938110306934, 81.88105503125999, 82.67721935322541, 83.4778813166706, + 84.28304815182372, 85.09272707154808, 85.90692527145302, 86.72564993000343, + 87.54890820862819, 88.3767072518277, 89.2090541872801, 90.04595612594655, + 90.88742016217518, 91.73345337380438, 92.58406282226491, 93.43925555268066, + 94.29903859396902, 95.16341895893969, 96.03240364439274, 96.9059996312159, + 97.78421388448044, 98.6670533535366, 99.55452497210776 + ]; + + // Below are method signatures ported from Java; implementations intentionally omitted. + + internal static double SanitizeRadians(double angle) + { + return (angle + PI * 8) % (PI * 2); + } + + internal static double TrueDelinearized(double rgbComponent) + { + double normalized = rgbComponent / 100.0; + double delinearized; + if (normalized <= 0.0031308) + { + delinearized = normalized * 12.92; + } + else + { + delinearized = 1.055 * Pow(normalized, 1.0 / 2.4) - 0.055; + } + return delinearized * 255.0; + } + + internal static double ChromaticAdaptation(double component) + { + double af = Pow(Abs(component), 0.42); + return MathUtils.Signum(component) * 400.0 * af / (af + 27.13); + } + + /// + /// Returns the hue of a linear RGB color in CAM16, in radians. + /// + internal static double HueOf(double[] linrgb) + { + double[] scaledDiscount = MathUtils.MatrixMultiply(linrgb, SCALED_DISCOUNT_FROM_LINRGB); + double rA = ChromaticAdaptation(scaledDiscount[0]); + double gA = ChromaticAdaptation(scaledDiscount[1]); + double bA = ChromaticAdaptation(scaledDiscount[2]); + double a = (11.0 * rA + -12.0 * gA + bA) / 11.0; + double b = (rA + gA - 2.0 * bA) / 9.0; + return Atan2(b, a); + } + + internal static bool AreInCyclicOrder(double a, double b, double c) + { + double deltaAB = SanitizeRadians(b - a); + double deltaAC = SanitizeRadians(c - a); + return deltaAB < deltaAC; + } + + /// + /// Solves the lerp equation: returns t such that lerp(source, target, t) = mid + /// + internal static double Intercept(double source, double mid, double target) + { + return (mid - source) / (target - source); + } + + internal static double[] LerpPoint(double[] source, double t, double[] target) + { + return [ + source[0] + (target[0] - source[0]) * t, + source[1] + (target[1] - source[1]) * t, + source[2] + (target[2] - source[2]) * t, + ]; + } + + /// + /// Intersects a segment with a plane along axis. + /// + internal static double[] SetCoordinate(double[] source, double coordinate, double[] target, int axis) + { + double t = Intercept(source[axis], coordinate, target[axis]); + return LerpPoint(source, t, target); + } + + internal static bool IsBounded(double x) + { + return 0.0 <= x && x <= 100.0; + } + + /// + /// Returns the nth possible vertex of the polygonal intersection of the Y plane and RGB cube. + /// + internal static double[] NthVertex(double y, int n) + { + double kR = Y_FROM_LINRGB[0]; + double kG = Y_FROM_LINRGB[1]; + double kB = Y_FROM_LINRGB[2]; + double coordA = n % 4 <= 1 ? 0.0 : 100.0; + double coordB = n % 2 == 0 ? 0.0 : 100.0; + if (n < 4) + { + double g = coordA; + double b = coordB; + double r = (y - g * kG - b * kB) / kR; + if (IsBounded(r)) + { + return [r, g, b]; + } + else + { + return [-1.0, -1.0, -1.0]; + } + } + else if (n < 8) + { + double b = coordA; + double r = coordB; + double g = (y - r * kR - b * kB) / kG; + if (IsBounded(g)) + { + return [r, g, b]; + } + else + { + return [-1.0, -1.0, -1.0]; + } + } + else + { + double r = coordA; + double g = coordB; + double b = (y - r * kR - g * kG) / kB; + if (IsBounded(b)) + { + return [r, g, b]; + } + else + { + return [-1.0, -1.0, -1.0]; + } + } + } + + /// + /// Finds the segment containing the desired color for a given Y and target hue. + /// + internal static double[][] BisectToSegment(double y, double targetHue) + { + double[] left = [-1.0, -1.0, -1.0]; + double[] right = left; + double leftHue = 0.0; + double rightHue = 0.0; + bool initialized = false; + bool uncut = true; + for (int n = 0; n < 12; n++) + { + double[] mid = NthVertex(y, n); + if (mid[0] < 0) + { + continue; + } + double midHue = HueOf(mid); + if (!initialized) + { + left = mid; + right = mid; + leftHue = midHue; + rightHue = midHue; + initialized = true; + continue; + } + if (uncut || AreInCyclicOrder(leftHue, midHue, rightHue)) + { + uncut = false; + if (AreInCyclicOrder(leftHue, targetHue, midHue)) + { + right = mid; + rightHue = midHue; + } + else + { + left = mid; + leftHue = midHue; + } + } + } + return new double[][] { left, right }; + } + + internal static double[] Midpoint(double[] a, double[] b) + { + return [(a[0] + b[0]) / 2.0, (a[1] + b[1]) / 2.0, (a[2] + b[2]) / 2.0]; + } + + internal static int CriticalPlaneBelow(double x) + { + return (int)Floor(x - 0.5); + } + + internal static int CriticalPlaneAbove(double x) + { + return (int)Ceiling(x - 0.5); + } + + /// + /// Finds a color with the given Y and hue on the boundary of the cube. + /// + internal static double[] BisectToLimit(double y, double targetHue) + { + double[][] segment = BisectToSegment(y, targetHue); + double[] left = segment[0]; + double leftHue = HueOf(left); + double[] right = segment[1]; + for (int axis = 0; axis < 3; axis++) + { + if (left[axis] != right[axis]) + { + int lPlane; + int rPlane; + if (left[axis] < right[axis]) + { + lPlane = CriticalPlaneBelow(TrueDelinearized(left[axis])); + rPlane = CriticalPlaneAbove(TrueDelinearized(right[axis])); + } + else + { + lPlane = CriticalPlaneAbove(TrueDelinearized(left[axis])); + rPlane = CriticalPlaneBelow(TrueDelinearized(right[axis])); + } + for (int i = 0; i < 8; i++) + { + if (Abs(rPlane - lPlane) <= 1) + { + break; + } + else + { + int mPlane = (int)Floor((lPlane + rPlane) / 2.0); + double midPlaneCoordinate = CRITICAL_PLANES[mPlane]; + double[] mid = SetCoordinate(left, midPlaneCoordinate, right, axis); + double midHue = HueOf(mid); + if (AreInCyclicOrder(leftHue, targetHue, midHue)) + { + right = mid; + rPlane = mPlane; + } + else + { + left = mid; + leftHue = midHue; + lPlane = mPlane; + } + } + } + } + } + return Midpoint(left, right); + } + + internal static double InverseChromaticAdaptation(double adapted) + { + double adaptedAbs = Abs(adapted); + double basev = Max(0, 27.13 * adaptedAbs / (400.0 - adaptedAbs)); + return MathUtils.Signum(adapted) * Pow(basev, 1.0 / 0.42); + } + + /// + /// Finds a color with the given hue, chroma, and Y. + /// + internal static int FindResultByJ(double hueRadians, double chroma, double y) + { + // Initial estimate of j. + double j = Sqrt(y) * 11.0; + var viewingConditions = ViewingConditions.DEFAULT; + double tInnerCoeff = 1 / Pow(1.64 - Pow(0.29, viewingConditions.N), 0.73); + double eHue = 0.25 * (Cos(hueRadians + 2.0) + 3.8); + double p1 = eHue * (50000.0 / 13.0) * viewingConditions.Nc * viewingConditions.Ncb; + double hSin = Sin(hueRadians); + double hCos = Cos(hueRadians); + for (int iterationRound = 0; iterationRound < 5; iterationRound++) + { + double jNormalized = j / 100.0; + double alpha = chroma == 0.0 || j == 0.0 ? 0.0 : chroma / Sqrt(jNormalized); + double t = Pow(alpha * tInnerCoeff, 1.0 / 0.9); + double ac = + viewingConditions.Aw + * Pow(jNormalized, 1.0 / viewingConditions.C / viewingConditions.Z); + double p2 = ac / viewingConditions.Nbb; + double gamma = 23.0 * (p2 + 0.305) * t / (23.0 * p1 + 11.0 * t * hCos + 108.0 * t * hSin); + double a = gamma * hCos; + double b = gamma * hSin; + double rA = (460.0 * p2 + 451.0 * a + 288.0 * b) / 1403.0; + double gA = (460.0 * p2 - 891.0 * a - 261.0 * b) / 1403.0; + double bA = (460.0 * p2 - 220.0 * a - 6300.0 * b) / 1403.0; + double rCScaled = InverseChromaticAdaptation(rA); + double gCScaled = InverseChromaticAdaptation(gA); + double bCScaled = InverseChromaticAdaptation(bA); + double[] linrgb = + MathUtils.MatrixMultiply( + [rCScaled, gCScaled, bCScaled], LINRGB_FROM_SCALED_DISCOUNT); + if (linrgb[0] < 0 || linrgb[1] < 0 || linrgb[2] < 0) + { + return 0; + } + double kR = Y_FROM_LINRGB[0]; + double kG = Y_FROM_LINRGB[1]; + double kB = Y_FROM_LINRGB[2]; + double fnj = kR * linrgb[0] + kG * linrgb[1] + kB * linrgb[2]; + if (fnj <= 0) + { + return 0; + } + if (iterationRound == 4 || Abs(fnj - y) < 0.002) + { + if (linrgb[0] > 100.01 || linrgb[1] > 100.01 || linrgb[2] > 100.01) + { + return 0; + } + return ColorUtils.ArgbFromLinrgb(linrgb); + } + // Iterates with Newton method, Using 2 * fn(j) / j as the approximation of fn'(j) + j = j - (fnj - y) * j / (2 * fnj); + } + return 0; + } + + /// + /// Finds an sRGB color with the given hue, chroma, and L*, if possible. + /// + public static int SolveToInt(double hueDegrees, double chroma, double lstar) + { + if (chroma < 0.0001 || lstar < 0.0001 || lstar > 99.9999) + { + return ColorUtils.ArgbFromLstar(lstar); + } + hueDegrees = MathUtils.SanitizeDegreesDouble(hueDegrees); + double hueRadians = hueDegrees / 180.0 * PI; + double y = ColorUtils.YFromLstar(lstar); + int exactAnswer = FindResultByJ(hueRadians, chroma, y); + if (exactAnswer != 0) + { + return exactAnswer; + } + double[] linrgb = BisectToLimit(y, hueRadians); + return ColorUtils.ArgbFromLinrgb(linrgb); + } + + /// + /// Finds an sRGB color with the given hue, chroma, and L*, if possible, returning CAM16. + /// + public static Cam16 SolveToCam(double hueDegrees, double chroma, double lstar) + { + return Cam16.FromInt(SolveToInt(hueDegrees, chroma, lstar)); + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Hct/ViewingConditions.cs b/src/MaterialDesign3.MaterialColorUtilities/Hct/ViewingConditions.cs new file mode 100644 index 0000000000..5981d365ab --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Hct/ViewingConditions.cs @@ -0,0 +1,134 @@ +using static System.Math; +#if NET462 +using static System.MathCompat; +#endif + +namespace MaterialColorUtilities; + +/// +/// Viewing conditions used by CAM16/HCT; caches intermediate values for performance. +/// +public sealed class ViewingConditions +{ + /// + /// sRGB-like viewing conditions. + /// + public static readonly ViewingConditions DEFAULT = DefaultWithBackgroundLstar(50.0); + + // Properties corresponding to Java getters + public double Aw { get; } + public double N { get; } + public double Nbb { get; } + internal double Ncb { get; } + internal double C { get; } + internal double Nc { get; } + public double[] RgbD { get; } + internal double Fl { get; } + public double FlRoot { get; } + internal double Z { get; } + + /// + /// Create ViewingConditions from a simple, physically relevant set of parameters. + /// + public static ViewingConditions Make( + double[] whitePoint, + double adaptingLuminance, + double backgroundLstar, + double surround, + bool discountingIlluminant) + { + // A background of pure black is non-physical and leads to infinities that represent the idea + // that any color viewed in pure black can't be seen. + backgroundLstar = Max(0.1, backgroundLstar); + + // Transform white point XYZ to 'cone'/'rgb' responses + var matrix = Cam16.XYZ_TO_CAM16RGB; + var xyz = whitePoint; + double rW = (xyz[0] * matrix[0][0]) + (xyz[1] * matrix[0][1]) + (xyz[2] * matrix[0][2]); + double gW = (xyz[0] * matrix[1][0]) + (xyz[1] * matrix[1][1]) + (xyz[2] * matrix[1][2]); + double bW = (xyz[0] * matrix[2][0]) + (xyz[1] * matrix[2][1]) + (xyz[2] * matrix[2][2]); + + double f = 0.8 + (surround / 10.0); + double c = (f >= 0.9) + ? MathUtils.Lerp(0.59, 0.69, ((f - 0.9) * 10.0)) + : MathUtils.Lerp(0.525, 0.59, ((f - 0.8) * 10.0)); + + double d = discountingIlluminant + ? 1.0 + : f * (1.0 - ((1.0 / 3.6) * Exp((-adaptingLuminance - 42.0) / 92.0))); + d = MathUtils.ClampDouble(0.0, 1.0, d); + double nc = f; + double[] rgbD = + [ + d * (100.0 / rW) + 1.0 - d, + d * (100.0 / gW) + 1.0 - d, + d * (100.0 / bW) + 1.0 - d + ]; + + double k = 1.0 / (5.0 * adaptingLuminance + 1.0); + double k4 = k * k * k * k; + double k4F = 1.0 - k4; + double fl = (k4 * adaptingLuminance) + (0.1 * k4F * k4F * Cbrt(5.0 * adaptingLuminance)); + + double n = (ColorUtils.YFromLstar(backgroundLstar) / whitePoint[1]); + double z = 1.48 + Sqrt(n); + double nbb = 0.725 / Pow(n, 0.2); + double ncb = nbb; + double[] rgbAFactors = + [ + Pow(fl * rgbD[0] * rW / 100.0, 0.42), + Pow(fl * rgbD[1] * gW / 100.0, 0.42), + Pow(fl * rgbD[2] * bW / 100.0, 0.42) + ]; + + double[] rgbA = + [ + (400.0 * rgbAFactors[0]) / (rgbAFactors[0] + 27.13), + (400.0 * rgbAFactors[1]) / (rgbAFactors[1] + 27.13), + (400.0 * rgbAFactors[2]) / (rgbAFactors[2] + 27.13) + ]; + + double aw = ((2.0 * rgbA[0]) + rgbA[1] + (0.05 * rgbA[2])) * nbb; + return new ViewingConditions(n, aw, nbb, ncb, c, nc, rgbD, fl, Pow(fl, 0.25), z); + } + + /// + /// Create sRGB-like viewing conditions with a custom background L*. + /// + public static ViewingConditions DefaultWithBackgroundLstar(double lstar) + { + return Make( + ColorUtils.WhitePointD65(), + (200.0 / PI * ColorUtils.YFromLstar(50.0) / 100.0), + lstar, + 2.0, + false); + } + + /// + /// Parameterized constructor for caching viewing condition intermediates. + /// + private ViewingConditions( + double n, + double aw, + double nbb, + double ncb, + double c, + double nc, + double[] rgbD, + double fl, + double flRoot, + double z) + { + N = n; + Aw = aw; + Nbb = nbb; + Ncb = ncb; + C = c; + Nc = nc; + RgbD = rgbD; + Fl = fl; + FlRoot = flRoot; + Z = z; + } +} diff --git a/src/MaterialDesign3.MaterialColorUtilities/MaterialColorUtilities.csproj b/src/MaterialDesign3.MaterialColorUtilities/MaterialColorUtilities.csproj new file mode 100644 index 0000000000..7325ddfa26 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/MaterialColorUtilities.csproj @@ -0,0 +1,45 @@ + + + MaterialColorUtilities + MaterialColorUtilities + net462;net8.0-windows + 13 + disable + MaterialColorUtilities + enable + true + 1.0.1 + $([System.Text.RegularExpressions.Regex]::Replace("$(MDIXColorsVersion)", "-ci\d+$", "")) + Material Design Color Utilities + $(MDIXColorsVersion) + $(MDIXColorsVersion) + + + MaterialDesignColorUtilities + Material Design 3 Color Utilities + Utilities to create Material Design 3 Color Palettes + WPF XAML Material Design Colour Color UI UX + + + + + <_Parameter1>MDIXColorsVersion + <_Parameter2>$(MDIXColorsVersion) + + + + + + + + all + + + + + + MathCompat.cs + + + + diff --git a/src/MaterialDesign3.MaterialColorUtilities/Palettes/CorePalette.cs b/src/MaterialDesign3.MaterialColorUtilities/Palettes/CorePalette.cs new file mode 100644 index 0000000000..679ffb6762 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Palettes/CorePalette.cs @@ -0,0 +1,59 @@ +using static System.Math; + +namespace MaterialColorUtilities; + +/// +/// An intermediate between a key color and a full color scheme: generates 5 tonal palettes varying chroma. +/// +[Obsolete("Use DynamicScheme for color scheme generation. Use CorePalettes for core palettes container class.")] +public sealed class CorePalette +{ + public TonalPalette a1 { get; } + public TonalPalette a2 { get; } + public TonalPalette a3 { get; } + public TonalPalette n1 { get; } + public TonalPalette n2 { get; } + public TonalPalette error { get; } + + /// + /// Create key palettes from a color. + /// + [Obsolete("Use DynamicScheme for color scheme generation. Use CorePalettes for core palettes container class.")] + public static CorePalette Of(int argb) + { + return new CorePalette(argb, false); + } + + /// + /// Create content key palettes from a color. + /// + [Obsolete("Use DynamicScheme for color scheme generation. Use CorePalettes for core palettes container class.")] + public static CorePalette ContentOf(int argb) + { + return new CorePalette(argb, true); + } + + private CorePalette(int argb, bool isContent) + { + var hct = Hct.FromInt(argb); + var hue = hct.Hue; + var chroma = hct.Chroma; + if (isContent) + { + a1 = TonalPalette.FromHueAndChroma(hue, chroma); + a2 = TonalPalette.FromHueAndChroma(hue, chroma / 3.0); + a3 = TonalPalette.FromHueAndChroma(hue + 60.0, chroma / 2.0); + n1 = TonalPalette.FromHueAndChroma(hue, Min(chroma / 12.0, 4.0)); + n2 = TonalPalette.FromHueAndChroma(hue, Min(chroma / 6.0, 8.0)); + } + else + { + a1 = TonalPalette.FromHueAndChroma(hue, Max(48.0, chroma)); + a2 = TonalPalette.FromHueAndChroma(hue, 16.0); + a3 = TonalPalette.FromHueAndChroma(hue + 60.0, 24.0); + n1 = TonalPalette.FromHueAndChroma(hue, 4.0); + n2 = TonalPalette.FromHueAndChroma(hue, 8.0); + } + error = TonalPalette.FromHueAndChroma(25.0, 84.0); + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Palettes/CorePalettes.cs b/src/MaterialDesign3.MaterialColorUtilities/Palettes/CorePalettes.cs new file mode 100644 index 0000000000..ad344b91dd --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Palettes/CorePalettes.cs @@ -0,0 +1,12 @@ +namespace MaterialColorUtilities; + +/// +/// Comprises foundational palettes to build a color scheme. +/// Generated from a source color, these palettes will then be part of a DynamicScheme together with appearance preferences. +/// +public record CorePalettes( + TonalPalette Primary, + TonalPalette Secondary, + TonalPalette Tertiary, + TonalPalette Neutral, + TonalPalette NeutralVariant); \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Palettes/TonalPalette.cs b/src/MaterialDesign3.MaterialColorUtilities/Palettes/TonalPalette.cs new file mode 100644 index 0000000000..af99f74eac --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Palettes/TonalPalette.cs @@ -0,0 +1,172 @@ +using static System.Math; + +namespace MaterialColorUtilities; + +/// +/// A convenience class for retrieving colors that are constant in hue and chroma, but vary in tone. +/// TonalPalette is intended for use in a single thread due to its stateful caching. +/// +public sealed class TonalPalette +{ + private readonly Dictionary _cache = new(); + private readonly Hct _keyColor; + private readonly double _hue; + private readonly double _chroma; + + /// + /// Create tones using the HCT hue and chroma from a color. + /// + public static TonalPalette FromInt(int argb) + { + return FromHct(Hct.FromInt(argb)); + } + + /// + /// Create tones using a HCT color. + /// + public static TonalPalette FromHct(Hct hct) + { + return new TonalPalette(hct.Hue, hct.Chroma, hct); + } + + /// + /// Create tones from a defined HCT hue and chroma. + /// + public static TonalPalette FromHueAndChroma(double hue, double chroma) + { + var keyColor = new KeyColor(hue, chroma).Create(); + return new TonalPalette(hue, chroma, keyColor); + } + + private TonalPalette(double hue, double chroma, Hct keyColor) + { + _hue = hue; + _chroma = chroma; + _keyColor = keyColor; + } + + /// + /// Create an ARGB color with HCT hue and chroma of this palette, and the provided HCT tone (0-100). + /// + public int Tone(int tone) + { + if (_cache.TryGetValue(tone, out var cached)) + { + return cached; + } + int color; + if (tone == 99 && Hct.IsYellow(_hue)) + { + color = AverageArgb(Tone(98), Tone(100)); + } + else + { + color = Hct.From(_hue, _chroma, tone).Argb; + } + _cache[tone] = color; + return color; + } + + /// + /// Given a tone, use hue and chroma of palette to create a color, and return it as HCT. + /// + public Hct GetHct(double tone) + { + return Hct.From(_hue, _chroma, tone); + } + + /// The chroma of the Tonal Palette, in HCT. + public double GetChroma() => _chroma; + + /// The hue of the Tonal Palette, in HCT. + public double GetHue() => _hue; + + /// The key color is the first tone, starting from T50, that matches the palette's chroma. + public Hct GetKeyColor() => _keyColor; + + private static int AverageArgb(int argb1, int argb2) + { + var red1 = (argb1 >> 16) & 0xff; + var green1 = (argb1 >> 8) & 0xff; + var blue1 = argb1 & 0xff; + var red2 = (argb2 >> 16) & 0xff; + var green2 = (argb2 >> 8) & 0xff; + var blue2 = argb2 & 0xff; + var red = (int)Round((red1 + red2) / 2.0); + var green = (int)Round((green1 + green2) / 2.0); + var blue = (int)Round((blue1 + blue2) / 2.0); + return (255 << 24) | ((red & 255) << 16) | ((green & 255) << 8) | (blue & 255); + } + + /// + /// Key color is a color that represents the hue and chroma of a tonal palette. + /// + private sealed class KeyColor + { + private readonly double _hue; + private readonly double _requestedChroma; + private readonly Dictionary _chromaCache = new(); + private const double MAX_CHROMA_VALUE = 200.0; + + public KeyColor(double hue, double requestedChroma) + { + _hue = hue; + _requestedChroma = requestedChroma; + } + + public Hct Create() + { + const int pivotTone = 50; + const int toneStepSize = 1; + const double epsilon = 0.01; + + var lowerTone = 0; + var upperTone = 100; + while (lowerTone < upperTone) + { + var midTone = (lowerTone + upperTone) / 2; + var isAscending = MaxChroma(midTone) < MaxChroma(midTone + toneStepSize); + var sufficientChroma = MaxChroma(midTone) >= _requestedChroma - epsilon; + + if (sufficientChroma) + { + if (Abs(lowerTone - pivotTone) < Abs(upperTone - pivotTone)) + { + upperTone = midTone; + } + else + { + if (lowerTone == midTone) + { + return Hct.From(_hue, _requestedChroma, lowerTone); + } + lowerTone = midTone; + } + } + else + { + if (isAscending) + { + lowerTone = midTone + toneStepSize; + } + else + { + upperTone = midTone; + } + } + } + return Hct.From(_hue, _requestedChroma, lowerTone); + } + + private double MaxChroma(int tone) + { + if (!_chromaCache.TryGetValue(tone, out var cached)) + { + var newChroma = Hct.From(_hue, MAX_CHROMA_VALUE, tone).Chroma; + _chromaCache[tone] = newChroma; + return newChroma; + } + return cached; + } + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Quantize/PointProvider.cs b/src/MaterialDesign3.MaterialColorUtilities/Quantize/PointProvider.cs new file mode 100644 index 0000000000..2f9cc1ed2c --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Quantize/PointProvider.cs @@ -0,0 +1,13 @@ +namespace MaterialColorUtilities; + +public interface PointProvider +{ + // The three components (L*, a*, b* or similar) from an ARGB color. + double[] FromInt(int argb); + + // Convert a point in the color space back to ARGB. + int ToInt(double[] point); + + // Squared distance between two points in the color space. + double Distance(double[] a, double[] b); +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Quantize/PointProviderLab.cs b/src/MaterialDesign3.MaterialColorUtilities/Quantize/PointProviderLab.cs new file mode 100644 index 0000000000..fbec122262 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Quantize/PointProviderLab.cs @@ -0,0 +1,45 @@ +namespace MaterialColorUtilities; + +/// +/// Provides conversions needed for K-Means quantization. Converting input to points, and converting +/// the final state of the K-Means algorithm to colors. +/// +public sealed class PointProviderLab: PointProvider +{ + /// + /// Convert a color represented in ARGB to a 3-element array of L*a*b* coordinates of the color. + /// + /// + /// + public double[] FromInt(int argb) + { + var lab = ColorUtils.LabFromArgb(argb); + return [lab[0], lab[1], lab[2]]; + } + + /// + /// Convert a 3-element array to a color represented in ARGB. + /// + /// + /// + public int ToInt(double[] lab) + { + return ColorUtils.ArgbFromLab(lab[0], lab[1], lab[2]); + } + + /// + /// Standard CIE 1976 delta E formula also takes the square root, unneeded here. This method is + /// used by quantization algorithms to compare distance, and the relative ordering is the same, + /// with or without a square root. + ///
+ /// This relatively minor optimization is helpful because this method is called at least once + /// for each pixel in an image. + /// + public double Distance(double[] one, double[] two) + { + var dL = one[0] - two[0]; + var dA = one[1] - two[1]; + var dB = one[2] - two[2]; + return dL * dL + dA * dA + dB * dB; + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Quantize/Quantizer.cs b/src/MaterialDesign3.MaterialColorUtilities/Quantize/Quantizer.cs new file mode 100644 index 0000000000..430e2ae62a --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Quantize/Quantizer.cs @@ -0,0 +1,6 @@ +namespace MaterialColorUtilities; + +public interface Quantizer +{ + QuantizerResult Quantize(int[] pixels, int maxColors); +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerCelebi.cs b/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerCelebi.cs new file mode 100644 index 0000000000..8aa550ccf3 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerCelebi.cs @@ -0,0 +1,21 @@ +namespace MaterialColorUtilities; + +public sealed class QuantizerCelebi +{ + private QuantizerCelebi() { } + + public static Dictionary Quantize(int[] pixels, int maxColors) + { + var wu = new QuantizerWu(); + var wuResult = wu.Quantize(pixels, maxColors); + + var wuClusters = new int[wuResult.ColorToCount.Count]; + var index = 0; + foreach (var kvp in wuResult.ColorToCount) + { + wuClusters[index++] = kvp.Key; + } + + return QuantizerWsMeans.Quantize(pixels, wuClusters, maxColors); + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerMap.cs b/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerMap.cs new file mode 100644 index 0000000000..99a3db5a03 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerMap.cs @@ -0,0 +1,17 @@ +namespace MaterialColorUtilities; + +public sealed class QuantizerMap: Quantizer +{ + private Dictionary ColorToCount { get; } = new(); + + public QuantizerResult Quantize(int[] pixels, int colorCount) + { + foreach (var pixel in pixels) + { + ColorToCount.TryGetValue(pixel, out var current); + ColorToCount[pixel] = current + 1; + } + + return new QuantizerResult(ColorToCount); + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerResult.cs b/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerResult.cs new file mode 100644 index 0000000000..1de3faacf4 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerResult.cs @@ -0,0 +1,3 @@ +namespace MaterialColorUtilities; + +public record QuantizerResult(Dictionary ColorToCount); \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerWsmeans.cs b/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerWsmeans.cs new file mode 100644 index 0000000000..9d9beca7bb --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerWsmeans.cs @@ -0,0 +1,204 @@ +using static System.Math; + +namespace MaterialColorUtilities; + +public static class QuantizerWsMeans +{ + private sealed class Distance : IComparable + { + public int Index; + public double D; + public int CompareTo(Distance? other) + { + if (other == null) return 1; + return D.CompareTo(other.D); + } + } + + private const int MAX_ITERATIONS = 10; + private const double MIN_MOVEMENT_DISTANCE = 3.0; + + public static Dictionary Quantize(int[] inputPixels, int[] startingClusters, int maxColors) + { + var random = new Random(0x42688); + + var pixelToCount = new Dictionary(); + var points = new double[inputPixels.Length][]; + var pixels = new int[inputPixels.Length]; + PointProvider pointProvider = new PointProviderLab(); + + int pointCount = 0; + for (int i = 0; i < inputPixels.Length; i++) + { + int inputPixel = inputPixels[i]; + if (!pixelToCount.TryGetValue(inputPixel, out var pixelCount)) + { + points[pointCount] = pointProvider.FromInt(inputPixel); + pixels[pointCount] = inputPixel; + pointCount++; + pixelToCount[inputPixel] = 1; + } + else + { + pixelToCount[inputPixel] = pixelCount + 1; + } + } + + var counts = new int[pointCount]; + for (int i = 0; i < pointCount; i++) + { + int pixel = pixels[i]; + counts[i] = pixelToCount[pixel]; + } + + int clusterCount = Min(maxColors, pointCount); + if (startingClusters.Length != 0) + { + clusterCount = Min(clusterCount, startingClusters.Length); + } + + var clusters = new double[clusterCount][]; + int clustersCreated = 0; + for (int i = 0; i < startingClusters.Length && i < clusterCount; i++) + { + clusters[i] = pointProvider.FromInt(startingClusters[i]); + clustersCreated++; + } + + int additionalClustersNeeded = clusterCount - clustersCreated; + if (startingClusters.Length == 0 && additionalClustersNeeded > 0) + { + for (int i = 0; i < additionalClustersNeeded; i++) + { + // Random Lab within typical ranges: L [0,100], a [-100,100], b [-100,100] + double l = random.NextDouble() * 100.0; + double a = random.NextDouble() * 200.0 - 100.0; + double b = random.NextDouble() * 200.0 - 100.0; + clusters[clustersCreated + i] = [l, a, b]; + } + } + + var clusterIndices = new int[pointCount]; + for (int i = 0; i < pointCount; i++) + { + clusterIndices[i] = random.Next(clusterCount); + } + + var indexMatrix = new int[clusterCount][]; + for (int i = 0; i < clusterCount; i++) indexMatrix[i] = new int[clusterCount]; + + var distanceToIndexMatrix = new Distance[clusterCount][]; + for (int i = 0; i < clusterCount; i++) + { + distanceToIndexMatrix[i] = new Distance[clusterCount]; + for (int j = 0; j < clusterCount; j++) + { + distanceToIndexMatrix[i][j] = new Distance(); + } + } + + var pixelCountSums = new int[clusterCount]; + for (int iteration = 0; iteration < MAX_ITERATIONS; iteration++) + { + // Update cluster pair distances and sorted indices + for (int i = 0; i < clusterCount; i++) + { + for (int j = i + 1; j < clusterCount; j++) + { + double distance = pointProvider.Distance(clusters[i], clusters[j]); + distanceToIndexMatrix[j][i].D = distance; + distanceToIndexMatrix[j][i].Index = i; + distanceToIndexMatrix[i][j].D = distance; + distanceToIndexMatrix[i][j].Index = j; + } + Array.Sort(distanceToIndexMatrix[i]); + for (int j = 0; j < clusterCount; j++) + { + indexMatrix[i][j] = distanceToIndexMatrix[i][j].Index; + } + } + + int pointsMoved = 0; + for (int i = 0; i < pointCount; i++) + { + var point = points[i]; + int previousClusterIndex = clusterIndices[i]; + var previousCluster = clusters[previousClusterIndex]; + double previousDistance = pointProvider.Distance(point, previousCluster); + + double minimumDistance = previousDistance; + int newClusterIndex = -1; + for (int j = 0; j < clusterCount; j++) + { + if (distanceToIndexMatrix[previousClusterIndex][j].D >= 4 * previousDistance) + { + continue; + } + double distance = pointProvider.Distance(point, clusters[j]); + if (distance < minimumDistance) + { + minimumDistance = distance; + newClusterIndex = j; + } + } + if (newClusterIndex != -1) + { + double distanceChange = Abs(Sqrt(minimumDistance) - Sqrt(previousDistance)); + if (distanceChange > MIN_MOVEMENT_DISTANCE) + { + pointsMoved++; + clusterIndices[i] = newClusterIndex; + } + } + } + + if (pointsMoved == 0 && iteration != 0) + { + break; + } + + var componentASums = new double[clusterCount]; + var componentBSums = new double[clusterCount]; + var componentCSums = new double[clusterCount]; + pixelCountSums.AsSpan().Fill(0); + for (int i = 0; i < pointCount; i++) + { + int clusterIndex = clusterIndices[i]; + var point = points[i]; + int count = counts[i]; + pixelCountSums[clusterIndex] += count; + componentASums[clusterIndex] += point[0] * count; + componentBSums[clusterIndex] += point[1] * count; + componentCSums[clusterIndex] += point[2] * count; + } + + for (int i = 0; i < clusterCount; i++) + { + int count = pixelCountSums[i]; + if (count == 0) + { + clusters[i] = [0.0, 0.0, 0.0]; + continue; + } + double a = componentASums[i] / count; + double b = componentBSums[i] / count; + double c = componentCSums[i] / count; + clusters[i][0] = a; + clusters[i][1] = b; + clusters[i][2] = c; + } + } + + var argbToPopulation = new Dictionary(); + for (int i = 0; i < clusterCount; i++) + { + int count = pixelCountSums[i]; + if (count == 0) continue; + int possibleNewCluster = pointProvider.ToInt(clusters[i]); + if (argbToPopulation.ContainsKey(possibleNewCluster)) continue; + argbToPopulation[possibleNewCluster] = count; + } + + return argbToPopulation; + } +} diff --git a/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerWu.cs b/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerWu.cs new file mode 100644 index 0000000000..6440461b63 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerWu.cs @@ -0,0 +1,398 @@ +namespace MaterialColorUtilities; + +public sealed class QuantizerWu: Quantizer +{ + private int[] weights = default!; + private int[] momentsR = default!; + private int[] momentsG = default!; + private int[] momentsB = default!; + private double[] moments = default!; + private Box[] cubes = default!; + + // 5 bits per channel histogram size. + private const int INDEX_BITS = 5; + private const int INDEX_COUNT = (1 << INDEX_BITS) + 1; // 33 + private const int TOTAL_SIZE = INDEX_COUNT * INDEX_COUNT * INDEX_COUNT; // 35937 + + public QuantizerResult Quantize(int[] pixels, int colorCount) + { + var mapResult = new QuantizerMap().Quantize(pixels, colorCount); + ConstructHistogram(mapResult.ColorToCount); + CreateMoments(); + var createBoxesResult = CreateBoxes(colorCount); + var colors = CreateResult(createBoxesResult.resultCount); + var resultMap = new Dictionary(); + foreach (var color in colors) + { + resultMap[color] = 0; + } + return new QuantizerResult(resultMap); + } + + private static int GetIndex(int r, int g, int b) + { + return (r << (INDEX_BITS * 2)) + (r << (INDEX_BITS + 1)) + r + (g << INDEX_BITS) + g + b; + } + + private void ConstructHistogram(Dictionary pixels) + { + weights = new int[TOTAL_SIZE]; + momentsR = new int[TOTAL_SIZE]; + momentsG = new int[TOTAL_SIZE]; + momentsB = new int[TOTAL_SIZE]; + moments = new double[TOTAL_SIZE]; + + foreach (var pair in pixels) + { + int pixel = pair.Key; + int count = pair.Value; + int red = ColorUtils.RedFromArgb(pixel); + int green = ColorUtils.GreenFromArgb(pixel); + int blue = ColorUtils.BlueFromArgb(pixel); + int bitsToRemove = 8 - INDEX_BITS; + int iR = (red >> bitsToRemove) + 1; + int iG = (green >> bitsToRemove) + 1; + int iB = (blue >> bitsToRemove) + 1; + int index = GetIndex(iR, iG, iB); + weights[index] += count; + momentsR[index] += red * count; + momentsG[index] += green * count; + momentsB[index] += blue * count; + moments[index] += count * ((red * red) + (green * green) + (blue * blue)); + } + } + + private void CreateMoments() + { + for (int r = 1; r < INDEX_COUNT; ++r) + { + var area = new int[INDEX_COUNT]; + var areaR = new int[INDEX_COUNT]; + var areaG = new int[INDEX_COUNT]; + var areaB = new int[INDEX_COUNT]; + var area2 = new double[INDEX_COUNT]; + + for (int g = 1; g < INDEX_COUNT; ++g) + { + int line = 0; + int lineR = 0; + int lineG = 0; + int lineB = 0; + double line2 = 0.0; + for (int b = 1; b < INDEX_COUNT; ++b) + { + int index = GetIndex(r, g, b); + line += weights[index]; + lineR += momentsR[index]; + lineG += momentsG[index]; + lineB += momentsB[index]; + line2 += moments[index]; + + area[b] += line; + areaR[b] += lineR; + areaG[b] += lineG; + areaB[b] += lineB; + area2[b] += line2; + + int previousIndex = GetIndex(r - 1, g, b); + weights[index] = weights[previousIndex] + area[b]; + momentsR[index] = momentsR[previousIndex] + areaR[b]; + momentsG[index] = momentsG[previousIndex] + areaG[b]; + momentsB[index] = momentsB[previousIndex] + areaB[b]; + moments[index] = moments[previousIndex] + area2[b]; + } + } + } + } + + private CreateBoxesResult CreateBoxes(int maxColorCount) + { + cubes = new Box[maxColorCount]; + for (int i = 0; i < maxColorCount; i++) cubes[i] = new Box(); + var volumeVariance = new double[maxColorCount]; + var firstBox = cubes[0]; + firstBox.r1 = INDEX_COUNT - 1; + firstBox.g1 = INDEX_COUNT - 1; + firstBox.b1 = INDEX_COUNT - 1; + + int generatedColorCount = maxColorCount; + int next = 0; + for (int i = 1; i < maxColorCount; i++) + { + if (Cut(cubes[next], cubes[i])) + { + volumeVariance[next] = (cubes[next].vol > 1) ? Variance(cubes[next]) : 0.0; + volumeVariance[i] = (cubes[i].vol > 1) ? Variance(cubes[i]) : 0.0; + } + else + { + volumeVariance[next] = 0.0; + i--; + } + + next = 0; + double temp = volumeVariance[0]; + for (int j = 1; j <= i; j++) + { + if (volumeVariance[j] > temp) + { + temp = volumeVariance[j]; + next = j; + } + } + if (temp <= 0.0) + { + generatedColorCount = i + 1; + break; + } + } + + return new CreateBoxesResult(maxColorCount, generatedColorCount); + } + + private List CreateResult(int colorCount) + { + var colors = new List(); + for (int i = 0; i < colorCount; ++i) + { + var cube = cubes[i]; + int weight = Volume(cube, weights); + if (weight > 0) + { + int r = Volume(cube, momentsR) / weight; + int g = Volume(cube, momentsG) / weight; + int b = Volume(cube, momentsB) / weight; + int color = (255 << 24) | ((r & 0x0ff) << 16) | ((g & 0x0ff) << 8) | (b & 0x0ff); + colors.Add(color); + } + } + return colors; + } + + private double Variance(Box cube) + { + int dr = Volume(cube, momentsR); + int dg = Volume(cube, momentsG); + int db = Volume(cube, momentsB); + double xx = + moments[GetIndex(cube.r1, cube.g1, cube.b1)] + - moments[GetIndex(cube.r1, cube.g1, cube.b0)] + - moments[GetIndex(cube.r1, cube.g0, cube.b1)] + + moments[GetIndex(cube.r1, cube.g0, cube.b0)] + - moments[GetIndex(cube.r0, cube.g1, cube.b1)] + + moments[GetIndex(cube.r0, cube.g1, cube.b0)] + + moments[GetIndex(cube.r0, cube.g0, cube.b1)] + - moments[GetIndex(cube.r0, cube.g0, cube.b0)]; + + int hypotenuse = dr * dr + dg * dg + db * db; + int volume = Volume(cube, weights); + return xx - hypotenuse / (double)volume; + } + + private bool Cut(Box one, Box two) + { + int wholeR = Volume(one, momentsR); + int wholeG = Volume(one, momentsG); + int wholeB = Volume(one, momentsB); + int wholeW = Volume(one, weights); + + var maxRResult = Maximize(one, Direction.RED, one.r0 + 1, one.r1, wholeR, wholeG, wholeB, wholeW); + var maxGResult = Maximize(one, Direction.GREEN, one.g0 + 1, one.g1, wholeR, wholeG, wholeB, wholeW); + var maxBResult = Maximize(one, Direction.BLUE, one.b0 + 1, one.b1, wholeR, wholeG, wholeB, wholeW); + Direction cutDirection; + double maxR = maxRResult.maximum; + double maxG = maxGResult.maximum; + double maxB = maxBResult.maximum; + if (maxR >= maxG && maxR >= maxB) + { + if (maxRResult.cutLocation < 0) + { + return false; + } + cutDirection = Direction.RED; + } + else if (maxG >= maxR && maxG >= maxB) + { + cutDirection = Direction.GREEN; + } + else + { + cutDirection = Direction.BLUE; + } + + two.r1 = one.r1; + two.g1 = one.g1; + two.b1 = one.b1; + + switch (cutDirection) + { + case Direction.RED: + one.r1 = maxRResult.cutLocation; + two.r0 = one.r1; + two.g0 = one.g0; + two.b0 = one.b0; + break; + case Direction.GREEN: + one.g1 = maxGResult.cutLocation; + two.r0 = one.r0; + two.g0 = one.g1; + two.b0 = one.b0; + break; + case Direction.BLUE: + one.b1 = maxBResult.cutLocation; + two.r0 = one.r0; + two.g0 = one.g0; + two.b0 = one.b1; + break; + } + + one.vol = (one.r1 - one.r0) * (one.g1 - one.g0) * (one.b1 - one.b0); + two.vol = (two.r1 - two.r0) * (two.g1 - two.g0) * (two.b1 - two.b0); + + return true; + } + + private MaximizeResult Maximize( + Box cube, + Direction direction, + int first, + int last, + int wholeR, + int wholeG, + int wholeB, + int wholeW) + { + int bottomR = Bottom(cube, direction, momentsR); + int bottomG = Bottom(cube, direction, momentsG); + int bottomB = Bottom(cube, direction, momentsB); + int bottomW = Bottom(cube, direction, weights); + + double max = 0.0; + int cut = -1; + + int halfR = 0; + int halfG = 0; + int halfB = 0; + int halfW = 0; + for (int i = first; i < last; i++) + { + halfR = bottomR + Top(cube, direction, i, momentsR); + halfG = bottomG + Top(cube, direction, i, momentsG); + halfB = bottomB + Top(cube, direction, i, momentsB); + halfW = bottomW + Top(cube, direction, i, weights); + if (halfW == 0) continue; + + double tempNumerator = (double)halfR * halfR + (double)halfG * halfG + (double)halfB * halfB; + double tempDenominator = halfW; + double temp = tempNumerator / tempDenominator; + + halfR = wholeR - halfR; + halfG = wholeG - halfG; + halfB = wholeB - halfB; + halfW = wholeW - halfW; + if (halfW == 0) continue; + + tempNumerator = (double)halfR * halfR + (double)halfG * halfG + (double)halfB * halfB; + tempDenominator = halfW; + temp += tempNumerator / tempDenominator; + + if (temp > max) + { + max = temp; + cut = i; + } + } + return new MaximizeResult(cut, max); + } + + private static int Volume(Box cube, int[] moment) + { + return (moment[GetIndex(cube.r1, cube.g1, cube.b1)] + - moment[GetIndex(cube.r1, cube.g1, cube.b0)] + - moment[GetIndex(cube.r1, cube.g0, cube.b1)] + + moment[GetIndex(cube.r1, cube.g0, cube.b0)] + - moment[GetIndex(cube.r0, cube.g1, cube.b1)] + + moment[GetIndex(cube.r0, cube.g1, cube.b0)] + + moment[GetIndex(cube.r0, cube.g0, cube.b1)] + - moment[GetIndex(cube.r0, cube.g0, cube.b0)]); + } + + private static int Bottom(Box cube, Direction direction, int[] moment) + { + return direction switch + { + Direction.RED => + -moment[GetIndex(cube.r0, cube.g1, cube.b1)] + + moment[GetIndex(cube.r0, cube.g1, cube.b0)] + + moment[GetIndex(cube.r0, cube.g0, cube.b1)] + - moment[GetIndex(cube.r0, cube.g0, cube.b0)], + Direction.GREEN => + -moment[GetIndex(cube.r1, cube.g0, cube.b1)] + + moment[GetIndex(cube.r1, cube.g0, cube.b0)] + + moment[GetIndex(cube.r0, cube.g0, cube.b1)] + - moment[GetIndex(cube.r0, cube.g0, cube.b0)], + _ => + -moment[GetIndex(cube.r1, cube.g1, cube.b0)] + + moment[GetIndex(cube.r1, cube.g0, cube.b0)] + + moment[GetIndex(cube.r0, cube.g1, cube.b0)] + - moment[GetIndex(cube.r0, cube.g0, cube.b0)], + }; + } + + private static int Top(Box cube, Direction direction, int position, int[] moment) + { + return direction switch + { + Direction.RED => + moment[GetIndex(position, cube.g1, cube.b1)] + - moment[GetIndex(position, cube.g1, cube.b0)] + - moment[GetIndex(position, cube.g0, cube.b1)] + + moment[GetIndex(position, cube.g0, cube.b0)], + Direction.GREEN => + moment[GetIndex(cube.r1, position, cube.b1)] + - moment[GetIndex(cube.r1, position, cube.b0)] + - moment[GetIndex(cube.r0, position, cube.b1)] + + moment[GetIndex(cube.r0, position, cube.b0)], + _ => + moment[GetIndex(cube.r1, cube.g1, position)] + - moment[GetIndex(cube.r1, cube.g0, position)] + - moment[GetIndex(cube.r0, cube.g1, position)] + + moment[GetIndex(cube.r0, cube.g0, position)], + }; + } + + private enum Direction { RED, GREEN, BLUE } + + private sealed class MaximizeResult + { + public int cutLocation; + public double maximum; + public MaximizeResult(int cut, double max) + { + cutLocation = cut; + maximum = max; + } + } + + private sealed class CreateBoxesResult + { + public int requestedCount; + public int resultCount; + public CreateBoxesResult(int requestedCount, int resultCount) + { + this.requestedCount = requestedCount; + this.resultCount = resultCount; + } + } + + private sealed class Box + { + public int r0 = 0; + public int r1 = 0; + public int g0 = 0; + public int g1 = 0; + public int b0 = 0; + public int b1 = 0; + public int vol = 0; + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Scheme/Scheme.cs b/src/MaterialDesign3.MaterialColorUtilities/Scheme/Scheme.cs new file mode 100644 index 0000000000..4458b15ecd --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Scheme/Scheme.cs @@ -0,0 +1,158 @@ +namespace MaterialColorUtilities; + +/// +/// Represents a Material color scheme, a mapping of color roles to colors. +/// +public record Scheme( + int Primary, + int OnPrimary, + int PrimaryContainer, + int OnPrimaryContainer, + int Secondary, + int OnSecondary, + int SecondaryContainer, + int OnSecondaryContainer, + int Tertiary, + int OnTertiary, + int TertiaryContainer, + int OnTertiaryContainer, + int Error, + int OnError, + int ErrorContainer, + int OnErrorContainer, + int Background, + int OnBackground, + int Surface, + int OnSurface, + int SurfaceVariant, + int OnSurfaceVariant, + int Outline, + int OutlineVariant, + int Shadow, + int Scrim, + int InverseSurface, + int InverseOnSurface, + int InversePrimary) +{ + /// + /// Creates a light theme Scheme from a source color in ARGB. + /// + public static Scheme Light(int argb) + { + var core = CorePalette.Of(argb); + return LightFromCorePalette(core); + } + + /// + /// Creates a dark theme Scheme from a source color in ARGB. + /// + public static Scheme Dark(int argb) + { + var core = CorePalette.Of(argb); + return DarkFromCorePalette(core); + } + + /// + /// Creates a light theme content-based Scheme from a source color in ARGB. + /// + public static Scheme LightContent(int argb) + { + var core = CorePalette.ContentOf(argb); + return LightFromCorePalette(core); + } + + /// + /// Creates a dark theme content-based Scheme from a source color in ARGB. + /// + public static Scheme DarkContent(int argb) + { + var core = CorePalette.ContentOf(argb); + return DarkFromCorePalette(core); + } + + private static Scheme LightFromCorePalette(CorePalette core) + { + return new Scheme( + // Primary + core.a1.Tone(40), + core.a1.Tone(100), + core.a1.Tone(90), + core.a1.Tone(10), + // Secondary + core.a2.Tone(40), + core.a2.Tone(100), + core.a2.Tone(90), + core.a2.Tone(10), + // Tertiary + core.a3.Tone(40), + core.a3.Tone(100), + core.a3.Tone(90), + core.a3.Tone(10), + // Error + core.error.Tone(40), + core.error.Tone(100), + core.error.Tone(90), + core.error.Tone(10), + // Neutral n1 + core.n1.Tone(99), + core.n1.Tone(10), + core.n1.Tone(99), + core.n1.Tone(10), + // Neutral variant n2 + core.n2.Tone(90), + core.n2.Tone(30), + core.n2.Tone(50), + core.n2.Tone(80), + // Shadow, Scrim + unchecked((int)0xff000000), // shadow (0 with alpha 255) + unchecked((int)0xff000000), // scrim + // Inverse + core.n1.Tone(20), + core.n1.Tone(95), + core.a1.Tone(80) + ); + } + + private static Scheme DarkFromCorePalette(CorePalette core) + { + return new Scheme( + // Primary + core.a1.Tone(80), + core.a1.Tone(20), + core.a1.Tone(30), + core.a1.Tone(90), + // Secondary + core.a2.Tone(80), + core.a2.Tone(20), + core.a2.Tone(30), + core.a2.Tone(90), + // Tertiary + core.a3.Tone(80), + core.a3.Tone(20), + core.a3.Tone(30), + core.a3.Tone(90), + // Error + core.error.Tone(80), + core.error.Tone(20), + core.error.Tone(30), + core.error.Tone(80), + // Neutral n1 + core.n1.Tone(10), + core.n1.Tone(90), + core.n1.Tone(10), + core.n1.Tone(90), + // Neutral variant n2 + core.n2.Tone(30), + core.n2.Tone(80), + core.n2.Tone(60), + core.n2.Tone(30), + // Shadow, Scrim + unchecked((int)0xff000000), // shadow + unchecked((int)0xff000000), // scrim + // Inverse + core.n1.Tone(90), + core.n1.Tone(20), + core.a1.Tone(40) + ); + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeContent.cs b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeContent.cs new file mode 100644 index 0000000000..22af251549 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeContent.cs @@ -0,0 +1,31 @@ +namespace MaterialColorUtilities; + +public class SchemeContent: DynamicScheme +{ + public SchemeContent(Hct sourceColorHct, bool isDark, double contrastLevel) + : this(sourceColorHct, isDark, contrastLevel, DEFAULT_SPEC_VERSION, DEFAULT_PLATFORM) + { + } + + public SchemeContent( + Hct sourceColorHct, + bool isDark, + double contrastLevel, + SpecVersion specVersion, + Platform platform) + : base( + sourceColorHct, + Variant.CONTENT, + isDark, + contrastLevel, + platform, + specVersion, + ColorSpecs.Get(specVersion).GetPrimaryPalette(Variant.CONTENT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetSecondaryPalette(Variant.CONTENT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetTertiaryPalette(Variant.CONTENT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralPalette(Variant.CONTENT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralVariantPalette(Variant.CONTENT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetErrorPalette(Variant.CONTENT, sourceColorHct, isDark, platform, contrastLevel)) + { + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeExpressive.cs b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeExpressive.cs new file mode 100644 index 0000000000..d31478d458 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeExpressive.cs @@ -0,0 +1,31 @@ +namespace MaterialColorUtilities; + +public class SchemeExpressive: DynamicScheme +{ + public SchemeExpressive(Hct sourceColorHct, bool isDark, double contrastLevel) + : this(sourceColorHct, isDark, contrastLevel, DEFAULT_SPEC_VERSION, DEFAULT_PLATFORM) + { + } + + public SchemeExpressive( + Hct sourceColorHct, + bool isDark, + double contrastLevel, + SpecVersion specVersion, + Platform platform) + : base( + sourceColorHct, + Variant.EXPRESSIVE, + isDark, + contrastLevel, + platform, + specVersion, + ColorSpecs.Get(specVersion).GetPrimaryPalette(Variant.EXPRESSIVE, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetSecondaryPalette(Variant.EXPRESSIVE, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetTertiaryPalette(Variant.EXPRESSIVE, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralPalette(Variant.EXPRESSIVE, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralVariantPalette(Variant.EXPRESSIVE, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetErrorPalette(Variant.EXPRESSIVE, sourceColorHct, isDark, platform, contrastLevel)) + { + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeFidelity.cs b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeFidelity.cs new file mode 100644 index 0000000000..78f2407a0a --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeFidelity.cs @@ -0,0 +1,31 @@ +namespace MaterialColorUtilities; + +public class SchemeFidelity: DynamicScheme +{ + public SchemeFidelity(Hct sourceColorHct, bool isDark, double contrastLevel) + : this(sourceColorHct, isDark, contrastLevel, DEFAULT_SPEC_VERSION, DEFAULT_PLATFORM) + { + } + + public SchemeFidelity( + Hct sourceColorHct, + bool isDark, + double contrastLevel, + SpecVersion specVersion, + Platform platform) + : base( + sourceColorHct, + Variant.FIDELITY, + isDark, + contrastLevel, + platform, + specVersion, + ColorSpecs.Get(specVersion).GetPrimaryPalette(Variant.FIDELITY, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetSecondaryPalette(Variant.FIDELITY, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetTertiaryPalette(Variant.FIDELITY, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralPalette(Variant.FIDELITY, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralVariantPalette(Variant.FIDELITY, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetErrorPalette(Variant.FIDELITY, sourceColorHct, isDark, platform, contrastLevel)) + { + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeFruitSalad.cs b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeFruitSalad.cs new file mode 100644 index 0000000000..8e224fa292 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeFruitSalad.cs @@ -0,0 +1,31 @@ +namespace MaterialColorUtilities; + +public class SchemeFruitSalad: DynamicScheme +{ + public SchemeFruitSalad(Hct sourceColorHct, bool isDark, double contrastLevel) + : this(sourceColorHct, isDark, contrastLevel, DEFAULT_SPEC_VERSION, DEFAULT_PLATFORM) + { + } + + public SchemeFruitSalad( + Hct sourceColorHct, + bool isDark, + double contrastLevel, + SpecVersion specVersion, + Platform platform) + : base( + sourceColorHct, + Variant.FRUIT_SALAD, + isDark, + contrastLevel, + platform, + specVersion, + ColorSpecs.Get(specVersion).GetPrimaryPalette(Variant.FRUIT_SALAD, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetSecondaryPalette(Variant.FRUIT_SALAD, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetTertiaryPalette(Variant.FRUIT_SALAD, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralPalette(Variant.FRUIT_SALAD, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralVariantPalette(Variant.FRUIT_SALAD, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetErrorPalette(Variant.FRUIT_SALAD, sourceColorHct, isDark, platform, contrastLevel)) + { + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeMonochrome.cs b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeMonochrome.cs new file mode 100644 index 0000000000..4bb28b1194 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeMonochrome.cs @@ -0,0 +1,31 @@ +namespace MaterialColorUtilities; + +public class SchemeMonochrome: DynamicScheme +{ + public SchemeMonochrome(Hct sourceColorHct, bool isDark, double contrastLevel) + : this(sourceColorHct, isDark, contrastLevel, DEFAULT_SPEC_VERSION, DEFAULT_PLATFORM) + { + } + + public SchemeMonochrome( + Hct sourceColorHct, + bool isDark, + double contrastLevel, + SpecVersion specVersion, + Platform platform) + : base( + sourceColorHct, + Variant.MONOCHROME, + isDark, + contrastLevel, + platform, + specVersion, + ColorSpecs.Get(specVersion).GetPrimaryPalette(Variant.MONOCHROME, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetSecondaryPalette(Variant.MONOCHROME, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetTertiaryPalette(Variant.MONOCHROME, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralPalette(Variant.MONOCHROME, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralVariantPalette(Variant.MONOCHROME, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetErrorPalette(Variant.MONOCHROME, sourceColorHct, isDark, platform, contrastLevel)) + { + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeNeutral.cs b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeNeutral.cs new file mode 100644 index 0000000000..3a8f5e9165 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeNeutral.cs @@ -0,0 +1,31 @@ +namespace MaterialColorUtilities; + +public class SchemeNeutral: DynamicScheme +{ + public SchemeNeutral(Hct sourceColorHct, bool isDark, double contrastLevel) + : this(sourceColorHct, isDark, contrastLevel, DEFAULT_SPEC_VERSION, DEFAULT_PLATFORM) + { + } + + public SchemeNeutral( + Hct sourceColorHct, + bool isDark, + double contrastLevel, + SpecVersion specVersion, + Platform platform) + : base( + sourceColorHct, + Variant.NEUTRAL, + isDark, + contrastLevel, + platform, + specVersion, + ColorSpecs.Get(specVersion).GetPrimaryPalette(Variant.NEUTRAL, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetSecondaryPalette(Variant.NEUTRAL, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetTertiaryPalette(Variant.NEUTRAL, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralPalette(Variant.NEUTRAL, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralVariantPalette(Variant.NEUTRAL, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetErrorPalette(Variant.NEUTRAL, sourceColorHct, isDark, platform, contrastLevel)) + { + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeRainbow.cs b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeRainbow.cs new file mode 100644 index 0000000000..38617fd0ce --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeRainbow.cs @@ -0,0 +1,31 @@ +namespace MaterialColorUtilities; + +public class SchemeRainbow: DynamicScheme +{ + public SchemeRainbow(Hct sourceColorHct, bool isDark, double contrastLevel) + : this(sourceColorHct, isDark, contrastLevel, DEFAULT_SPEC_VERSION, DEFAULT_PLATFORM) + { + } + + public SchemeRainbow( + Hct sourceColorHct, + bool isDark, + double contrastLevel, + SpecVersion specVersion, + Platform platform) + : base( + sourceColorHct, + Variant.RAINBOW, + isDark, + contrastLevel, + platform, + specVersion, + ColorSpecs.Get(specVersion).GetPrimaryPalette(Variant.RAINBOW, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetSecondaryPalette(Variant.RAINBOW, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetTertiaryPalette(Variant.RAINBOW, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralPalette(Variant.RAINBOW, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralVariantPalette(Variant.RAINBOW, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetErrorPalette(Variant.RAINBOW, sourceColorHct, isDark, platform, contrastLevel)) + { + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeTonalSpot.cs b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeTonalSpot.cs new file mode 100644 index 0000000000..8fd7e19198 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeTonalSpot.cs @@ -0,0 +1,31 @@ +namespace MaterialColorUtilities; + +public class SchemeTonalSpot: DynamicScheme +{ + public SchemeTonalSpot(Hct sourceColorHct, bool isDark, double contrastLevel) + : this(sourceColorHct, isDark, contrastLevel, DEFAULT_SPEC_VERSION, DEFAULT_PLATFORM) + { + } + + public SchemeTonalSpot( + Hct sourceColorHct, + bool isDark, + double contrastLevel, + SpecVersion specVersion, + Platform platform) + : base( + sourceColorHct, + Variant.TONAL_SPOT, + isDark, + contrastLevel, + platform, + specVersion, + ColorSpecs.Get(specVersion).GetPrimaryPalette(Variant.TONAL_SPOT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetSecondaryPalette(Variant.TONAL_SPOT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetTertiaryPalette(Variant.TONAL_SPOT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralPalette(Variant.TONAL_SPOT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralVariantPalette(Variant.TONAL_SPOT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetErrorPalette(Variant.TONAL_SPOT, sourceColorHct, isDark, platform, contrastLevel)) + { + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeVibrant.cs b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeVibrant.cs new file mode 100644 index 0000000000..2f902689ca --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Scheme/SchemeVibrant.cs @@ -0,0 +1,31 @@ +namespace MaterialColorUtilities; + +public class SchemeVibrant: DynamicScheme +{ + public SchemeVibrant(Hct sourceColorHct, bool isDark, double contrastLevel) + : this(sourceColorHct, isDark, contrastLevel, DEFAULT_SPEC_VERSION, DEFAULT_PLATFORM) + { + } + + public SchemeVibrant( + Hct sourceColorHct, + bool isDark, + double contrastLevel, + SpecVersion specVersion, + Platform platform) + : base( + sourceColorHct, + Variant.VIBRANT, + isDark, + contrastLevel, + platform, + specVersion, + ColorSpecs.Get(specVersion).GetPrimaryPalette(Variant.VIBRANT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetSecondaryPalette(Variant.VIBRANT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetTertiaryPalette(Variant.VIBRANT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralPalette(Variant.VIBRANT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetNeutralVariantPalette(Variant.VIBRANT, sourceColorHct, isDark, platform, contrastLevel), + ColorSpecs.Get(specVersion).GetErrorPalette(Variant.VIBRANT, sourceColorHct, isDark, platform, contrastLevel)) + { + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Score/Score.cs b/src/MaterialDesign3.MaterialColorUtilities/Score/Score.cs new file mode 100644 index 0000000000..5de9a0f96c --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Score/Score.cs @@ -0,0 +1,129 @@ +namespace MaterialColorUtilities; + +/// +/// Given a large set of colors, remove unsuitable colors and rank the rest based on suitability. +/// +public static class Score +{ + private const double TargetChroma = 48.0; + private const double WeightProportion = 0.7; + private const double WeightChromaAbove = 0.3; + private const double WeightChromaBelow = 0.1; + private const double CutoffChroma = 5.0; + private const double CutoffExcitedProportion = 0.01; + + private const int GoogleBlue = unchecked((int)0xff4285f4); + + /// + /// Given a map with keys of colors and values of how often the color appears, rank the colors + /// based on suitability for being used for a UI theme. + /// + /// map with keys of colors and values of how often the color appears. + /// max count of colors to be returned in the list. + /// color to be returned if no other options available. + /// whether to filter out undesireable combinations. + /// Colors sorted by suitability for a UI theme. + public static IEnumerable ScoreColors( + Dictionary colorsToPopulation, + int desired = 4, + int fallbackColorArgb = GoogleBlue, + bool filter = true) + { + // Get the HCT color for each Argb value, while finding the per hue count and total count. + List colorsHct = []; + var huePopulation = new int[360]; + var populationSum = 0.0; + foreach (var entry in colorsToPopulation) + { + var hct = Hct.FromInt(entry.Key); + colorsHct.Add(hct); + var hue = (int)Math.Floor(hct.Hue); + huePopulation[hue] += entry.Value; + populationSum += entry.Value; + } + + // Hues with more usage in neighboring 30 degree slice get a larger number. + var hueExcitedProportions = new double[360]; + for (var hue = 0; hue < 360; hue++) + { + var proportion = populationSum == 0.0 ? 0.0 : huePopulation[hue] / populationSum; + for (var i = hue - 14; i < hue + 16; i++) + { + var neighborHue = MathUtils.SanitizeDegreesInt(i); + hueExcitedProportions[neighborHue] += proportion; + } + } + + // Scores each HCT color based on usage and chroma, while optionally filtering out + // values that do not have enough chroma or usage. + List scoredHcts = []; + foreach (var hct in colorsHct) + { + var hue = MathUtils.SanitizeDegreesInt((int)Math.Round(hct.Hue)); + var proportion = hueExcitedProportions[hue]; + if (filter && (hct.Chroma < CutoffChroma || proportion <= CutoffExcitedProportion)) + { + continue; + } + + var proportionScore = proportion * 100.0 * WeightProportion; + var chromaWeight = hct.Chroma < TargetChroma ? WeightChromaBelow : WeightChromaAbove; + var chromaScore = (hct.Chroma - TargetChroma) * chromaWeight; + var score = proportionScore + chromaScore; + scoredHcts.Add(new ScoredHct(hct, score)); + } + + // Sorted so that colors with higher scores come first. + scoredHcts.Sort(new ScoredComparator()); + + // Iterates through potential hue differences in degrees in order to select the colors with + // the largest distribution of hues possible. Starting at 90 degrees (maximum difference for + // 4 colors) then decreasing down to a 15 degree minimum. + List chosenColors = []; + for (var differenceDegrees = 90; differenceDegrees >= 15; differenceDegrees--) + { + chosenColors.Clear(); + foreach (var entry in scoredHcts) + { + var hct = entry.Hct; + var hasDuplicateHue = false; + foreach (var chosenHct in chosenColors) + { + if (MathUtils.DifferenceDegrees(hct.Hue, chosenHct.Hue) < differenceDegrees) + { + hasDuplicateHue = true; + break; + } + } + if (!hasDuplicateHue) + { + chosenColors.Add(hct); + } + if (chosenColors.Count >= desired) + { + break; + } + } + if (chosenColors.Count >= desired) + { + break; + } + } + + return chosenColors.Count == 0 ? [fallbackColorArgb] : chosenColors.Select(c => c.Argb); + } + + private record ScoredHct(Hct Hct, double Score); + + private sealed class ScoredComparator : IComparer + { + public int Compare(ScoredHct? x, ScoredHct? y) + { + if (x == null && y == null) return 0; + if (x == null) return 1; + if (y == null) return -1; + // Descending by score + return Comparer.Default.Compare(y.Score, x.Score); + } + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Temperature/TemperatureCache.cs b/src/MaterialDesign3.MaterialColorUtilities/Temperature/TemperatureCache.cs new file mode 100644 index 0000000000..ceb1d74b4e --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Temperature/TemperatureCache.cs @@ -0,0 +1,298 @@ +using static System.Math; +using static MaterialColorUtilities.MathUtils; + +namespace MaterialColorUtilities; + +/// +/// Design utilities using color temperature theory: analogous colors, complementary color, and a cache. +/// +public sealed class TemperatureCache +{ + private readonly Hct input; + private Hct? precomputedComplement; + private List? precomputedHctsByTemp; + private List? precomputedHctsByHue; + private Dictionary? precomputedTempsByHct; + + /// + /// Create a cache that allows calculation of complementary and analogous colors. + /// Any returned colors will have the same tone and chroma as the input (subject to gamut limits). + /// + public TemperatureCache(Hct input) + { + this.input = input; + } + + /// + /// A color that complements the input color aesthetically. + /// + public Hct GetComplement() + { + if (precomputedComplement != null) + { + return precomputedComplement; + } + + var coldestHue = GetColdest().Hue; + var coldestTemp = GetTempsByHct()[GetColdest()]; + + var warmestHue = GetWarmest().Hue; + var warmestTemp = GetTempsByHct()[GetWarmest()]; + var range = warmestTemp - coldestTemp; + var startHueIsColdestToWarmest = IsBetween(input.Hue, coldestHue, warmestHue); + var startHue = startHueIsColdestToWarmest ? warmestHue : coldestHue; + var endHue = startHueIsColdestToWarmest ? coldestHue : warmestHue; + var directionOfRotation = 1.0; + var smallestError = 1000.0; + var answer = GetHctsByHue()[(int)Round(input.Hue)]; + + var complementRelativeTemp = (1.0 - GetRelativeTemperature(input)); + for (var hueAddend = 0.0; hueAddend <= 360.0; hueAddend += 1.0) + { + var hue = SanitizeDegreesDouble(startHue + directionOfRotation * hueAddend); + if (!IsBetween(hue, startHue, endHue)) + { + continue; + } + var possibleAnswer = GetHctsByHue()[(int)Round(hue)]; + var relativeTemp = (GetTempsByHct()[possibleAnswer] - coldestTemp) / range; + var error = Abs(complementRelativeTemp - relativeTemp); + if (error < smallestError) + { + smallestError = error; + answer = possibleAnswer; + } + } + precomputedComplement = answer; + return precomputedComplement; + } + + /// + /// 5 colors that pair well with the input color (equidistant in temperature and adjacent in hue). + /// + public List GetAnalogousColors() + { + return GetAnalogousColors(5, 12); + } + + /// + /// A set of colors with differing hues, equidistant in temperature. + /// + /// The number of colors to return, includes the input color. + /// The number of divisions on the color wheel. + public List GetAnalogousColors(int count, int divisions) + { + var startHue = (int)Round(input.Hue); + var startHct = GetHctsByHue()[startHue]; + var lastTemp = GetRelativeTemperature(startHct); + + List allColors = + [ + startHct + ]; + + var absoluteTotalTempDelta = 0.0; + for (var i = 0; i < 360; i++) + { + var hue = SanitizeDegreesInt(startHue + i); + var hct = GetHctsByHue()[hue]; + var temp = GetRelativeTemperature(hct); + var tempDelta = Abs(temp - lastTemp); + lastTemp = temp; + absoluteTotalTempDelta += tempDelta; + } + + var hueAddend = 1; + var tempStep = absoluteTotalTempDelta / (double)divisions; + var totalTempDelta = 0.0; + lastTemp = GetRelativeTemperature(startHct); + while (allColors.Count < divisions) + { + var hue = SanitizeDegreesInt(startHue + hueAddend); + var hct = GetHctsByHue()[hue]; + var temp = GetRelativeTemperature(hct); + var tempDelta = Abs(temp - lastTemp); + totalTempDelta += tempDelta; + + var desiredTotalTempDeltaForIndex = (allColors.Count * tempStep); + var indexSatisfied = totalTempDelta >= desiredTotalTempDeltaForIndex; + var indexAddend = 1; + while (indexSatisfied && allColors.Count < divisions) + { + allColors.Add(hct); + desiredTotalTempDeltaForIndex = ((allColors.Count + indexAddend) * tempStep); + indexSatisfied = totalTempDelta >= desiredTotalTempDeltaForIndex; + indexAddend++; + } + lastTemp = temp; + hueAddend++; + + if (hueAddend > 360) + { + while (allColors.Count < divisions) + { + allColors.Add(hct); + } + break; + } + } + + List answers = + [ + input + ]; + + var ccwCount = (int)Floor(((double)count - 1.0) / 2.0); + for (var i = 1; i < (ccwCount + 1); i++) + { + var index = 0 - i; + while (index < 0) + { + index = allColors.Count + index; + } + if (index >= allColors.Count) + { + index %= allColors.Count; + } + answers.Insert(0, allColors[index]); + } + + var cwCount = count - ccwCount - 1; + for (var i = 1; i < (cwCount + 1); i++) + { + var index = i; + while (index < 0) + { + index = allColors.Count + index; + } + if (index >= allColors.Count) + { + index %= allColors.Count; + } + answers.Add(allColors[index]); + } + + return answers; + } + + /// + /// Temperature relative to all colors with the same chroma and tone. + /// Value from 0 to 1. + /// + public double GetRelativeTemperature(Hct hct) + { + var range = GetTempsByHct()[GetWarmest()] - GetTempsByHct()[GetColdest()]; + var differenceFromColdest = GetTempsByHct()[hct] - GetTempsByHct()[GetColdest()]; + if (range == 0.0) + { + return 0.5; + } + return differenceFromColdest / range; + } + + /// + /// Value representing cool-warm factor of a color. Values below 0 are cool, above are warm. + /// Implementation of Ou, Woodcock and Wright's algorithm in Lab/LCH. + /// + public static double RawTemperature(Hct color) + { + var lab = ColorUtils.LabFromArgb(color.Argb); + var hue = SanitizeDegreesDouble(Atan2(lab[2], lab[1]) * 180.0 / PI); + var chroma = Sqrt(lab[1] * lab[1] + lab[2] * lab[2]); + return -0.5 + 0.02 * Pow(chroma, 1.07) * Cos((SanitizeDegreesDouble(hue - 50.0)) * PI / 180.0); + } + + /// + /// Coldest color with same chroma and tone as input. + /// + private Hct GetColdest() + { + return GetHctsByTemp()[0]; + } + + /// + /// HCTs for all colors with the same chroma/tone as the input, sorted by hue index (0..360). + /// + private List GetHctsByHue() + { + if (precomputedHctsByHue != null) + { + return precomputedHctsByHue; + } + List hcts = []; + for (var hue = 0.0; hue <= 360.0; hue += 1.0) + { + var colorAtHue = Hct.From(hue, input.Chroma, input.Tone); + hcts.Add(colorAtHue); + } + precomputedHctsByHue = hcts; + return precomputedHctsByHue; + } + + /// + /// HCTs for all colors with the same chroma/tone as the input, sorted from coldest to warmest. + /// + private List GetHctsByTemp() + { + if (precomputedHctsByTemp != null) + { + return precomputedHctsByTemp; + } + + List hcts = + [ + ..GetHctsByHue(), + input + ]; + hcts.Sort((a, b) => GetTempsByHct()[a].CompareTo(GetTempsByHct()[b])); + precomputedHctsByTemp = hcts; + return precomputedHctsByTemp; + } + + /// + /// Map of HCT to raw temperature for all hues at the input chroma/tone and the input itself. + /// + private Dictionary GetTempsByHct() + { + if (precomputedTempsByHct != null) + { + return precomputedTempsByHct; + } + + List allHcts = + [ + ..GetHctsByHue(), + input + ]; + + Dictionary temperaturesByHct = new(); + foreach (var hct in allHcts) + { + temperaturesByHct[hct] = RawTemperature(hct); + } + + precomputedTempsByHct = temperaturesByHct; + return precomputedTempsByHct; + } + + /// + /// Warmest color with same chroma and tone as input. + /// + private Hct GetWarmest() + { + var list = GetHctsByTemp(); + return list[^1]; + } + + /// + /// Determines if an angle is between two other angles, rotating clockwise. + /// + private static bool IsBetween(double angle, double a, double b) + { + if (a < b) + { + return a <= angle && angle <= b; + } + return a <= angle || angle <= b; + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Utils/ColorUtils.cs b/src/MaterialDesign3.MaterialColorUtilities/Utils/ColorUtils.cs new file mode 100644 index 0000000000..abf70a20e6 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Utils/ColorUtils.cs @@ -0,0 +1,249 @@ +namespace MaterialColorUtilities; + +/// +/// Color science utilities and conversions not covered by HCT or CAM16. +/// +public static class ColorUtils +{ + internal static readonly double[][] SRGB_TO_XYZ = + [ + [0.41233895, 0.35762064, 0.18051042], + [0.2126, 0.7152, 0.0722], + [0.01932141, 0.11916382, 0.95034478] + ]; + + internal static readonly double[][] XYZ_TO_SRGB = + [ + [3.2413774792388685, -1.5376652402851851, -0.49885366846268053], + [-0.9691452513005321, 1.8758853451067872, 0.04156585616912061], + [0.05562093689691305, -0.20395524564742123, 1.0571799111220335] + ]; + + internal static readonly double[] WHITE_POINT_D65 = [95.047, 100.0, 108.883]; + + /// + /// Converts a color from RGB components to ARGB format. + /// + public static int ArgbFromRgb(int red, int green, int blue) + { + return (255 << 24) | ((red & 255) << 16) | ((green & 255) << 8) | (blue & 255); + } + + /// + /// Converts a color from linear RGB components to ARGB format. + /// + public static int ArgbFromLinrgb(double[] linrgb) + { + var r = Delinearized(linrgb[0]); + var g = Delinearized(linrgb[1]); + var b = Delinearized(linrgb[2]); + return ArgbFromRgb(r, g, b); + } + + /// + /// Returns the alpha component of a color in ARGB format. + /// + public static int AlphaFromArgb(int argb) + { + return (argb >> 24) & 255; + } + + /// + /// Returns the red component of a color in ARGB format. + /// + public static int RedFromArgb(int argb) + { + return (argb >> 16) & 255; + } + + /// + /// Returns the green component of a color in ARGB format. + /// + public static int GreenFromArgb(int argb) + { + return (argb >> 8) & 255; + } + + /// + /// Returns the blue component of a color in ARGB format. + /// + public static int BlueFromArgb(int argb) + { + return argb & 255; + } + + /// + /// Returns whether a color in ARGB format is opaque. + /// + public static bool IsOpaque(int argb) + { + return AlphaFromArgb(argb) >= 255; + } + + /// + /// Converts a color from XYZ to ARGB. + /// + public static int ArgbFromXyz(double x, double y, double z) + { + var m = XYZ_TO_SRGB; + var linearR = m[0][0] * x + m[0][1] * y + m[0][2] * z; + var linearG = m[1][0] * x + m[1][1] * y + m[1][2] * z; + var linearB = m[2][0] * x + m[2][1] * y + m[2][2] * z; + var r = Delinearized(linearR); + var g = Delinearized(linearG); + var b = Delinearized(linearB); + return ArgbFromRgb(r, g, b); + } + + /// + /// Converts a color from ARGB to XYZ. + /// + public static double[] XyzFromArgb(int argb) + { + var r = Linearized(RedFromArgb(argb)); + var g = Linearized(GreenFromArgb(argb)); + var b = Linearized(BlueFromArgb(argb)); + return MathUtils.MatrixMultiply([r, g, b], SRGB_TO_XYZ); + } + + /// + /// Converts a color represented in Lab color space into an ARGB integer. + /// + public static int ArgbFromLab(double l, double a, double b) + { + var fy = (l + 16.0) / 116.0; + var fx = a / 500.0 + fy; + var fz = fy - b / 200.0; + var xNormalized = LabInvf(fx); + var yNormalized = LabInvf(fy); + var zNormalized = LabInvf(fz); + var x = xNormalized * WHITE_POINT_D65[0]; + var y = yNormalized * WHITE_POINT_D65[1]; + var z = zNormalized * WHITE_POINT_D65[2]; + return ArgbFromXyz(x, y, z); + } + + /// + /// Converts a color from ARGB representation to L*a*b* representation. + /// + public static double[] LabFromArgb(int argb) + { + var linearR = Linearized(RedFromArgb(argb)); + var linearG = Linearized(GreenFromArgb(argb)); + var linearB = Linearized(BlueFromArgb(argb)); + var m = SRGB_TO_XYZ; + var x = m[0][0] * linearR + m[0][1] * linearG + m[0][2] * linearB; + var y = m[1][0] * linearR + m[1][1] * linearG + m[1][2] * linearB; + var z = m[2][0] * linearR + m[2][1] * linearG + m[2][2] * linearB; + var xNorm = x / WHITE_POINT_D65[0]; + var yNorm = y / WHITE_POINT_D65[1]; + var zNorm = z / WHITE_POINT_D65[2]; + var fx = LabF(xNorm); + var fy = LabF(yNorm); + var fz = LabF(zNorm); + var l = 116.0 * fy - 16.0; + var a = 500.0 * (fx - fy); + var b = 200.0 * (fy - fz); + return [l, a, b]; + } + + /// + /// Converts an L* value to an ARGB representation. + /// + public static int ArgbFromLstar(double lstar) + { + var y = YFromLstar(lstar); + var component = Delinearized(y); + return ArgbFromRgb(component, component, component); + } + + /// + /// Computes the L* value of a color in ARGB representation. + /// + public static double LstarFromArgb(int argb) + { + var y = XyzFromArgb(argb)[1]; + return 116.0 * LabF(y / 100.0) - 16.0; + } + + /// + /// Converts an L* value to a Y value. + /// + public static double YFromLstar(double lstar) + { + return 100.0 * LabInvf((lstar + 16.0) / 116.0); + } + + /// + /// Converts a Y value to an L* value. + /// + public static double LstarFromY(double y) + { + return LabF(y / 100.0) * 116.0 - 16.0; + } + + /// + /// Linearizes an RGB component. + /// + public static double Linearized(int rgbComponent) + { + var normalized = rgbComponent / 255.0; + if (normalized <= 0.040449936) + { + return normalized / 12.92 * 100.0; + } + + return Math.Pow((normalized + 0.055) / 1.055, 2.4) * 100.0; + } + + /// + /// Delinearizes an RGB component. + /// + public static int Delinearized(double rgbComponent) + { + var normalized = rgbComponent / 100.0; + double delinearized; + if (normalized <= 0.0031308) + { + delinearized = normalized * 12.92; + } + else + { + delinearized = 1.055 * Math.Pow(normalized, 1.0 / 2.4) - 0.055; + } + return MathUtils.ClampInt(0, 255, (int)Math.Round(delinearized * 255.0)); + } + + /// + /// Returns the standard white point; white on a sunny day. + /// + public static double[] WhitePointD65() + { + return WHITE_POINT_D65; + } + + internal static double LabF(double t) + { + var e = 216.0 / 24389.0; + var kappa = 24389.0 / 27.0; + if (t > e) + { + return Math.Pow(t, 1.0 / 3.0); + } + + return (kappa * t + 16.0) / 116.0; + } + + internal static double LabInvf(double ft) + { + var e = 216.0 / 24389.0; + var kappa = 24389.0 / 27.0; + var ft3 = ft * ft * ft; + if (ft3 > e) + { + return ft3; + } + + return (116.0 * ft - 16.0) / kappa; + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Utils/MathUtils.cs b/src/MaterialDesign3.MaterialColorUtilities/Utils/MathUtils.cs new file mode 100644 index 0000000000..6152374348 --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Utils/MathUtils.cs @@ -0,0 +1,151 @@ +namespace MaterialColorUtilities; + +/// +/// Utility methods for mathematical operations. +/// +public static class MathUtils +{ + /// + /// The signum function. + /// + public static int Signum(double num) + { + if (num < 0) return -1; + if (num == 0) return 0; + return 1; + } + + /// + /// Linear interpolation between start and stop by amount. + /// + public static double Lerp(double start, double stop, double amount) + { + return (1.0 - amount) * start + amount * stop; + } + + /// + /// Clamp an int between min and max (inclusive). + /// + public static int ClampInt(int min, int max, int input) + { + if (input < min) return min; + if (input > max) return max; + return input; + } + + /// + /// Clamp a double between min and max (inclusive). + /// + public static double ClampDouble(double min, double max, double input) + { + if (input < min) return min; + if (input > max) return max; + return input; + } + + /// + /// Sanitize degrees to [0,360). + /// + public static int SanitizeDegreesInt(int degrees) + { + degrees %= 360; + if (degrees < 0) degrees += 360; + return degrees; + } + + /// + /// Sanitize degrees to [0.0,360.0). + /// + public static double SanitizeDegreesDouble(double degrees) + { + degrees %= 360.0; + if (degrees < 0) degrees += 360.0; + return degrees; + } + + /// + /// Sign of shortest rotation from 'from' to 'to' in degrees. + /// + public static double RotationDirection(double from, double to) + { + var increasingDifference = SanitizeDegreesDouble(to - from); + return increasingDifference <= 180.0 ? 1.0 : -1.0; + } + + /// + /// Shortest arc distance between two angles in degrees. + /// + public static double DifferenceDegrees(double a, double b) + { + return 180.0 - Math.Abs(Math.Abs(a - b) - 180.0); + } + + /// + /// Multiply a 1x3 row vector by a 3x3 matrix. + /// + public static double[] MatrixMultiply(double[] row, double[][] matrix) + { + var a = row[0] * matrix[0][0] + row[1] * matrix[0][1] + row[2] * matrix[0][2]; + var b = row[0] * matrix[1][0] + row[1] * matrix[1][1] + row[2] * matrix[1][2]; + var c = row[0] * matrix[2][0] + row[1] * matrix[2][1] + row[2] * matrix[2][2]; + return [a, b, c]; + } + + // --- Missing math helpers for cross-platform parity with Java/modern .NET --- + + /// + /// sqrt(x^2 + y^2) computed in a numerically stable way. + /// + public static double Hypot(double x, double y) + { + x = Math.Abs(x); + y = Math.Abs(y); + var max = Math.Max(x, y); + var min = Math.Min(x, y); + if (max == 0) return 0; + var r = min / max; + return max * Math.Sqrt(1 + r * r); + } + + /// + /// e^x - 1, with better precision for small x. + /// + public static double Expm1(double x) + { + if (x == 0.0) return 0.0; + var ax = Math.Abs(x); + if (ax < 1e-5) + { + // Series expansion: x + x^2/2 + x^3/6 + return x + 0.5 * x * x + (x * x * x) / 6.0; + } + return Math.Exp(x) - 1.0; + } + + /// + /// ln(1 + x), with better precision for small x. + /// + public static double Log1p(double x) + { + if (x <= -1.0) + { + // Domain error maps to -Infinity like Java's log1p for x == -1 and NaN for x < -1. + return x == -1.0 ? double.NegativeInfinity : double.NaN; + } + var ax = Math.Abs(x); + if (ax < 1e-5) + { + // Series expansion: x - x^2/2 + x^3/3 + return x - 0.5 * x * x + (x * x * x) / 3.0; + } + return Math.Log(1.0 + x); + } + + /// + /// Cube root that supports negative inputs. + /// + public static double Cbrt(double x) + { + return x < 0 ? -Math.Pow(-x, 1.0 / 3.0) : Math.Pow(x, 1.0 / 3.0); + } +} \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/Utils/StringUtils.cs b/src/MaterialDesign3.MaterialColorUtilities/Utils/StringUtils.cs new file mode 100644 index 0000000000..29af2097ea --- /dev/null +++ b/src/MaterialDesign3.MaterialColorUtilities/Utils/StringUtils.cs @@ -0,0 +1,18 @@ +namespace MaterialColorUtilities; + +/// +/// Utility methods for string representations of colors. +/// +public static class StringUtils +{ + /// + /// Hex string representing color, ex. #ff0000 for red. + /// + public static string HexFromArgb(int argb) + { + var red = ColorUtils.RedFromArgb(argb); + var green = ColorUtils.GreenFromArgb(argb); + var blue = ColorUtils.BlueFromArgb(argb); + return $"#{red:X2}{green:X2}{blue:X2}".ToLowerInvariant(); + } +} \ No newline at end of file diff --git a/src/Shims/MathCompat.cs b/src/Shims/MathCompat.cs new file mode 100644 index 0000000000..c336ba584b --- /dev/null +++ b/src/Shims/MathCompat.cs @@ -0,0 +1,19 @@ +#if NET462 +namespace System +{ + internal static class MathCompat + { + /// + /// Returns the cube root of a specified number. + /// + /// + /// Correctly handles negatives (real cube root), NaN, infinities, and signed zero. + /// + public static double Cbrt(double x) + { + if (double.IsNaN(x) || double.IsInfinity(x) || x == 0) return x; + return x < 0 ? -Math.Pow(-x, 1.0 / 3.0) : Math.Pow(x, 1.0 / 3.0); + } + } +} +#endif From 3126d0caa30afe4cb1c1796fbf2da73ef6e273da Mon Sep 17 00:00:00 2001 From: Johann Dirry Date: Fri, 12 Sep 2025 21:02:07 +0200 Subject: [PATCH 2/2] Implementing unit tests for MaterialColorUtilities --- MaterialDesignToolkit.Full.sln | 19 + .../Contrast/Contrast.cs | 8 +- .../DynamicColor/ColorSpec2021.cs | 39 +- .../DynamicColor/ColorSpec2025.cs | 47 +-- .../DynamicColor/ColorSpecs.cs | 10 +- .../DynamicColor/DynamicColor.cs | 15 +- .../DynamicColor/DynamicScheme.cs | 31 +- .../DynamicColor/MaterialDynamicColors.cs | 5 +- .../DynamicColor/TonePolarity.cs | 14 +- .../Hct/Cam16.cs | 77 +--- .../Hct/Hct.cs | 45 +-- .../Hct/HctSolver.cs | 35 +- .../MaterialColorUtilities.csproj | 2 + .../Palettes/CorePalette.cs | 10 +- .../Palettes/TonalPalette.cs | 15 +- .../Quantize/PointProviderLab.cs | 7 +- .../Quantize/QuantizerWu.cs | 5 +- .../Temperature/TemperatureCache.cs | 15 +- .../Utils/ColorUtils.cs | 47 +-- .../Utils/MathUtils.cs | 20 +- .../BlendTests.cs | 43 +++ .../ColorUtilsTests.cs | 267 +++++++++++++ .../ContrastConstraintTests.cs | 354 ++++++++++++++++++ .../ContrastTests.cs | 76 ++++ .../DislikeAnalyzerTests.cs | 86 +++++ .../DynamicSchemeTests.cs | 68 ++++ .../MaterialColorUtilities.Tests/HctTests.cs | 291 ++++++++++++++ .../MaterialColorUtilities.Tests.csproj | 34 ++ .../MaterialDynamicColorsTests.cs | 243 ++++++++++++ .../MathUtilsTests.cs | 48 +++ .../QuantizerCelebiTests.cs | 101 +++++ .../QuantizerWsMeansTests.cs | 79 ++++ .../QuantizerWuTests.cs | 121 ++++++ .../SchemeMonochromeTests.cs | 60 +++ .../ScoreTests.cs | 332 ++++++++++++++++ .../TemperatureCacheTests.cs | 126 +++++++ .../TonalPaletteTests.cs | 128 +++++++ 37 files changed, 2609 insertions(+), 314 deletions(-) create mode 100644 tests/MaterialColorUtilities.Tests/BlendTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/ColorUtilsTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/ContrastConstraintTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/ContrastTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/DislikeAnalyzerTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/DynamicSchemeTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/HctTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/MaterialColorUtilities.Tests.csproj create mode 100644 tests/MaterialColorUtilities.Tests/MaterialDynamicColorsTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/MathUtilsTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/QuantizerCelebiTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/QuantizerWsMeansTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/QuantizerWuTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/SchemeMonochromeTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/ScoreTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/TemperatureCacheTests.cs create mode 100644 tests/MaterialColorUtilities.Tests/TonalPaletteTests.cs diff --git a/MaterialDesignToolkit.Full.sln b/MaterialDesignToolkit.Full.sln index 0e85f04106..8810cebe10 100644 --- a/MaterialDesignToolkit.Full.sln +++ b/MaterialDesignToolkit.Full.sln @@ -65,6 +65,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MaterialDesignDemo.Shared", EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MaterialColorUtilities", "src\MaterialDesign3.MaterialColorUtilities\MaterialColorUtilities.csproj", "{2C29B80E-1689-43CE-85AC-71799666B4AC}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MaterialColorUtilities.Tests", "tests\MaterialColorUtilities.Tests\MaterialColorUtilities.Tests.csproj", "{91485BEA-759F-406E-87B7-68D94CF66DE4}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -269,6 +271,22 @@ Global {2C29B80E-1689-43CE-85AC-71799666B4AC}.Release|x64.Build.0 = Release|Any CPU {2C29B80E-1689-43CE-85AC-71799666B4AC}.Release|x86.ActiveCfg = Release|Any CPU {2C29B80E-1689-43CE-85AC-71799666B4AC}.Release|x86.Build.0 = Release|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Debug|ARM.ActiveCfg = Debug|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Debug|ARM.Build.0 = Debug|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Debug|x64.ActiveCfg = Debug|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Debug|x64.Build.0 = Debug|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Debug|x86.ActiveCfg = Debug|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Debug|x86.Build.0 = Debug|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Release|Any CPU.Build.0 = Release|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Release|ARM.ActiveCfg = Release|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Release|ARM.Build.0 = Release|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Release|x64.ActiveCfg = Release|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Release|x64.Build.0 = Release|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Release|x86.ActiveCfg = Release|Any CPU + {91485BEA-759F-406E-87B7-68D94CF66DE4}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -281,6 +299,7 @@ Global {98627CBE-F009-482E-97E9-C69C7135E91F} = {D34BE232-DE51-43C1-ABDC-B69003BB50FF} {B39795A7-D66A-4F2F-9F41-050838D14048} = {D34BE232-DE51-43C1-ABDC-B69003BB50FF} {2C29B80E-1689-43CE-85AC-71799666B4AC} = {9E303A4A-3712-44B9-91EE-830FDC087795} + {91485BEA-759F-406E-87B7-68D94CF66DE4} = {9E303A4A-3712-44B9-91EE-830FDC087795} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {730B2F9E-74AE-46CE-9E61-89AA5C6D5DD3} diff --git a/src/MaterialDesign3.MaterialColorUtilities/Contrast/Contrast.cs b/src/MaterialDesign3.MaterialColorUtilities/Contrast/Contrast.cs index 53f3e58681..e5ff70cda3 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/Contrast/Contrast.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/Contrast/Contrast.cs @@ -94,9 +94,11 @@ public static double RatioOfYs(double y1, double y2) /// color's lightness to in order to reach their desired contrast, instead of guessing & checking /// with hex codes. /// - public static double RatioOfTones(double t1, double t2) + public static double RatioOfTones(double toneA, double toneB) { - return RatioOfYs(ColorUtils.YFromLstar(t1), ColorUtils.YFromLstar(t2)); + return RatioOfYs( + ColorUtils.YFromLstar(MathUtils.Clamp(0.0, 100.0, toneA)), + ColorUtils.YFromLstar(MathUtils.Clamp(0.0, 100.0, toneB))); } /// @@ -191,4 +193,4 @@ public static double DarkerUnsafe(double tone, double ratio) var darkerSafe = Darker(tone, ratio); return Max(0.0, darkerSafe); } -} \ No newline at end of file +} diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2021.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2021.cs index 18abb40a60..80ae5bbd98 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2021.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2021.cs @@ -192,7 +192,7 @@ public class ColorSpec2021 : ColorSpec .SetIsBackground(true) .SetBackground(HighestSurface) .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 7.0)) - .SetToneDeltaPair(_ => new ToneDeltaPair(PrimaryContainer, Primary, 10.0, TonePolarity.NEARER, false)) + .SetToneDeltaPair(_ => new ToneDeltaPair(PrimaryContainer, Primary, 10.0, TonePolarity.Nearer, false)) .Build(); public DynamicColor? PrimaryDim => null; @@ -217,7 +217,7 @@ public class ColorSpec2021 : ColorSpec .SetIsBackground(true) .SetBackground(HighestSurface) .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) - .SetToneDeltaPair(_ => new ToneDeltaPair(PrimaryContainer, Primary, 10.0, TonePolarity.NEARER, false)) + .SetToneDeltaPair(_ => new ToneDeltaPair(PrimaryContainer, Primary, 10.0, TonePolarity.Nearer, false)) .Build(); public DynamicColor OnPrimaryContainer => new DynamicColor.Builder() @@ -249,7 +249,7 @@ public class ColorSpec2021 : ColorSpec .SetIsBackground(true) .SetBackground(HighestSurface) .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 7.0)) - .SetToneDeltaPair(_ => new ToneDeltaPair(SecondaryContainer, Secondary, 10.0, TonePolarity.NEARER, false)) + .SetToneDeltaPair(_ => new ToneDeltaPair(SecondaryContainer, Secondary, 10.0, TonePolarity.Nearer, false)) .Build(); public DynamicColor? SecondaryDim => null; @@ -275,7 +275,7 @@ public class ColorSpec2021 : ColorSpec .SetIsBackground(true) .SetBackground(HighestSurface) .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) - .SetToneDeltaPair(_ => new ToneDeltaPair(SecondaryContainer, Secondary, 10.0, TonePolarity.NEARER, false)) + .SetToneDeltaPair(_ => new ToneDeltaPair(SecondaryContainer, Secondary, 10.0, TonePolarity.Nearer, false)) .Build(); public DynamicColor OnSecondaryContainer => new DynamicColor.Builder() @@ -299,7 +299,7 @@ public class ColorSpec2021 : ColorSpec .SetIsBackground(true) .SetBackground(HighestSurface) .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 7.0)) - .SetToneDeltaPair(_ => new ToneDeltaPair(TertiaryContainer, Tertiary, 10.0, TonePolarity.NEARER, false)) + .SetToneDeltaPair(_ => new ToneDeltaPair(TertiaryContainer, Tertiary, 10.0, TonePolarity.Nearer, false)) .Build(); public DynamicColor? TertiaryDim => null; @@ -325,7 +325,7 @@ public class ColorSpec2021 : ColorSpec .SetIsBackground(true) .SetBackground(HighestSurface) .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) - .SetToneDeltaPair(_ => new ToneDeltaPair(TertiaryContainer, Tertiary, 10.0, TonePolarity.NEARER, false)) + .SetToneDeltaPair(_ => new ToneDeltaPair(TertiaryContainer, Tertiary, 10.0, TonePolarity.Nearer, false)) .Build(); public DynamicColor OnTertiaryContainer => new DynamicColor.Builder() @@ -349,7 +349,7 @@ public class ColorSpec2021 : ColorSpec .SetIsBackground(true) .SetBackground(HighestSurface) .SetContrastCurve(_ => new ContrastCurve(3.0, 4.5, 7.0, 7.0)) - .SetToneDeltaPair(_ => new ToneDeltaPair(ErrorContainer, Error, 10.0, TonePolarity.NEARER, false)) + .SetToneDeltaPair(_ => new ToneDeltaPair(ErrorContainer, Error, 10.0, TonePolarity.Nearer, false)) .Build(); public DynamicColor? ErrorDim => null; @@ -369,7 +369,7 @@ public class ColorSpec2021 : ColorSpec .SetIsBackground(true) .SetBackground(HighestSurface) .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) - .SetToneDeltaPair(_ => new ToneDeltaPair(ErrorContainer, Error, 10.0, TonePolarity.NEARER, false)) + .SetToneDeltaPair(_ => new ToneDeltaPair(ErrorContainer, Error, 10.0, TonePolarity.Nearer, false)) .Build(); public DynamicColor OnErrorContainer => new DynamicColor.Builder() @@ -388,7 +388,7 @@ public class ColorSpec2021 : ColorSpec .SetIsBackground(true) .SetBackground(HighestSurface) .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) - .SetToneDeltaPair(_ => new ToneDeltaPair(PrimaryFixed, PrimaryFixedDim, 10.0, TonePolarity.LIGHTER, true)) + .SetToneDeltaPair(_ => new ToneDeltaPair(PrimaryFixed, PrimaryFixedDim, 10.0, TonePolarity.Lighter, true)) .Build(); public DynamicColor PrimaryFixedDim => new DynamicColor.Builder() @@ -398,7 +398,7 @@ public class ColorSpec2021 : ColorSpec .SetIsBackground(true) .SetBackground(HighestSurface) .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) - .SetToneDeltaPair(_ => new ToneDeltaPair(PrimaryFixed, PrimaryFixedDim, 10.0, TonePolarity.LIGHTER, true)) + .SetToneDeltaPair(_ => new ToneDeltaPair(PrimaryFixed, PrimaryFixedDim, 10.0, TonePolarity.Lighter, true)) .Build(); public DynamicColor OnPrimaryFixed => new DynamicColor.Builder() @@ -427,7 +427,7 @@ public class ColorSpec2021 : ColorSpec .SetIsBackground(true) .SetBackground(HighestSurface) .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) - .SetToneDeltaPair(_ => new ToneDeltaPair(SecondaryFixed, SecondaryFixedDim, 10.0, TonePolarity.LIGHTER, true)) + .SetToneDeltaPair(_ => new ToneDeltaPair(SecondaryFixed, SecondaryFixedDim, 10.0, TonePolarity.Lighter, true)) .Build(); public DynamicColor SecondaryFixedDim => new DynamicColor.Builder() @@ -437,7 +437,7 @@ public class ColorSpec2021 : ColorSpec .SetIsBackground(true) .SetBackground(HighestSurface) .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) - .SetToneDeltaPair(_ => new ToneDeltaPair(SecondaryFixed, SecondaryFixedDim, 10.0, TonePolarity.LIGHTER, true)) + .SetToneDeltaPair(_ => new ToneDeltaPair(SecondaryFixed, SecondaryFixedDim, 10.0, TonePolarity.Lighter, true)) .Build(); public DynamicColor OnSecondaryFixed => new DynamicColor.Builder() @@ -466,7 +466,7 @@ public class ColorSpec2021 : ColorSpec .SetIsBackground(true) .SetBackground(HighestSurface) .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) - .SetToneDeltaPair(_ => new ToneDeltaPair(TertiaryFixed, TertiaryFixedDim, 10.0, TonePolarity.LIGHTER, true)) + .SetToneDeltaPair(_ => new ToneDeltaPair(TertiaryFixed, TertiaryFixedDim, 10.0, TonePolarity.Lighter, true)) .Build(); public DynamicColor TertiaryFixedDim => new DynamicColor.Builder() @@ -476,7 +476,7 @@ public class ColorSpec2021 : ColorSpec .SetIsBackground(true) .SetBackground(HighestSurface) .SetContrastCurve(_ => new ContrastCurve(1.0, 1.0, 3.0, 4.5)) - .SetToneDeltaPair(_ => new ToneDeltaPair(TertiaryFixed, TertiaryFixedDim, 10.0, TonePolarity.LIGHTER, true)) + .SetToneDeltaPair(_ => new ToneDeltaPair(TertiaryFixed, TertiaryFixedDim, 10.0, TonePolarity.Lighter, true)) .Build(); public DynamicColor OnTertiaryFixed => new DynamicColor.Builder() @@ -605,9 +605,9 @@ public double GetTone(DynamicScheme scheme, DynamicColor color) var polarity = toneDeltaPair.Polarity; var stayTogether = toneDeltaPair.StayTogether; - var aIsNearer = (polarity == TonePolarity.NEARER - || (polarity == TonePolarity.LIGHTER && !scheme.IsDark) - || (polarity == TonePolarity.DARKER && !scheme.IsDark)); + var aIsNearer = (polarity == TonePolarity.Nearer + || (polarity == TonePolarity.Lighter && !scheme.IsDark) + || (polarity == TonePolarity.Darker && !scheme.IsDark)); var nearer = aIsNearer ? roleA : roleB; var farther = aIsNearer ? roleB : roleA; var amNearer = color.name.Equals(nearer.name, System.StringComparison.Ordinal); @@ -848,8 +848,5 @@ public TonalPalette GetNeutralVariantPalette(Variant variant, Hct sourceColorHct }; } - public TonalPalette? GetErrorPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel) - { - return null; - } + public TonalPalette? GetErrorPalette(Variant variant, Hct sourceColorHct, bool isDark, Platform platform, double contrastLevel) => null; } \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2025.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2025.cs index c8c6f316d3..d3f0e0e316 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2025.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpec2025.cs @@ -520,7 +520,7 @@ public class ColorSpec2025 : ColorSpec2021 }) .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(4.5) : GetContrastCurve(7)) .SetToneDeltaPair(s => s.PlatformType == Platform.PHONE - ? new ToneDeltaPair(PrimaryContainer, Primary, 5.0, TonePolarity.RELATIVE_LIGHTER, DeltaConstraint.FARTHER) + ? new ToneDeltaPair(PrimaryContainer, Primary, 5.0, TonePolarity.RelativeLighter, DeltaConstraint.FARTHER) : null!) .Build(); return base.Primary.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); @@ -543,7 +543,7 @@ public class ColorSpec2025 : ColorSpec2021 .SetIsBackground(true) .SetBackground(s => SurfaceContainerHigh) .SetContrastCurve(s => GetContrastCurve(4.5)) - .SetToneDeltaPair(s => new ToneDeltaPair(PrimaryDim!, Primary, 5.0, TonePolarity.DARKER, DeltaConstraint.FARTHER)) + .SetToneDeltaPair(s => new ToneDeltaPair(PrimaryDim!, Primary, 5.0, TonePolarity.Darker, DeltaConstraint.FARTHER)) .Build(); } } @@ -584,7 +584,7 @@ public class ColorSpec2025 : ColorSpec2021 if (s.PlatformType == Platform.PHONE) return s.IsDark ? SurfaceBright : SurfaceDim; return null!; }) - .SetToneDeltaPair(s => s.PlatformType == Platform.WATCH ? new ToneDeltaPair(PrimaryContainer, PrimaryDim!, 10.0, TonePolarity.DARKER, DeltaConstraint.FARTHER) : null!) + .SetToneDeltaPair(s => s.PlatformType == Platform.WATCH ? new ToneDeltaPair(PrimaryContainer, PrimaryDim!, 10.0, TonePolarity.Darker, DeltaConstraint.FARTHER) : null!) .SetContrastCurve(s => s.PlatformType == Platform.PHONE && s.ContrastLevel > 0 ? GetContrastCurve(1.5) : null!) .Build(); return base.PrimaryContainer.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); @@ -644,7 +644,7 @@ public class ColorSpec2025 : ColorSpec2021 }) .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(4.5) : GetContrastCurve(7)) .SetToneDeltaPair(s => s.PlatformType == Platform.PHONE - ? new ToneDeltaPair(SecondaryContainer, Secondary, 5.0, TonePolarity.RELATIVE_LIGHTER, DeltaConstraint.FARTHER) + ? new ToneDeltaPair(SecondaryContainer, Secondary, 5.0, TonePolarity.RelativeLighter, DeltaConstraint.FARTHER) : null!) .Build(); return base.Secondary.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); @@ -666,7 +666,7 @@ public class ColorSpec2025 : ColorSpec2021 .SetIsBackground(true) .SetBackground(s => SurfaceContainerHigh) .SetContrastCurve(s => GetContrastCurve(4.5)) - .SetToneDeltaPair(s => new ToneDeltaPair(SecondaryDim!, Secondary, 5.0, TonePolarity.DARKER, DeltaConstraint.FARTHER)) + .SetToneDeltaPair(s => new ToneDeltaPair(SecondaryDim!, Secondary, 5.0, TonePolarity.Darker, DeltaConstraint.FARTHER)) .Build(); } } @@ -705,7 +705,7 @@ public class ColorSpec2025 : ColorSpec2021 if (s.PlatformType == Platform.PHONE) return s.IsDark ? SurfaceBright : SurfaceDim; return null!; }) - .SetToneDeltaPair(s => s.PlatformType == Platform.WATCH ? new ToneDeltaPair(SecondaryContainer, SecondaryDim!, 10.0, TonePolarity.DARKER, DeltaConstraint.FARTHER) : null!) + .SetToneDeltaPair(s => s.PlatformType == Platform.WATCH ? new ToneDeltaPair(SecondaryContainer, SecondaryDim!, 10.0, TonePolarity.Darker, DeltaConstraint.FARTHER) : null!) .SetContrastCurve(s => s.PlatformType == Platform.PHONE && s.ContrastLevel > 0 ? GetContrastCurve(1.5) : null!) .Build(); return base.SecondaryContainer.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); @@ -756,7 +756,7 @@ public class ColorSpec2025 : ColorSpec2021 return SurfaceContainerHigh; }) .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(4.5) : GetContrastCurve(7)) - .SetToneDeltaPair(s => s.PlatformType == Platform.PHONE ? new ToneDeltaPair(TertiaryContainer, Tertiary, 5.0, TonePolarity.RELATIVE_LIGHTER, DeltaConstraint.FARTHER) : null!) + .SetToneDeltaPair(s => s.PlatformType == Platform.PHONE ? new ToneDeltaPair(TertiaryContainer, Tertiary, 5.0, TonePolarity.RelativeLighter, DeltaConstraint.FARTHER) : null!) .Build(); return base.Tertiary.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); } @@ -773,7 +773,7 @@ public class ColorSpec2025 : ColorSpec2021 .SetIsBackground(true) .SetBackground(s => SurfaceContainerHigh) .SetContrastCurve(s => GetContrastCurve(4.5)) - .SetToneDeltaPair(s => new ToneDeltaPair(TertiaryDim!, Tertiary, 5.0, TonePolarity.DARKER, DeltaConstraint.FARTHER)) + .SetToneDeltaPair(s => new ToneDeltaPair(TertiaryDim!, Tertiary, 5.0, TonePolarity.Darker, DeltaConstraint.FARTHER)) .Build(); } } @@ -831,7 +831,7 @@ public class ColorSpec2025 : ColorSpec2021 if (s.PlatformType == Platform.PHONE) return s.IsDark ? SurfaceBright : SurfaceDim; return null!; }) - .SetToneDeltaPair(s => s.PlatformType == Platform.WATCH ? new ToneDeltaPair(TertiaryContainer, TertiaryDim!, 10.0, TonePolarity.DARKER, DeltaConstraint.FARTHER) : null!) + .SetToneDeltaPair(s => s.PlatformType == Platform.WATCH ? new ToneDeltaPair(TertiaryContainer, TertiaryDim!, 10.0, TonePolarity.Darker, DeltaConstraint.FARTHER) : null!) .SetContrastCurve(s => s.PlatformType == Platform.PHONE && s.ContrastLevel > 0 ? GetContrastCurve(1.5) : null!) .Build(); return base.TertiaryContainer.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); @@ -868,7 +868,7 @@ public class ColorSpec2025 : ColorSpec2021 .SetIsBackground(true) .SetBackground(s => s.PlatformType == Platform.PHONE ? (s.IsDark ? SurfaceBright : SurfaceDim) : SurfaceContainerHigh) .SetContrastCurve(s => s.PlatformType == Platform.PHONE ? GetContrastCurve(4.5) : GetContrastCurve(7)) - .SetToneDeltaPair(s => s.PlatformType == Platform.PHONE ? new ToneDeltaPair(ErrorContainer, Error, 5.0, TonePolarity.RELATIVE_LIGHTER, DeltaConstraint.FARTHER) : null!) + .SetToneDeltaPair(s => s.PlatformType == Platform.PHONE ? new ToneDeltaPair(ErrorContainer, Error, 5.0, TonePolarity.RelativeLighter, DeltaConstraint.FARTHER) : null!) .Build(); return base.Error.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); } @@ -885,7 +885,7 @@ public class ColorSpec2025 : ColorSpec2021 .SetIsBackground(true) .SetBackground(s => SurfaceContainerHigh) .SetContrastCurve(s => GetContrastCurve(4.5)) - .SetToneDeltaPair(s => new ToneDeltaPair(ErrorDim!, Error, 5.0, TonePolarity.DARKER, DeltaConstraint.FARTHER)) + .SetToneDeltaPair(s => new ToneDeltaPair(ErrorDim!, Error, 5.0, TonePolarity.Darker, DeltaConstraint.FARTHER)) .Build(); } } @@ -918,7 +918,7 @@ public class ColorSpec2025 : ColorSpec2021 }) .SetIsBackground(true) .SetBackground(s => s.PlatformType == Platform.PHONE ? (s.IsDark ? SurfaceBright : SurfaceDim) : null!) - .SetToneDeltaPair(s => s.PlatformType == Platform.WATCH ? new ToneDeltaPair(ErrorContainer, ErrorDim!, 10.0, TonePolarity.DARKER, DeltaConstraint.FARTHER) : null!) + .SetToneDeltaPair(s => s.PlatformType == Platform.WATCH ? new ToneDeltaPair(ErrorContainer, ErrorDim!, 10.0, TonePolarity.Darker, DeltaConstraint.FARTHER) : null!) .SetContrastCurve(s => s.PlatformType == Platform.PHONE && s.ContrastLevel > 0 ? GetContrastCurve(1.5) : null!) .Build(); return base.ErrorContainer.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); @@ -969,7 +969,7 @@ public class ColorSpec2025 : ColorSpec2021 .SetPalette(s => s.PrimaryPalette) .SetTone(s => PrimaryFixed.GetTone(s)) .SetIsBackground(true) - .SetToneDeltaPair(s => new ToneDeltaPair(PrimaryFixedDim, PrimaryFixed, 5.0, TonePolarity.DARKER, DeltaConstraint.EXACT)) + .SetToneDeltaPair(s => new ToneDeltaPair(PrimaryFixedDim, PrimaryFixed, 5.0, TonePolarity.Darker, DeltaConstraint.EXACT)) .Build(); return base.PrimaryFixedDim.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); } @@ -1033,7 +1033,7 @@ public class ColorSpec2025 : ColorSpec2021 .SetPalette(s => s.SecondaryPalette) .SetTone(s => SecondaryFixed.GetTone(s)) .SetIsBackground(true) - .SetToneDeltaPair(s => new ToneDeltaPair(SecondaryFixedDim, SecondaryFixed, 5.0, TonePolarity.DARKER, DeltaConstraint.EXACT)) + .SetToneDeltaPair(s => new ToneDeltaPair(SecondaryFixedDim, SecondaryFixed, 5.0, TonePolarity.Darker, DeltaConstraint.EXACT)) .Build(); return base.SecondaryFixedDim.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); } @@ -1097,7 +1097,7 @@ public class ColorSpec2025 : ColorSpec2021 .SetPalette(s => s.TertiaryPalette) .SetTone(s => TertiaryFixed.GetTone(s)) .SetIsBackground(true) - .SetToneDeltaPair(s => new ToneDeltaPair(TertiaryFixedDim, TertiaryFixed, 5.0, TonePolarity.DARKER, DeltaConstraint.EXACT)) + .SetToneDeltaPair(s => new ToneDeltaPair(TertiaryFixedDim, TertiaryFixed, 5.0, TonePolarity.Darker, DeltaConstraint.EXACT)) .Build(); return base.TertiaryFixedDim.ToBuilder().ExtendSpecVersion(SpecVersion.SPEC_2025, color2025).Build(); } @@ -1178,15 +1178,9 @@ private static double FindBestToneForChroma(double hue, double chroma, double to return answer; } - private static double TMaxC(TonalPalette palette) - { - return TMaxC(palette, 0, 100); - } + private static double TMaxC(TonalPalette palette) => TMaxC(palette, 0, 100); - private static double TMaxC(TonalPalette palette, double lowerBound, double upperBound) - { - return TMaxC(palette, lowerBound, upperBound, 1.0); - } + private static double TMaxC(TonalPalette palette, double lowerBound, double upperBound) => TMaxC(palette, lowerBound, upperBound, 1.0); private static double TMaxC(TonalPalette palette, double lowerBound, double upperBound, double chromaMultiplier) { @@ -1194,10 +1188,7 @@ private static double TMaxC(TonalPalette palette, double lowerBound, double uppe return MathUtils.ClampDouble(lowerBound, upperBound, answer); } - private static double TMinC(TonalPalette palette) - { - return TMinC(palette, 0, 100); - } + private static double TMinC(TonalPalette palette) => TMinC(palette, 0, 100); private static double TMinC(TonalPalette palette, double lowerBound, double upperBound) { @@ -1239,7 +1230,7 @@ private static ContrastCurve GetContrastCurve(double @default) var roleB = toneDeltaPair.RoleB; var polarity = toneDeltaPair.Polarity; var constraint = toneDeltaPair.Constraint; - var absoluteDelta = (polarity == TonePolarity.DARKER || (polarity == TonePolarity.RELATIVE_LIGHTER && scheme.IsDark) || (polarity == TonePolarity.RELATIVE_DARKER && !scheme.IsDark)) + var absoluteDelta = (polarity == TonePolarity.Darker || (polarity == TonePolarity.RelativeLighter && scheme.IsDark) || (polarity == TonePolarity.RelativeDarker && !scheme.IsDark)) ? -toneDeltaPair.Delta : toneDeltaPair.Delta; var amRoleA = color.name.Equals(roleA.name); diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpecs.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpecs.cs index 255a979daa..cb098b5b16 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpecs.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/ColorSpecs.cs @@ -5,13 +5,7 @@ public static class ColorSpecs private static readonly ColorSpec SPEC_2021 = new ColorSpec2021(); private static readonly ColorSpec SPEC_2025 = new ColorSpec2025(); - public static ColorSpec Get() - { - return Get(SpecVersion.SPEC_2021); - } + public static ColorSpec Get() => Get(SpecVersion.SPEC_2021); - public static ColorSpec Get(SpecVersion specVersion) - { - return specVersion == SpecVersion.SPEC_2025 ? SPEC_2025 : SPEC_2021; - } + public static ColorSpec Get(SpecVersion specVersion) => specVersion == SpecVersion.SPEC_2025 ? SPEC_2025 : SPEC_2021; } \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicColor.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicColor.cs index 8aba4a353a..8547459b30 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicColor.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicColor.cs @@ -155,10 +155,7 @@ public Hct GetHct(DynamicScheme scheme) return answer; } - public double GetTone(DynamicScheme scheme) - { - return ColorSpecs.Get(scheme.SpecVersion).GetTone(scheme, this); - } + public double GetTone(DynamicScheme scheme) => ColorSpecs.Get(scheme.SpecVersion).GetTone(scheme, this); public static double ForegroundTone(double bgTone, double ratio) { @@ -196,15 +193,9 @@ public static double EnableLightForeground(double tone) return tone; } - public static bool TonePrefersLightForeground(double tone) - { - return Round(tone) < 60.0; - } + public static bool TonePrefersLightForeground(double tone) => Round(tone) < 60.0; - public static bool ToneAllowsLightForeground(double tone) - { - return Round(tone) <= 49.0; - } + public static bool ToneAllowsLightForeground(double tone) => Round(tone) <= 49.0; public static Func GetInitialToneFromBackground( Func? background) diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicScheme.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicScheme.cs index 4d53b40371..a17a4852db 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicScheme.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/DynamicScheme.cs @@ -23,10 +23,7 @@ public class DynamicScheme public TonalPalette NeutralVariantPalette { get; } public TonalPalette ErrorPalette { get; } - public DynamicScheme() - { - throw new NotImplementedException(); - } + public DynamicScheme() => throw new NotImplementedException(); public DynamicScheme( Hct sourceColorHct, @@ -111,10 +108,7 @@ public DynamicScheme( ErrorPalette = errorPalette ?? TonalPalette.FromHueAndChroma(25.0, 84.0); } - public static DynamicScheme From(DynamicScheme other, bool isDark) - { - return From(other, isDark, other.ContrastLevel); - } + public static DynamicScheme From(DynamicScheme other, bool isDark) => From(other, isDark, other.ContrastLevel); public static DynamicScheme From(DynamicScheme other, bool isDark, double contrastLevel) { @@ -135,6 +129,9 @@ public static DynamicScheme From(DynamicScheme other, bool isDark, double contra public static double GetPiecewiseValue(Hct sourceColorHct, double[] hueBreakpoints, double[] hues) { + if (hueBreakpoints == null || hues == null) + throw new ArgumentNullException(hueBreakpoints == null ? nameof(hueBreakpoints) : nameof(hues)); + var size = Min(hueBreakpoints.Length - 1, hues.Length); var sourceHue = sourceColorHct.Hue; for (var i = 0; i < size; i++) @@ -144,12 +141,18 @@ public static double GetPiecewiseValue(Hct sourceColorHct, double[] hueBreakpoin return MathUtils.SanitizeDegreesDouble(hues[i]); } } + // No condition matched, return the source value. return sourceHue; } public static double GetRotatedHue(Hct sourceColorHct, double[] hueBreakpoints, double[] rotations) { + if (hueBreakpoints.Length != rotations.Length) + { + throw new ArgumentException("hueBreakpoints length must equal rotations length"); + } + var rotation = GetPiecewiseValue(sourceColorHct, hueBreakpoints, rotations); if (Min(hueBreakpoints.Length - 1, rotations.Length) <= 0) { @@ -158,19 +161,13 @@ public static double GetRotatedHue(Hct sourceColorHct, double[] hueBreakpoints, return MathUtils.SanitizeDegreesDouble(sourceColorHct.Hue + rotation); } - public Hct GetHct(DynamicColor dynamicColor) - { - return dynamicColor.GetHct(this); - } + public Hct GetHct(DynamicColor dynamicColor) => dynamicColor.GetHct(this); - public int GetArgb(DynamicColor dynamicColor) - { - return dynamicColor.GetArgb(this); - } + public int GetArgb(DynamicColor dynamicColor) => dynamicColor.GetArgb(this); public override string ToString() { var mode = IsDark ? "dark" : "light"; return $"Scheme: variant={Variant}, mode={mode}, platform={PlatformType.ToString().ToLowerInvariant()}, contrastLevel={ContrastLevel:0.0}, seed={SourceColorHct}, specVersion={SpecVersion}"; } -} \ No newline at end of file +} diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/MaterialDynamicColors.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/MaterialDynamicColors.cs index 32793d29a5..def4908c25 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/MaterialDynamicColors.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/MaterialDynamicColors.cs @@ -4,10 +4,7 @@ public sealed class MaterialDynamicColors { private static readonly ColorSpec colorSpec = new ColorSpec2025(); - public DynamicColor HighestSurface(DynamicScheme s) - { - return colorSpec.HighestSurface(s); - } + public DynamicColor HighestSurface(DynamicScheme s) => colorSpec.HighestSurface(s); // Main Palettes public DynamicColor PrimaryPaletteKeyColor => colorSpec.PrimaryPaletteKeyColor; diff --git a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/TonePolarity.cs b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/TonePolarity.cs index c4979b3fef..32ac616c02 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/TonePolarity.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/DynamicColor/TonePolarity.cs @@ -2,12 +2,12 @@ public enum TonePolarity { - DARKER, - LIGHTER, - RELATIVE_DARKER, - RELATIVE_LIGHTER, + Darker, + Lighter, + RelativeDarker, + RelativeLighter, [Obsolete("Use DeltaConstraint instead.")] - NEARER, + Nearer, [Obsolete("Use DeltaConstraint instead.")] - FARTHER, -} \ No newline at end of file + Farther, +} diff --git a/src/MaterialDesign3.MaterialColorUtilities/Hct/Cam16.cs b/src/MaterialDesign3.MaterialColorUtilities/Hct/Cam16.cs index e683336d20..24ee6e83f8 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/Hct/Cam16.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/Hct/Cam16.cs @@ -60,74 +60,47 @@ public double Distance(Cam16 other) /// /// Hue in CAM16. /// - public double GetHue() - { - return Hue; - } + public double GetHue() => Hue; /// /// Chroma in CAM16. /// - public double GetChroma() - { - return Chroma; - } + public double GetChroma() => Chroma; /// /// Lightness in CAM16. /// - public double GetJ() - { - return J; - } + public double GetJ() => J; /// /// Brightness in CAM16. Prefer lightness. /// - public double GetQ() - { - return Q; - } + public double GetQ() => Q; /// /// Colorfulness in CAM16. Prefer chroma. /// - public double GetM() - { - return M; - } + public double GetM() => M; /// /// Saturation in CAM16. Prefer chroma. /// - public double GetS() - { - return S; - } + public double GetS() => S; /// /// Lightness coordinate in CAM16-UCS. /// - public double GetJstar() - { - return Jstar; - } + public double GetJstar() => Jstar; /// /// a* coordinate in CAM16-UCS. /// - public double GetAstar() - { - return Astar; - } + public double GetAstar() => Astar; /// /// b* coordinate in CAM16-UCS. /// - public double GetBstar() - { - return Bstar; - } + public double GetBstar() => Bstar; /// /// Constructor that sets all CAM16 and CAM16-UCS dimensions. @@ -157,10 +130,7 @@ private Cam16( /// /// Create a CAM16 color from an ARGB color in default viewing conditions. /// - public static Cam16 FromInt(int argb) - { - return FromIntInViewingConditions(argb, ViewingConditions.DEFAULT); - } + public static Cam16 FromInt(int argb) => FromIntInViewingConditions(argb, ViewingConditions.DEFAULT); /// /// Create a CAM16 color from an ARGB color in defined viewing conditions. @@ -262,10 +232,7 @@ internal static Cam16 FromXyzInViewingConditions( /// /// Create CAM16 from J, C, and H. /// - internal static Cam16 FromJch(double j, double c, double h) - { - return FromJchInViewingConditions(j, c, h, ViewingConditions.DEFAULT); - } + internal static Cam16 FromJch(double j, double c, double h) => FromJchInViewingConditions(j, c, h, ViewingConditions.DEFAULT); /// /// Create CAM16 from J, C, H and viewing conditions. @@ -294,10 +261,7 @@ private static Cam16 FromJchInViewingConditions(double j, double c, double h, Vi /// /// Create CAM16 from CAM16-UCS coordinates in default viewing conditions. /// - public static Cam16 FromUcs(double jstar, double astar, double bstar) - { - return FromUcsInViewingConditions(jstar, astar, bstar, ViewingConditions.DEFAULT); - } + public static Cam16 FromUcs(double jstar, double astar, double bstar) => FromUcsInViewingConditions(jstar, astar, bstar, ViewingConditions.DEFAULT); /// /// Create CAM16 from CAM16-UCS coordinates in defined viewing conditions. @@ -319,10 +283,7 @@ public static Cam16 FromUcsInViewingConditions(double jstar, double astar, doubl /// /// ARGB representation of this color in default viewing conditions. /// - public int ToInt() - { - return Viewed(ViewingConditions.DEFAULT); - } + public int ToInt() => Viewed(ViewingConditions.DEFAULT); /// /// ARGB representation of this color in specified viewing conditions. @@ -333,7 +294,7 @@ internal int Viewed(ViewingConditions viewingConditions) return ColorUtils.ArgbFromXyz(xyz[0], xyz[1], xyz[2]); } - internal double[] XyzInViewingConditions(ViewingConditions viewingConditions, double[] returnArray) + public double[] XyzInViewingConditions(ViewingConditions viewingConditions, double[]? returnArray = null) { double alpha = (Chroma == 0.0 || J == 0.0) ? 0.0 : Chroma / Sqrt(J / 100.0); @@ -378,16 +339,14 @@ internal double[] XyzInViewingConditions(ViewingConditions viewingConditions, do double y = (rF * matrix[1][0]) + (gF * matrix[1][1]) + (bF * matrix[1][2]); double z = (rF * matrix[2][0]) + (gF * matrix[2][1]) + (bF * matrix[2][2]); - if (returnArray != null) + if (returnArray is { Length: 3 }) { returnArray[0] = x; returnArray[1] = y; returnArray[2] = z; return returnArray; } - else - { - return [x, y, z]; - } + + return [x, y, z]; } -} \ No newline at end of file +} diff --git a/src/MaterialDesign3.MaterialColorUtilities/Hct/Hct.cs b/src/MaterialDesign3.MaterialColorUtilities/Hct/Hct.cs index 9cb00e67b3..5e3a79d0c6 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/Hct/Hct.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/Hct/Hct.cs @@ -26,62 +26,35 @@ public static Hct From(double hue, double chroma, double tone) /// /// Create an HCT color from an ARGB color. /// - public static Hct FromInt(int argb) - { - return new Hct(argb); - } + public static Hct FromInt(int argb) => new(argb); - private Hct(int argb) - { - SetInternalState(argb); - } + private Hct(int argb) => SetInternalState(argb); /// /// Set the hue of this color. Chroma may decrease because chroma has a different maximum for any /// given hue and tone. /// - public void SetHue(double newHue) - { - SetInternalState(HctSolver.SolveToInt(newHue, Chroma, Tone)); - } + public void SetHue(double newHue) => SetInternalState(HctSolver.SolveToInt(newHue, Chroma, Tone)); /// /// Set the chroma of this color. Chroma may decrease because chroma has a different maximum for /// any given hue and tone. /// - public void SetChroma(double newChroma) - { - SetInternalState(HctSolver.SolveToInt(Hue, newChroma, Tone)); - } + public void SetChroma(double newChroma) => SetInternalState(HctSolver.SolveToInt(Hue, newChroma, Tone)); /// /// Set the tone of this color. Chroma may decrease because chroma has a different maximum for any /// given hue and tone. /// - public void SetTone(double newTone) - { - SetInternalState(HctSolver.SolveToInt(Hue, Chroma, newTone)); - } + public void SetTone(double newTone) => SetInternalState(HctSolver.SolveToInt(Hue, Chroma, newTone)); - public override string ToString() - { - return $"HCT({(int)Round(Hue)}, {(int)Round(Chroma)}, {(int)Round(Tone)})"; - } + public override string ToString() => $"HCT({(int)Round(Hue)}, {(int)Round(Chroma)}, {(int)Round(Tone)})"; - public static bool IsBlue(double hue) - { - return hue is >= 250 and < 270; - } + public static bool IsBlue(double hue) => hue is >= 250 and < 270; - public static bool IsYellow(double hue) - { - return hue is >= 105 and < 125; - } + public static bool IsYellow(double hue) => hue is >= 105 and < 125; - public static bool IsCyan(double hue) - { - return hue is >= 170 and < 207; - } + public static bool IsCyan(double hue) => hue is >= 170 and < 207; /// /// Translate a color into different ViewingConditions. diff --git a/src/MaterialDesign3.MaterialColorUtilities/Hct/HctSolver.cs b/src/MaterialDesign3.MaterialColorUtilities/Hct/HctSolver.cs index 1663d9f92b..4835a581e3 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/Hct/HctSolver.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/Hct/HctSolver.cs @@ -94,10 +94,7 @@ public static class HctSolver // Below are method signatures ported from Java; implementations intentionally omitted. - internal static double SanitizeRadians(double angle) - { - return (angle + PI * 8) % (PI * 2); - } + internal static double SanitizeRadians(double angle) => (angle + PI * 8) % (PI * 2); internal static double TrueDelinearized(double rgbComponent) { @@ -144,10 +141,7 @@ internal static bool AreInCyclicOrder(double a, double b, double c) /// /// Solves the lerp equation: returns t such that lerp(source, target, t) = mid /// - internal static double Intercept(double source, double mid, double target) - { - return (mid - source) / (target - source); - } + internal static double Intercept(double source, double mid, double target) => (mid - source) / (target - source); internal static double[] LerpPoint(double[] source, double t, double[] target) { @@ -167,10 +161,7 @@ internal static double[] SetCoordinate(double[] source, double coordinate, doubl return LerpPoint(source, t, target); } - internal static bool IsBounded(double x) - { - return 0.0 <= x && x <= 100.0; - } + internal static bool IsBounded(double x) => 0.0 <= x && x <= 100.0; /// /// Returns the nth possible vertex of the polygonal intersection of the Y plane and RGB cube. @@ -272,20 +263,11 @@ internal static double[][] BisectToSegment(double y, double targetHue) return new double[][] { left, right }; } - internal static double[] Midpoint(double[] a, double[] b) - { - return [(a[0] + b[0]) / 2.0, (a[1] + b[1]) / 2.0, (a[2] + b[2]) / 2.0]; - } + internal static double[] Midpoint(double[] a, double[] b) => [(a[0] + b[0]) / 2.0, (a[1] + b[1]) / 2.0, (a[2] + b[2]) / 2.0]; - internal static int CriticalPlaneBelow(double x) - { - return (int)Floor(x - 0.5); - } + internal static int CriticalPlaneBelow(double x) => (int)Floor(x - 0.5); - internal static int CriticalPlaneAbove(double x) - { - return (int)Ceiling(x - 0.5); - } + internal static int CriticalPlaneAbove(double x) => (int)Ceiling(x - 0.5); /// /// Finds a color with the given Y and hue on the boundary of the cube. @@ -433,8 +415,5 @@ public static int SolveToInt(double hueDegrees, double chroma, double lstar) /// /// Finds an sRGB color with the given hue, chroma, and L*, if possible, returning CAM16. /// - public static Cam16 SolveToCam(double hueDegrees, double chroma, double lstar) - { - return Cam16.FromInt(SolveToInt(hueDegrees, chroma, lstar)); - } + public static Cam16 SolveToCam(double hueDegrees, double chroma, double lstar) => Cam16.FromInt(SolveToInt(hueDegrees, chroma, lstar)); } \ No newline at end of file diff --git a/src/MaterialDesign3.MaterialColorUtilities/MaterialColorUtilities.csproj b/src/MaterialDesign3.MaterialColorUtilities/MaterialColorUtilities.csproj index 7325ddfa26..58dfcd4bf6 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/MaterialColorUtilities.csproj +++ b/src/MaterialDesign3.MaterialColorUtilities/MaterialColorUtilities.csproj @@ -7,6 +7,8 @@ disable MaterialColorUtilities enable + false + true true 1.0.1 $([System.Text.RegularExpressions.Regex]::Replace("$(MDIXColorsVersion)", "-ci\d+$", "")) diff --git a/src/MaterialDesign3.MaterialColorUtilities/Palettes/CorePalette.cs b/src/MaterialDesign3.MaterialColorUtilities/Palettes/CorePalette.cs index 679ffb6762..65e4e02ce6 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/Palettes/CorePalette.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/Palettes/CorePalette.cs @@ -19,19 +19,13 @@ public sealed class CorePalette /// Create key palettes from a color. /// [Obsolete("Use DynamicScheme for color scheme generation. Use CorePalettes for core palettes container class.")] - public static CorePalette Of(int argb) - { - return new CorePalette(argb, false); - } + public static CorePalette Of(int argb) => new(argb, false); /// /// Create content key palettes from a color. /// [Obsolete("Use DynamicScheme for color scheme generation. Use CorePalettes for core palettes container class.")] - public static CorePalette ContentOf(int argb) - { - return new CorePalette(argb, true); - } + public static CorePalette ContentOf(int argb) => new(argb, true); private CorePalette(int argb, bool isContent) { diff --git a/src/MaterialDesign3.MaterialColorUtilities/Palettes/TonalPalette.cs b/src/MaterialDesign3.MaterialColorUtilities/Palettes/TonalPalette.cs index af99f74eac..f46d6f78e3 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/Palettes/TonalPalette.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/Palettes/TonalPalette.cs @@ -16,18 +16,12 @@ public sealed class TonalPalette /// /// Create tones using the HCT hue and chroma from a color. /// - public static TonalPalette FromInt(int argb) - { - return FromHct(Hct.FromInt(argb)); - } + public static TonalPalette FromInt(int argb) => FromHct(Hct.FromInt(argb)); /// /// Create tones using a HCT color. /// - public static TonalPalette FromHct(Hct hct) - { - return new TonalPalette(hct.Hue, hct.Chroma, hct); - } + public static TonalPalette FromHct(Hct hct) => new(hct.Hue, hct.Chroma, hct); /// /// Create tones from a defined HCT hue and chroma. @@ -70,10 +64,7 @@ public int Tone(int tone) /// /// Given a tone, use hue and chroma of palette to create a color, and return it as HCT. /// - public Hct GetHct(double tone) - { - return Hct.From(_hue, _chroma, tone); - } + public Hct GetHct(double tone) => Hct.From(_hue, _chroma, tone); /// The chroma of the Tonal Palette, in HCT. public double GetChroma() => _chroma; diff --git a/src/MaterialDesign3.MaterialColorUtilities/Quantize/PointProviderLab.cs b/src/MaterialDesign3.MaterialColorUtilities/Quantize/PointProviderLab.cs index fbec122262..3834ac5aa0 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/Quantize/PointProviderLab.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/Quantize/PointProviderLab.cs @@ -22,12 +22,9 @@ public double[] FromInt(int argb) /// /// /// - public int ToInt(double[] lab) - { - return ColorUtils.ArgbFromLab(lab[0], lab[1], lab[2]); - } + public int ToInt(double[] lab) => ColorUtils.ArgbFromLab(lab[0], lab[1], lab[2]); - /// + /// /// Standard CIE 1976 delta E formula also takes the square root, unneeded here. This method is /// used by quantization algorithms to compare distance, and the relative ordering is the same, /// with or without a square root. diff --git a/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerWu.cs b/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerWu.cs index 6440461b63..7540a64f1c 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerWu.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/Quantize/QuantizerWu.cs @@ -29,10 +29,7 @@ public QuantizerResult Quantize(int[] pixels, int colorCount) return new QuantizerResult(resultMap); } - private static int GetIndex(int r, int g, int b) - { - return (r << (INDEX_BITS * 2)) + (r << (INDEX_BITS + 1)) + r + (g << INDEX_BITS) + g + b; - } + private static int GetIndex(int r, int g, int b) => (r << (INDEX_BITS * 2)) + (r << (INDEX_BITS + 1)) + r + (g << INDEX_BITS) + g + b; private void ConstructHistogram(Dictionary pixels) { diff --git a/src/MaterialDesign3.MaterialColorUtilities/Temperature/TemperatureCache.cs b/src/MaterialDesign3.MaterialColorUtilities/Temperature/TemperatureCache.cs index ceb1d74b4e..98c302a9e5 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/Temperature/TemperatureCache.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/Temperature/TemperatureCache.cs @@ -18,10 +18,7 @@ public sealed class TemperatureCache /// Create a cache that allows calculation of complementary and analogous colors. /// Any returned colors will have the same tone and chroma as the input (subject to gamut limits). /// - public TemperatureCache(Hct input) - { - this.input = input; - } + public TemperatureCache(Hct input) => this.input = input; /// /// A color that complements the input color aesthetically. @@ -70,10 +67,7 @@ public Hct GetComplement() /// /// 5 colors that pair well with the input color (equidistant in temperature and adjacent in hue). /// - public List GetAnalogousColors() - { - return GetAnalogousColors(5, 12); - } + public List GetAnalogousColors() => GetAnalogousColors(5, 12); /// /// A set of colors with differing hues, equidistant in temperature. @@ -205,10 +199,7 @@ public static double RawTemperature(Hct color) /// /// Coldest color with same chroma and tone as input. /// - private Hct GetColdest() - { - return GetHctsByTemp()[0]; - } + private Hct GetColdest() => GetHctsByTemp()[0]; /// /// HCTs for all colors with the same chroma/tone as the input, sorted by hue index (0..360). diff --git a/src/MaterialDesign3.MaterialColorUtilities/Utils/ColorUtils.cs b/src/MaterialDesign3.MaterialColorUtilities/Utils/ColorUtils.cs index abf70a20e6..807f36961f 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/Utils/ColorUtils.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/Utils/ColorUtils.cs @@ -24,10 +24,7 @@ public static class ColorUtils /// /// Converts a color from RGB components to ARGB format. /// - public static int ArgbFromRgb(int red, int green, int blue) - { - return (255 << 24) | ((red & 255) << 16) | ((green & 255) << 8) | (blue & 255); - } + public static int ArgbFromRgb(int red, int green, int blue) => (255 << 24) | ((red & 255) << 16) | ((green & 255) << 8) | (blue & 255); /// /// Converts a color from linear RGB components to ARGB format. @@ -43,42 +40,27 @@ public static int ArgbFromLinrgb(double[] linrgb) /// /// Returns the alpha component of a color in ARGB format. /// - public static int AlphaFromArgb(int argb) - { - return (argb >> 24) & 255; - } + public static int AlphaFromArgb(int argb) => (argb >> 24) & 255; /// /// Returns the red component of a color in ARGB format. /// - public static int RedFromArgb(int argb) - { - return (argb >> 16) & 255; - } + public static int RedFromArgb(int argb) => (argb >> 16) & 255; /// /// Returns the green component of a color in ARGB format. /// - public static int GreenFromArgb(int argb) - { - return (argb >> 8) & 255; - } + public static int GreenFromArgb(int argb) => (argb >> 8) & 255; /// /// Returns the blue component of a color in ARGB format. /// - public static int BlueFromArgb(int argb) - { - return argb & 255; - } + public static int BlueFromArgb(int argb) => argb & 255; /// /// Returns whether a color in ARGB format is opaque. /// - public static bool IsOpaque(int argb) - { - return AlphaFromArgb(argb) >= 255; - } + public static bool IsOpaque(int argb) => AlphaFromArgb(argb) >= 255; /// /// Converts a color from XYZ to ARGB. @@ -169,18 +151,12 @@ public static double LstarFromArgb(int argb) /// /// Converts an L* value to a Y value. /// - public static double YFromLstar(double lstar) - { - return 100.0 * LabInvf((lstar + 16.0) / 116.0); - } + public static double YFromLstar(double lstar) => 100.0 * LabInvf((lstar + 16.0) / 116.0); /// /// Converts a Y value to an L* value. /// - public static double LstarFromY(double y) - { - return LabF(y / 100.0) * 116.0 - 16.0; - } + public static double LstarFromY(double y) => LabF(y / 100.0) * 116.0 - 16.0; /// /// Linearizes an RGB component. @@ -217,10 +193,7 @@ public static int Delinearized(double rgbComponent) /// /// Returns the standard white point; white on a sunny day. /// - public static double[] WhitePointD65() - { - return WHITE_POINT_D65; - } + public static double[] WhitePointD65() => WHITE_POINT_D65; internal static double LabF(double t) { @@ -246,4 +219,4 @@ internal static double LabInvf(double ft) return (116.0 * ft - 16.0) / kappa; } -} \ No newline at end of file +} diff --git a/src/MaterialDesign3.MaterialColorUtilities/Utils/MathUtils.cs b/src/MaterialDesign3.MaterialColorUtilities/Utils/MathUtils.cs index 6152374348..08a4d398c0 100644 --- a/src/MaterialDesign3.MaterialColorUtilities/Utils/MathUtils.cs +++ b/src/MaterialDesign3.MaterialColorUtilities/Utils/MathUtils.cs @@ -18,10 +18,7 @@ public static int Signum(double num) /// /// Linear interpolation between start and stop by amount. /// - public static double Lerp(double start, double stop, double amount) - { - return (1.0 - amount) * start + amount * stop; - } + public static double Lerp(double start, double stop, double amount) => (1.0 - amount) * start + amount * stop; /// /// Clamp an int between min and max (inclusive). @@ -75,10 +72,7 @@ public static double RotationDirection(double from, double to) /// /// Shortest arc distance between two angles in degrees. /// - public static double DifferenceDegrees(double a, double b) - { - return 180.0 - Math.Abs(Math.Abs(a - b) - 180.0); - } + public static double DifferenceDegrees(double a, double b) => 180.0 - Math.Abs(Math.Abs(a - b) - 180.0); /// /// Multiply a 1x3 row vector by a 3x3 matrix. @@ -144,8 +138,8 @@ public static double Log1p(double x) /// /// Cube root that supports negative inputs. /// - public static double Cbrt(double x) - { - return x < 0 ? -Math.Pow(-x, 1.0 / 3.0) : Math.Pow(x, 1.0 / 3.0); - } -} \ No newline at end of file + public static double Cbrt(double x) => x < 0 ? -Math.Pow(-x, 1.0 / 3.0) : Math.Pow(x, 1.0 / 3.0); + + public static double Clamp(double min, double max, double value) + => value < min ? min : (value > max ? max : value); +} diff --git a/tests/MaterialColorUtilities.Tests/BlendTests.cs b/tests/MaterialColorUtilities.Tests/BlendTests.cs new file mode 100644 index 0000000000..db93d55f19 --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/BlendTests.cs @@ -0,0 +1,43 @@ +namespace MaterialColorUtilities.Tests; + +public sealed class BlendTests +{ + // Same ARGB constants as in the Dart tests (note the unchecked casts for >0x7FFFFFFF). + private const int Red = unchecked((int)0xFFFF0000); + private const int Blue = unchecked((int)0xFF0000FF); + private const int Green = unchecked((int)0xFF00FF00); + private const int Yellow = unchecked((int)0xFFFFFF00); + + [Test] + [DisplayName("Blend.Harmonize matches MaterialColorUtilities vectors")] + [Arguments(Red, Blue, unchecked((int)0xFFFB0057))] // redToBlue + [Arguments(Red, Green, unchecked((int)0xFFD85600))] // redToGreen + [Arguments(Red, Yellow, unchecked((int)0xFFD85600))] // redToYellow + [Arguments(Blue, Green, unchecked((int)0xFF0047A3))] // blueToGreen + [Arguments(Blue, Red, unchecked((int)0xFF5700DC))] // blueToRed + [Arguments(Blue, Yellow, unchecked((int)0xFF0047A3))] // blueToYellow + [Arguments(Green, Blue, unchecked((int)0xFF00FC94))] // greenToBlue + [Arguments(Green, Red, unchecked((int)0xFFB1F000))] // greenToRed + [Arguments(Green, Yellow, unchecked((int)0xFFB1F000))] // greenToYellow + [Arguments(Yellow,Blue, unchecked((int)0xFFEBFFBA))] // yellowToBlue + [Arguments(Yellow,Green, unchecked((int)0xFFEBFFBA))] // yellowToGreen + [Arguments(Yellow,Red, unchecked((int)0xFFFFF6E3))] // yellowToRed + public async Task Harmonize_Matches_MaterialColorUtilities_Vectors(int designColor, int sourceColor, int expectedArgb) + { + // act + var actual = Blend.Harmonize(designColor, sourceColor); + + // assert (TUnit uses async fluent assertions) + await Assert.That(actual).IsEqualTo(expectedArgb); + } + + [Test] + [DisplayName("Blend.HctHue blends hue correctly")] + [Arguments(Red, Blue, 0.5, unchecked((int)0xffe700c9))] + [Arguments(Green, Yellow, 1.0, unchecked((int)0xffe3e300))] + public async Task HctHue_BlendsCorrectly(int from, int to, double amount, int expectedArgb) + { + var actual = Blend.HctHue(from, to, amount); + await Assert.That(actual).IsEqualTo(expectedArgb); + } +} diff --git a/tests/MaterialColorUtilities.Tests/ColorUtilsTests.cs b/tests/MaterialColorUtilities.Tests/ColorUtilsTests.cs new file mode 100644 index 0000000000..b4e07e43b3 --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/ColorUtilsTests.cs @@ -0,0 +1,267 @@ +namespace MaterialColorUtilities.Tests; + +public sealed class ColorUtilsTests +{ + private static IEnumerable Range(double start, double stop, int caseCount) + { + if (caseCount <= 1) + { + yield return start; + yield break; + } + + var stepSize = (stop - start) / (caseCount - 1); + for (var i = 0; i < caseCount; i++) + { + yield return start + stepSize * i; + } + } + + private static IReadOnlyList RgbRange() => Range(0.0, 255.0, 8).Select(d => (int)Math.Round(d)).ToArray(); + + private static IReadOnlyList FullRgbRange() => Enumerable.Range(0, 256).ToArray(); + + [Test] + [DisplayName("range_integrity")] + public async Task Range_Integrity() + { + // Dart: final range = _range(3.0, 9999.0, 1234); + var range = Range(3.0, 9999.0, 1234).ToArray(); + + // Dart: expect(range[i], closeTo(3 + 8.1070559611 * i, 1e-5)); + for (var i = 0; i < 1234; i++) + { + var expected = 3 + 8.1070559611 * i; + await Assert.That(range[i]).IsEqualTo(expected).Within(1e-5); + } + } + + [Test] + [DisplayName("argbFromRgb returns correct values")] + public async Task ArgbFromRgb_KnownVectors() + { + // black + await Assert.That(ColorUtils.ArgbFromRgb(0, 0, 0)).IsEqualTo(unchecked((int)0xFF000000)); + await Assert.That(ColorUtils.ArgbFromRgb(0, 0, 0)).IsEqualTo(unchecked((int)4278190080)); + + // white + await Assert.That(ColorUtils.ArgbFromRgb(255, 255, 255)).IsEqualTo(unchecked((int)0xFFFFFFFF)); + await Assert.That(ColorUtils.ArgbFromRgb(255, 255, 255)).IsEqualTo(unchecked((int)4294967295)); + + // random color + await Assert.That(ColorUtils.ArgbFromRgb(50, 150, 250)).IsEqualTo(unchecked((int)0xFF3296FA)); + await Assert.That(ColorUtils.ArgbFromRgb(50, 150, 250)).IsEqualTo(unchecked((int)4281505530)); + } + + [Test] + [DisplayName("y_to_lstar_to_y")] + public async Task Y_To_Lstar_To_Y_RoundTrip() + { + foreach (var y in Range(0, 100, 1001)) + { + var l = ColorUtils.LstarFromY(y); + var y2 = ColorUtils.YFromLstar(l); + await Assert.That(y2).IsEqualTo(y).Within(1e-5); + } + } + + [Test] + [DisplayName("lstar_to_y_to_lstar")] + public async Task Lstar_To_Y_To_Lstar_RoundTrip() + { + foreach (var lstar in Range(0, 100, 1001)) + { + var y = ColorUtils.YFromLstar(lstar); + var l2 = ColorUtils.LstarFromY(y); + await Assert.That(l2).IsEqualTo(lstar).Within(1e-5); + } + } + + [Test] + [DisplayName("yFromLstar numeric vectors")] + public async Task YFromLstar_Vectors() + { + async Task Check(double lstar, double expected) => + await Assert.That(ColorUtils.YFromLstar(lstar)).IsEqualTo(expected).Within(1e-5); + + await Check(0.0, 0.0); + await Check(0.1, 0.0110705); + await Check(0.2, 0.0221411); + await Check(0.3, 0.0332116); + await Check(0.4, 0.0442822); + await Check(0.5, 0.0553528); + await Check(1.0, 0.1107056); + await Check(2.0, 0.2214112); + await Check(3.0, 0.3321169); + await Check(4.0, 0.4428225); + await Check(5.0, 0.5535282); + await Check(8.0, 0.8856451); + await Check(10.0, 1.1260199); + await Check(15.0, 1.9085832); + await Check(20.0, 2.9890524); + await Check(25.0, 4.4154767); + await Check(30.0, 6.2359055); + await Check(40.0, 11.2509737); + await Check(50.0, 18.4186518); + await Check(60.0, 28.1233342); + await Check(70.0, 40.7494157); + await Check(80.0, 56.6812907); + await Check(90.0, 76.3033539); + await Check(95.0, 87.6183294); + await Check(99.0, 97.4360239); + await Check(100.0, 100.0); + } + + [Test] + [DisplayName("lstarFromY numeric vectors")] + public async Task LstarFromY_Vectors() + { + async Task Check(double y, double expected) => + await Assert.That(ColorUtils.LstarFromY(y)).IsEqualTo(expected).Within(1e-5); + + await Check(0.0, 0.0); + await Check(0.1, 0.9032962); + await Check(0.2, 1.8065925); + await Check(0.3, 2.7098888); + await Check(0.4, 3.6131851); + await Check(0.5, 4.5164814); + await Check(0.8856451, 8.0); + await Check(1.0, 8.9914424); + await Check(2.0, 15.4872443); + await Check(3.0, 20.0438970); + await Check(4.0, 23.6714419); + await Check(5.0, 26.7347653); + await Check(10.0, 37.8424304); + await Check(15.0, 45.6341970); + await Check(20.0, 51.8372115); + await Check(25.0, 57.0754208); + await Check(30.0, 61.6542222); + await Check(40.0, 69.4695307); + await Check(50.0, 76.0692610); + await Check(60.0, 81.8381891); + await Check(70.0, 86.9968642); + await Check(80.0, 91.6848609); + await Check(90.0, 95.9967686); + await Check(95.0, 98.0335184); + await Check(99.0, 99.6120372); + await Check(100.0, 100.0); + } + + [Test] + [DisplayName("y continuity at l* = 8")] + public async Task Y_Continuity() + { + const double epsilon = 1e-6; + const double delta = 1e-8; + var left = 8.0 - delta; + var mid = 8.0; + var right = 8.0 + delta; + + await Assert.That(ColorUtils.YFromLstar(left)) + .IsEqualTo(ColorUtils.YFromLstar(mid)).Within(epsilon); + + await Assert.That(ColorUtils.YFromLstar(right)) + .IsEqualTo(ColorUtils.YFromLstar(mid)).Within(epsilon); + } + + [Test] + [DisplayName("rgb -> xyz -> rgb roundtrip (approx)")] + public async Task Rgb_To_Xyz_To_Rgb_Roundtrip() + { + var range = RgbRange(); + foreach (var r in range) + foreach (var g in range) + foreach (var b in range) + { + var argb = ColorUtils.ArgbFromRgb(r, g, b); + var xyz = ColorUtils.XyzFromArgb(argb); + var converted = ColorUtils.ArgbFromXyz(xyz[0], xyz[1], xyz[2]); + + await Assert.That((double)ColorUtils.RedFromArgb(converted)) + .IsEqualTo(r).Within(1.5); + await Assert.That((double)ColorUtils.GreenFromArgb(converted)) + .IsEqualTo(g).Within(1.5); + await Assert.That((double)ColorUtils.BlueFromArgb(converted)) + .IsEqualTo(b).Within(1.5); + } + } + + [Test] + [DisplayName("rgb -> lab -> rgb roundtrip (approx)")] + public async Task Rgb_To_Lab_To_Rgb_Roundtrip() + { + var range = RgbRange(); + foreach (var r in range) + foreach (var g in range) + foreach (var b in range) + { + var argb = ColorUtils.ArgbFromRgb(r, g, b); + var lab = ColorUtils.LabFromArgb(argb); + var converted = ColorUtils.ArgbFromLab(lab[0], lab[1], lab[2]); + + await Assert.That((double)ColorUtils.RedFromArgb(converted)) + .IsEqualTo(r).Within(1.5); + await Assert.That((double)ColorUtils.GreenFromArgb(converted)) + .IsEqualTo(g).Within(1.5); + await Assert.That((double)ColorUtils.BlueFromArgb(converted)) + .IsEqualTo(b).Within(1.5); + } + } + + [Test] + [DisplayName("rgb -> l* -> rgb (exact, via argbFromLstar)")] + public async Task Rgb_To_Lstar_To_Rgb() + { + foreach (var component in FullRgbRange()) + { + var argb = ColorUtils.ArgbFromRgb(component, component, component); + var lstar = ColorUtils.LstarFromArgb(argb); + var converted = ColorUtils.ArgbFromLstar(lstar); + await Assert.That(converted).IsEqualTo(argb); + } + } + + [Test] + [DisplayName("rgb -> l* -> y commutes with Y from XYZ")] + public async Task Rgb_To_Lstar_To_Y_Commutes() + { + var range = RgbRange(); + foreach (var r in range) + foreach (var g in range) + foreach (var b in range) + { + var argb = ColorUtils.ArgbFromRgb(r, g, b); + var lstar = ColorUtils.LstarFromArgb(argb); + var y1 = ColorUtils.YFromLstar(lstar); + var y2 = ColorUtils.XyzFromArgb(argb)[1]; + + await Assert.That(y1).IsEqualTo(y2).Within(1e-5); + } + } + + [Test] + [DisplayName("l* -> rgb -> y commutes (looser tol)")] + public async Task Lstar_To_Rgb_To_Y_Commutes() + { + foreach (var lstar in Range(0, 100, 1001)) + { + var argb = ColorUtils.ArgbFromLstar(lstar); + var yFromRgb = ColorUtils.XyzFromArgb(argb)[1]; + var yFromL = ColorUtils.YFromLstar(lstar); + + await Assert.That(yFromRgb).IsEqualTo(yFromL).Within(1.0); + } + } + + [Test] + [DisplayName("linearize -> delinearize is identity on 0..255")] + public async Task Linearize_Delinearize_RoundTrip() + { + foreach (var c in FullRgbRange()) + { + var lin = ColorUtils.Linearized(c); + var converted = ColorUtils.Delinearized(lin); + await Assert.That(converted).IsEqualTo(c); + } + } +} diff --git a/tests/MaterialColorUtilities.Tests/ContrastConstraintTests.cs b/tests/MaterialColorUtilities.Tests/ContrastConstraintTests.cs new file mode 100644 index 0000000000..5205541b97 --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/ContrastConstraintTests.cs @@ -0,0 +1,354 @@ +namespace MaterialColorUtilities.Tests; + +public sealed class SchemeCorrectnessTests +{ +private static readonly double ContrastTolerance = 0.05; + private static readonly double DeltaTolerance = 0.5; + + private static readonly int[] SeedArgb = + { + unchecked((int)0xFF0000FF), // blue + unchecked((int)0xFF00FF00), // green + unchecked((int)0xFFFFFF00), // yellow + unchecked((int)0xFFFF0000), // red + }; + + private static readonly double[] ContrastLevels = { -1.0, 0.0, 0.5, 1.0 }; + + private readonly MaterialDynamicColors _mdc = new(); + + // ---- Constraint helpers (ported) ---- + + private interface IConstraint + { + void TestAgainst(DynamicScheme scheme); + } + + private sealed class ContrastConstraint : IConstraint + { + private readonly DynamicColor _foreground; + private readonly DynamicColor _background; + private readonly string _foregroundName; + private readonly string _backgroundName; + private readonly ContrastCurve _curve; + + public ContrastConstraint(DynamicColor foreground, string foregroundName, + DynamicColor background, string backgroundName, + ContrastCurve curve) + { + _foreground = foreground; + _background = background; + _foregroundName = foregroundName; + _backgroundName = backgroundName; + _curve = curve; + } + + public void TestAgainst(DynamicScheme scheme) + { + var fgTone = _foreground.GetHct(scheme).Tone; + var bgTone = _background.GetHct(scheme).Tone; + var actual = Contrast.RatioOfTones(fgTone, bgTone); + var desired = _curve.Get(scheme.ContrastLevel); + + // If desired <= 4.5, actual must be >= desired - tol. + if (desired <= 4.5) + { + if (actual < desired - ContrastTolerance) + { + Assert.Fail(FormatMessage(scheme, desired, actual)); + } + } + else + { + // Always must be >= 4.5 - tol + if (actual < 4.5 - ContrastTolerance) + { + Assert.Fail(FormatMessage(scheme, 4.5, actual)); + } + // If still under desired (with tol) and not clamped by tone 0/100, fail. + else if (actual < desired - ContrastTolerance && + fgTone != 100.0 && fgTone != 0.0) + { + Assert.Fail( + FormatMessage(scheme, desired, actual) + + " (and no color has tone 0 or 100)"); + } + } + } + + private string FormatMessage(DynamicScheme scheme, double desired, double actual) + => $"Dynamic scheme {scheme} fails contrast constraint:\n" + + $"{_foregroundName} should have contrast at least {desired} " + + $"against {_backgroundName}, but has {actual}\n"; + } + + private sealed class DeltaConstraint : IConstraint + { + private readonly DynamicColor _a; + private readonly DynamicColor _b; + private readonly string _aName; + private readonly string _bName; + private readonly double _delta; + private readonly TonePolarity _polarity; + + public DeltaConstraint(DynamicColor a, string aName, + DynamicColor b, string bName, + double delta, TonePolarity polarity) + { + _a = a; _aName = aName; _b = b; _bName = bName; + _delta = delta; _polarity = polarity; + } + + public void TestAgainst(DynamicScheme scheme) + { + var aTone = _a.GetHct(scheme).Tone; + var bTone = _b.GetHct(scheme).Tone; + + var aShouldBeLighter = + (_polarity == TonePolarity.Lighter) || + (_polarity == TonePolarity.Nearer && !scheme.IsDark) || + (_polarity == TonePolarity.Farther && scheme.IsDark); + + var actual = aShouldBeLighter ? (aTone - bTone) : (bTone - aTone); + if (actual < _delta - DeltaTolerance) + { + var lighterOrDarker = aShouldBeLighter ? "lighter" : "darker"; + Assert.Fail( + $"Dynamic scheme {scheme} fails delta constraint:\n" + + $"{_aName} should be {_delta} {lighterOrDarker} than {_bName}, " + + $"but tones are {aTone} and {bTone} (Δ={actual})\n"); + } + } + } + + private sealed class BackgroundConstraint : IConstraint + { + private readonly DynamicColor _background; + private readonly string _name; + + public BackgroundConstraint(DynamicColor background, string name) + { + _background = background; _name = name; + } + + public void TestAgainst(DynamicScheme scheme) + { + var tone = _background.GetHct(scheme).Tone; + if (tone >= 50.5 && tone < 59.5) + { + Assert.Fail( + $"Dynamic scheme {scheme} fails background constraint:\n" + + $"{_name} has tone {tone} in forbidden zone 50.5 <= tone < 59.5\n"); + } + } + } + + private List BuildConstraints() + { + // Convenience local to name roles + DynamicColor DC(string name) => name switch + { + "background" => _mdc.Background, + "on_surface" => _mdc.OnSurface, + "surface_dim" => _mdc.SurfaceDim, + "surface_bright" => _mdc.SurfaceBright, + "primary" => _mdc.Primary, + "secondary" => _mdc.Secondary, + "tertiary" => _mdc.Tertiary, + "error" => _mdc.Error, + "on_surface_variant" => _mdc.OnSurfaceVariant, + "outline" => _mdc.Outline, + "primary_container" => _mdc.PrimaryContainer, + "primary_fixed" => _mdc.PrimaryFixed, + "primary_fixed_dim" => _mdc.PrimaryFixedDim, + "secondary_container" => _mdc.SecondaryContainer, + "secondary_fixed" => _mdc.SecondaryFixed, + "secondary_fixed_dim" => _mdc.SecondaryFixedDim, + "tertiary_container" => _mdc.TertiaryContainer, + "tertiary_fixed" => _mdc.TertiaryFixed, + "tertiary_fixed_dim" => _mdc.TertiaryFixedDim, + "error_container" => _mdc.ErrorContainer, + "outline_variant" => _mdc.OutlineVariant, + "inverse_on_surface" => _mdc.InverseOnSurface, + "inverse_surface" => _mdc.InverseSurface, + "inverse_primary" => _mdc.InversePrimary, + "on_primary" => _mdc.OnPrimary, + "on_secondary" => _mdc.OnSecondary, + "on_tertiary" => _mdc.OnTertiary, + "on_error" => _mdc.OnError, + "on_primary_container" => _mdc.OnPrimaryContainer, + "on_secondary_container" => _mdc.OnSecondaryContainer, + "on_tertiary_container" => _mdc.OnTertiaryContainer, + "on_error_container" => _mdc.OnErrorContainer, + "on_primary_fixed" => _mdc.OnPrimaryFixed, + "on_secondary_fixed" => _mdc.OnSecondaryFixed, + "on_tertiary_fixed" => _mdc.OnTertiaryFixed, + "on_primary_fixed_variant" => _mdc.OnPrimaryFixedVariant, + "on_secondary_fixed_variant" => _mdc.OnSecondaryFixedVariant, + "on_tertiary_fixed_variant" => _mdc.OnTertiaryFixedVariant, + // Surfaces / background family + "on_background" => _mdc.OnBackground, + "surface" => _mdc.Surface, + "surface_container" => _mdc.SurfaceContainer, + "surface_container_high" => _mdc.SurfaceContainerHigh, + "surface_container_highest" => _mdc.SurfaceContainerHighest, + "surface_container_low" => _mdc.SurfaceContainerLow, + "surface_container_lowest" => _mdc.SurfaceContainerLowest, + "surface_tint" => _mdc.SurfaceTint, + "surface_variant" => _mdc.SurfaceVariant, + _ => throw new ArgumentOutOfRangeException(nameof(name), name, null) + }; + + var list = new List + { + new ContrastConstraint(DC("on_surface"), "on_surface", DC("surface_dim"), "surface_dim", new ContrastCurve(4.5, 7, 11, 21)), + new ContrastConstraint(DC("on_surface"), "on_surface", DC("surface_bright"), "surface_bright", new ContrastCurve(4.5, 7, 11, 21)), + + new ContrastConstraint(DC("primary"), "primary", DC("surface_dim"), "surface_dim", new ContrastCurve(3, 4.5, 7, 7)), + new ContrastConstraint(DC("primary"), "primary", DC("surface_bright"), "surface_bright", new ContrastCurve(3, 4.5, 7, 7)), + + new ContrastConstraint(DC("secondary"), "secondary", DC("surface_dim"), "surface_dim", new ContrastCurve(3, 4.5, 7, 7)), + new ContrastConstraint(DC("secondary"), "secondary", DC("surface_bright"), "surface_bright", new ContrastCurve(3, 4.5, 7, 7)), + + new ContrastConstraint(DC("tertiary"), "tertiary", DC("surface_dim"), "surface_dim", new ContrastCurve(3, 4.5, 7, 7)), + new ContrastConstraint(DC("tertiary"), "tertiary", DC("surface_bright"), "surface_bright", new ContrastCurve(3, 4.5, 7, 7)), + + new ContrastConstraint(DC("error"), "error", DC("surface_dim"), "surface_dim", new ContrastCurve(3, 4.5, 7, 7)), + new ContrastConstraint(DC("error"), "error", DC("surface_bright"), "surface_bright", new ContrastCurve(3, 4.5, 7, 7)), + + new ContrastConstraint(DC("on_surface_variant"), "on_surface_variant", DC("surface_dim"), "surface_dim", new ContrastCurve(3, 4.5, 7, 11)), + new ContrastConstraint(DC("on_surface_variant"), "on_surface_variant", DC("surface_bright"), "surface_bright", new ContrastCurve(3, 4.5, 7, 11)), + + new ContrastConstraint(DC("outline"), "outline", DC("surface_dim"), "surface_dim", new ContrastCurve(1.5, 3, 4.5, 7)), + new ContrastConstraint(DC("outline"), "outline", DC("surface_bright"), "surface_bright", new ContrastCurve(1.5, 3, 4.5, 7)), + + new ContrastConstraint(DC("primary_container"), "primary_container", DC("surface_dim"), "surface_dim", new ContrastCurve(0, 0, 3, 4.5)), + new ContrastConstraint(DC("primary_container"), "primary_container", DC("surface_bright"), "surface_bright", new ContrastCurve(0, 0, 3, 4.5)), + + new ContrastConstraint(DC("primary_fixed"), "primary_fixed", DC("surface_dim"), "surface_dim", new ContrastCurve(0, 0, 3, 4.5)), + new ContrastConstraint(DC("primary_fixed"), "primary_fixed", DC("surface_bright"), "surface_bright", new ContrastCurve(0, 0, 3, 4.5)), + + new ContrastConstraint(DC("primary_fixed_dim"), "primary_fixed_dim", DC("surface_dim"), "surface_dim", new ContrastCurve(0, 0, 3, 4.5)), + new ContrastConstraint(DC("primary_fixed_dim"), "primary_fixed_dim", DC("surface_bright"), "surface_bright", new ContrastCurve(0, 0, 3, 4.5)), + + new ContrastConstraint(DC("secondary_container"), "secondary_container", DC("surface_dim"), "surface_dim", new ContrastCurve(0, 0, 3, 4.5)), + new ContrastConstraint(DC("secondary_container"), "secondary_container", DC("surface_bright"), "surface_bright", new ContrastCurve(0, 0, 3, 4.5)), + + new ContrastConstraint(DC("secondary_fixed"), "secondary_fixed", DC("surface_dim"), "surface_dim", new ContrastCurve(0, 0, 3, 4.5)), + new ContrastConstraint(DC("secondary_fixed"), "secondary_fixed", DC("surface_bright"), "surface_bright", new ContrastCurve(0, 0, 3, 4.5)), + + new ContrastConstraint(DC("secondary_fixed_dim"), "secondary_fixed_dim", DC("surface_dim"), "surface_dim", new ContrastCurve(0, 0, 3, 4.5)), + new ContrastConstraint(DC("secondary_fixed_dim"), "secondary_fixed_dim", DC("surface_bright"), "surface_bright", new ContrastCurve(0, 0, 3, 4.5)), + + new ContrastConstraint(DC("tertiary_container"), "tertiary_container", DC("surface_dim"), "surface_dim", new ContrastCurve(0, 0, 3, 4.5)), + new ContrastConstraint(DC("tertiary_container"), "tertiary_container", DC("surface_bright"), "surface_bright", new ContrastCurve(0, 0, 3, 4.5)), + + new ContrastConstraint(DC("tertiary_fixed"), "tertiary_fixed", DC("surface_dim"), "surface_dim", new ContrastCurve(0, 0, 3, 4.5)), + new ContrastConstraint(DC("tertiary_fixed"), "tertiary_fixed", DC("surface_bright"), "surface_bright", new ContrastCurve(0, 0, 3, 4.5)), + + new ContrastConstraint(DC("tertiary_fixed_dim"), "tertiary_fixed_dim", DC("surface_dim"), "surface_dim", new ContrastCurve(0, 0, 3, 4.5)), + new ContrastConstraint(DC("tertiary_fixed_dim"), "tertiary_fixed_dim", DC("surface_bright"), "surface_bright", new ContrastCurve(0, 0, 3, 4.5)), + + new ContrastConstraint(DC("error_container"), "error_container", DC("surface_dim"), "surface_dim", new ContrastCurve(0, 0, 3, 4.5)), + new ContrastConstraint(DC("error_container"), "error_container", DC("surface_bright"), "surface_bright", new ContrastCurve(0, 0, 3, 4.5)), + + new ContrastConstraint(DC("outline_variant"), "outline_variant", DC("surface_dim"), "surface_dim", new ContrastCurve(0, 0, 3, 4.5)), + new ContrastConstraint(DC("outline_variant"), "outline_variant", DC("surface_bright"), "surface_bright", new ContrastCurve(0, 0, 3, 4.5)), + + new ContrastConstraint(DC("inverse_on_surface"), "inverse_on_surface", DC("inverse_surface"), "inverse_surface", new ContrastCurve(4.5, 7, 11, 21)), + new ContrastConstraint(DC("inverse_primary"), "inverse_primary", DC("inverse_surface"), "inverse_surface", new ContrastCurve(3, 4.5, 7, 7)), + + new ContrastConstraint(DC("on_primary"), "on_primary", DC("primary"), "primary", new ContrastCurve(4.5, 7, 11, 21)), + new ContrastConstraint(DC("on_secondary"), "on_secondary", DC("secondary"), "secondary", new ContrastCurve(4.5, 7, 11, 21)), + new ContrastConstraint(DC("on_tertiary"), "on_tertiary", DC("tertiary"), "tertiary", new ContrastCurve(4.5, 7, 11, 21)), + new ContrastConstraint(DC("on_error"), "on_error", DC("error"), "error", new ContrastCurve(4.5, 7, 11, 21)), + + new ContrastConstraint(DC("on_primary_container"), "on_primary_container", DC("primary_container"), "primary_container", new ContrastCurve(3, 4.5, 7, 11)), + new ContrastConstraint(DC("on_secondary_container"), "on_secondary_container", DC("secondary_container"), "secondary_container", new ContrastCurve(3, 4.5, 7, 11)), + new ContrastConstraint(DC("on_tertiary_container"), "on_tertiary_container", DC("tertiary_container"), "tertiary_container", new ContrastCurve(3, 4.5, 7, 11)), + new ContrastConstraint(DC("on_error_container"), "on_error_container", DC("error_container"), "error_container", new ContrastCurve(3, 4.5, 7, 11)), + + new ContrastConstraint(DC("on_primary_fixed"), "on_primary_fixed", DC("primary_fixed"), "primary_fixed", new ContrastCurve(4.5, 7, 11, 21)), + new ContrastConstraint(DC("on_primary_fixed"), "on_primary_fixed", DC("primary_fixed_dim"), "primary_fixed_dim", new ContrastCurve(4.5, 7, 11, 21)), + new ContrastConstraint(DC("on_secondary_fixed"), "on_secondary_fixed", DC("secondary_fixed"), "secondary_fixed", new ContrastCurve(4.5, 7, 11, 21)), + new ContrastConstraint(DC("on_secondary_fixed"), "on_secondary_fixed", DC("secondary_fixed_dim"), "secondary_fixed_dim", new ContrastCurve(4.5, 7, 11, 21)), + new ContrastConstraint(DC("on_tertiary_fixed"), "on_tertiary_fixed", DC("tertiary_fixed"), "tertiary_fixed", new ContrastCurve(4.5, 7, 11, 21)), + new ContrastConstraint(DC("on_tertiary_fixed"), "on_tertiary_fixed", DC("tertiary_fixed_dim"), "tertiary_fixed_dim", new ContrastCurve(4.5, 7, 11, 21)), + + // Delta constraints + new DeltaConstraint(DC("primary"), "primary", DC("primary_container"), "primary_container", 10, TonePolarity.Farther), + new DeltaConstraint(DC("secondary"), "secondary", DC("secondary_container"), "secondary_container", 10, TonePolarity.Farther), + new DeltaConstraint(DC("tertiary"), "tertiary", DC("tertiary_container"), "tertiary_container", 10, TonePolarity.Farther), + new DeltaConstraint(DC("error"), "error", DC("error_container"), "error_container", 10, TonePolarity.Farther), + + new DeltaConstraint(DC("primary_fixed_dim"), "primary_fixed_dim", DC("primary_fixed"), "primary_fixed", 10, TonePolarity.Darker), + new DeltaConstraint(DC("secondary_fixed_dim"), "secondary_fixed_dim", DC("secondary_fixed"), "secondary_fixed", 10, TonePolarity.Darker), + new DeltaConstraint(DC("tertiary_fixed_dim"), "tertiary_fixed_dim", DC("tertiary_fixed"), "tertiary_fixed", 10, TonePolarity.Darker), + + // Background forbidden zone constraints + new BackgroundConstraint(DC("background"), "background"), + new BackgroundConstraint(DC("error"), "error"), + new BackgroundConstraint(DC("error_container"), "error_container"), + new BackgroundConstraint(DC("primary"), "primary"), + new BackgroundConstraint(DC("primary_container"), "primary_container"), + new BackgroundConstraint(DC("primary_fixed"), "primary_fixed"), + new BackgroundConstraint(DC("primary_fixed_dim"), "primary_fixed_dim"), + new BackgroundConstraint(DC("secondary"), "secondary"), + new BackgroundConstraint(DC("secondary_container"), "secondary_container"), + new BackgroundConstraint(DC("secondary_fixed"), "secondary_fixed"), + new BackgroundConstraint(DC("secondary_fixed_dim"), "secondary_fixed_dim"), + new BackgroundConstraint(DC("surface"), "surface"), + new BackgroundConstraint(DC("surface_bright"), "surface_bright"), + new BackgroundConstraint(DC("surface_container"), "surface_container"), + new BackgroundConstraint(DC("surface_container_high"), "surface_container_high"), + new BackgroundConstraint(DC("surface_container_highest"), "surface_container_highest"), + new BackgroundConstraint(DC("surface_container_low"), "surface_container_low"), + new BackgroundConstraint(DC("surface_container_lowest"), "surface_container_lowest"), + new BackgroundConstraint(DC("surface_dim"), "surface_dim"), + new BackgroundConstraint(DC("surface_tint"), "surface_tint"), + new BackgroundConstraint(DC("surface_variant"), "surface_variant"), + new BackgroundConstraint(DC("tertiary"), "tertiary"), + new BackgroundConstraint(DC("tertiary_container"), "tertiary_container"), + new BackgroundConstraint(DC("tertiary_fixed"), "tertiary_fixed"), + new BackgroundConstraint(DC("tertiary_fixed_dim"), "tertiary_fixed_dim"), + }; + + return list; + } + + // ---- Variant → Scheme constructor mapping ---- + private static DynamicScheme SchemeFromVariant(Variant variant, Hct source, bool isDark, double contrastLevel) + { + var name = variant.ToString().ToLowerInvariant(); + if (name.Contains("fidelity")) return new SchemeFidelity(source, isDark, contrastLevel); + if (name.Contains("content")) return new SchemeContent(source, isDark, contrastLevel); + if (name.Contains("monochrome")) return new SchemeMonochrome(source, isDark, contrastLevel); + if (name.Contains("tonal")) return new SchemeTonalSpot(source, isDark, contrastLevel); + // Fallback: pick a sane default + return new SchemeTonalSpot(source, isDark, contrastLevel); + } + + [Test] + [DisplayName("scheme_correctness_test: all variants & contrast levels satisfy constraints")] + public async Task Scheme_Correctness_All() + { + var constraints = BuildConstraints(); + + foreach (var variant in Enum.GetValues(typeof(Variant)).Cast()) + foreach (var contrastLevel in ContrastLevels) + foreach (var argb in SeedArgb) + foreach (var isDark in new[] { false, true }) + { + var scheme = SchemeFromVariant(variant, Hct.FromInt(argb), isDark, contrastLevel); + + // Each constraint throws Assert.Fail(...) if violated. + foreach (var c in constraints) + { + c.TestAgainst(scheme); + } + + // If we got here, constraints passed for this (variant, seed, CL, dark) tuple. + await Assert.That(true).IsTrue(); // keep async signature satisfied + } + } +} diff --git a/tests/MaterialColorUtilities.Tests/ContrastTests.cs b/tests/MaterialColorUtilities.Tests/ContrastTests.cs new file mode 100644 index 0000000000..9e99b36dd3 --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/ContrastTests.cs @@ -0,0 +1,76 @@ +namespace MaterialColorUtilities.Tests; + +public sealed class ContrastTests +{ + [Test] + [DisplayName("ratioOfTones_outOfBoundsInput")] + public async Task RatioOfTones_OutOfBounds_ReturnsMax() + { + var actual = Contrast.RatioOfTones(-10.0, 110.0); + await Assert.That(actual).IsEqualTo(21.0).Within(0.001); + } + + [Test] + [DisplayName("lighter_impossibleRatioErrors")] + public async Task Lighter_ImpossibleRatio_ReturnsError() + { + var actual = Contrast.Lighter(tone: 90.0, ratio: 10.0); + await Assert.That(actual).IsEqualTo(-1.0).Within(0.001); + } + + [Test] + [DisplayName("lighter_outOfBoundsInputAboveErrors")] + public async Task Lighter_ToneAboveBounds_ReturnsError() + { + var actual = Contrast.Lighter(tone: 110.0, ratio: 2.0); + await Assert.That(actual).IsEqualTo(-1.0).Within(0.001); + } + + [Test] + [DisplayName("lighter_outOfBoundsInputBelowErrors")] + public async Task Lighter_ToneBelowBounds_ReturnsError() + { + var actual = Contrast.Lighter(tone: -10.0, ratio: 2.0); + await Assert.That(actual).IsEqualTo(-1.0).Within(0.001); + } + + [Test] + [DisplayName("lighterUnsafe_returnsMaxTone")] + public async Task LighterUnsafe_ReturnsMaxToneOnFailure() + { + var actual = Contrast.LighterUnsafe(tone: 100.0, ratio: 2.0); + await Assert.That(actual).IsEqualTo(100.0).Within(0.001); + } + + [Test] + [DisplayName("darker_impossibleRatioErrors")] + public async Task Darker_ImpossibleRatio_ReturnsError() + { + var actual = Contrast.Darker(tone: 10.0, ratio: 20.0); + await Assert.That(actual).IsEqualTo(-1.0).Within(0.001); + } + + [Test] + [DisplayName("darker_outOfBoundsInputAboveErrors")] + public async Task Darker_ToneAboveBounds_ReturnsError() + { + var actual = Contrast.Darker(tone: 110.0, ratio: 2.0); + await Assert.That(actual).IsEqualTo(-1.0).Within(0.001); + } + + [Test] + [DisplayName("darker_outOfBoundsInputBelowErrors")] + public async Task Darker_ToneBelowBounds_ReturnsError() + { + var actual = Contrast.Darker(tone: -10.0, ratio: 2.0); + await Assert.That(actual).IsEqualTo(-1.0).Within(0.001); + } + + [Test] + [DisplayName("darkerUnsafe_returnsMinTone")] + public async Task DarkerUnsafe_ReturnsMinToneOnFailure() + { + var actual = Contrast.DarkerUnsafe(tone: 0.0, ratio: 2.0); + await Assert.That(actual).IsEqualTo(0.0).Within(0.001); + } +} diff --git a/tests/MaterialColorUtilities.Tests/DislikeAnalyzerTests.cs b/tests/MaterialColorUtilities.Tests/DislikeAnalyzerTests.cs new file mode 100644 index 0000000000..da180b36ba --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/DislikeAnalyzerTests.cs @@ -0,0 +1,86 @@ +namespace MaterialColorUtilities.Tests; + +public class DislikeAnalyzerTests +{ + [Test] + [DisplayName("Monk Skin Tone Scale colors liked")] + public async Task MonkSkinToneScale_Colors_NotDisliked() + { + // From https://skintone.google#/get-started (ported) + var monkSkinToneScaleColors = new[] + { + unchecked((int)0xFFF6EDE4), + unchecked((int)0xFFF3E7DB), + unchecked((int)0xFFF7EAD0), + unchecked((int)0xFFEADABA), + unchecked((int)0xFFD7BD96), + unchecked((int)0xFFA07E56), + unchecked((int)0xFF825C43), + unchecked((int)0xFF604134), + unchecked((int)0xFF3A312A), + unchecked((int)0xFF292420), + }; + + foreach (var color in monkSkinToneScaleColors) + { + var hct = Hct.FromInt(color); + await Assert.That(DislikeAnalyzer.IsDisliked(hct)).IsFalse(); + } + } + + [Test] + [DisplayName("bile colors disliked")] + public async Task Bile_Colors_AreDisliked() + { + var unlikable = new[] + { + unchecked((int)0xFF95884B), + unchecked((int)0xFF716B40), + unchecked((int)0xFFB08E00), + unchecked((int)0xFF4C4308), + unchecked((int)0xFF464521), + }; + + foreach (var color in unlikable) + { + var hct = Hct.FromInt(color); + await Assert.That(DislikeAnalyzer.IsDisliked(hct)).IsTrue(); + } + } + + [Test] + [DisplayName("bile colors became likable after fix")] + public async Task Bile_Colors_BecomeLikable_AfterFix() + { + var unlikable = new[] + { + unchecked((int)0xFF95884B), + unchecked((int)0xFF716B40), + unchecked((int)0xFFB08E00), + unchecked((int)0xFF4C4308), + unchecked((int)0xFF464521), + }; + + foreach (var color in unlikable) + { + var hct = Hct.FromInt(color); + await Assert.That(DislikeAnalyzer.IsDisliked(hct)).IsTrue(); + + var likable = DislikeAnalyzer.FixIfDisliked(hct); + await Assert.That(DislikeAnalyzer.IsDisliked(likable)).IsFalse(); + } + } + + [Test] + [DisplayName("tone 67 not disliked and remains unchanged by fix")] + public async Task Tone67_NotDisliked_And_Unchanged() + { + var color = Hct.From(100.0, 50.0, 67.0); + + await Assert.That(DislikeAnalyzer.IsDisliked(color)).IsFalse(); + + var fixedColor = DislikeAnalyzer.FixIfDisliked(color); + // In the C# implementation, Hct exposes ARGB via `.Argb` + await Assert.That(fixedColor.Argb).IsEqualTo(color.Argb); + } +} diff --git a/tests/MaterialColorUtilities.Tests/DynamicSchemeTests.cs b/tests/MaterialColorUtilities.Tests/DynamicSchemeTests.cs new file mode 100644 index 0000000000..abeac6397e --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/DynamicSchemeTests.cs @@ -0,0 +1,68 @@ +using System.Runtime.Serialization; + +namespace MaterialColorUtilities.Tests; + +public sealed class DynamicSchemeTests +{ + [Test] + [DisplayName("0 length input")] + public async Task ZeroLengthInput_NoRotation() + { + var hue = DynamicScheme.GetRotatedHue( + Hct.From(43, 16, 16), + [], + []); + + await Assert.That(hue).IsEqualTo(43.0).Within(1.0); + } + + [Test] + [DisplayName("1 length input no rotation")] + public async Task OneLengthInput_NoRotation() + { + var hue = DynamicScheme.GetRotatedHue( + Hct.From(43, 16, 16), + [0.0], + [0.0]); + + await Assert.That(hue).IsEqualTo(43.0).Within(1.0); + } + + [Test] + [DisplayName("input length mismatch asserts")] + public async Task InputLengthMismatch_Throws() + { + await Assert.That(() => + DynamicScheme.GetRotatedHue( + Hct.From(43, 16, 16), + [0.0, 1.0], // 2 breakpoints + [0.0] // 1 rotation + ) + ).Throws(); + } + + [Test] + [DisplayName("on boundary rotation correct")] + public async Task OnBoundary_RotationApplied() + { + var hue = DynamicScheme.GetRotatedHue( + Hct.From(43, 16, 16), + [0.0, 42.0, 360.0], + [0.0, 15.0, 0.0]); + + await Assert.That(hue).IsEqualTo(43.0 + 15.0).Within(1.0); + } + + [Test] + [DisplayName("rotation > 360 wraps")] + public async Task RotationGreaterThan360_Wraps() + { + var hue = DynamicScheme.GetRotatedHue( + Hct.From(43, 16, 16), + [0.0, 42.0, 360.0], + [0.0, 480.0, 0.0]); + + // 43 + 480 = 523 -> 163 after sanitize/wrap + await Assert.That(hue).IsEqualTo(163.0).Within(1.0); + } +} diff --git a/tests/MaterialColorUtilities.Tests/HctTests.cs b/tests/MaterialColorUtilities.Tests/HctTests.cs new file mode 100644 index 0000000000..0cd4ed5539 --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/HctTests.cs @@ -0,0 +1,291 @@ +namespace MaterialColorUtilities.Tests; + +public sealed class HctTests +{ + [Test] + [Skip("Takes a long time to run")] + [DisplayName("HCT preserves original color for all opaque ARGB values")] + public async Task Hct_Preserves_Original_Color_For_All_Opaque_ARGB() + { + // Iterate from 0xFF000000 to 0xFFFFFFFF inclusive (all opaque colors). + uint argb = 0xFF000000u; + while (true) + { + int argbInt = unchecked((int)argb); + + var hct = Hct.FromInt(argbInt); + var reconstructedArgb = Hct.From(hct.Hue, hct.Chroma, hct.Tone).Argb; + + await Assert.That(reconstructedArgb).IsEqualTo(argbInt); + + if (argb == 0xFFFFFFFFu) + break; + + argb++; + } + } + + private const int Black = unchecked((int)0xFF000000); + private const int White = unchecked((int)0xFFFFFFFF); + private const int Red = unchecked((int)0xFFFF0000); + private const int Green = unchecked((int)0xFF00FF00); + private const int Blue = unchecked((int)0xFF0000FF); + private const int MidGray = unchecked((int)0xFF777777); + + private static bool ColorIsOnBoundary(int argb) => + ColorUtils.RedFromArgb(argb) == 0 || ColorUtils.RedFromArgb(argb) == 255 || + ColorUtils.GreenFromArgb(argb) == 0 || ColorUtils.GreenFromArgb(argb) == 255 || + ColorUtils.BlueFromArgb(argb) == 0 || ColorUtils.BlueFromArgb(argb) == 255; + + [Test] + [DisplayName("Hct equality/hash basics (by ARGB)")] + public async Task Hct_Equality_Hash_Basics_ByArgb() + { + var a = Hct.FromInt(123); + var b = Hct.FromInt(123); + + // Equality by ARGB value + await Assert.That(a.Argb).IsEqualTo(b.Argb); + + // Hash by ARGB value + await Assert.That(a.Argb.GetHashCode()).IsEqualTo(b.Argb.GetHashCode()); + } + + [Test] + [DisplayName("CAM16 conversions are reflexive via viewed(sRGB)")] + public async Task Conversions_Are_Reflexive() + { + var cam = Cam16.FromInt(Red); + + // pass an empty buffer again (API requires the arg) + var xyz = cam.XyzInViewingConditions(ViewingConditions.DEFAULT); + var color = ColorUtils.ArgbFromXyz(xyz[0], xyz[1], xyz[2]); + + await Assert.That(color).IsEqualTo(Red); + } + + [Test] public async Task Y_Midgray() => await Assert.That(ColorUtils.YFromLstar(50.0)).IsEqualTo(18.418).Within(0.001); + [Test] public async Task Y_Black() => await Assert.That(ColorUtils.YFromLstar(0.0)).IsEqualTo(0.0).Within(0.001); + [Test] public async Task Y_White() => await Assert.That(ColorUtils.YFromLstar(100)).IsEqualTo(100.0).Within(0.001); + + [Test] + [DisplayName("CAM16 red metrics")] + public async Task Cam_Red() + { + var cam = Cam16.FromInt(Red); + await Assert.That(cam.GetJ()).IsEqualTo(46.445).Within(0.001); + await Assert.That(cam.GetChroma()).IsEqualTo(113.357).Within(0.001); + await Assert.That(cam.GetHue()).IsEqualTo(27.408).Within(0.001); + await Assert.That(cam.GetM()).IsEqualTo(89.494).Within(0.001); + await Assert.That(cam.GetS()).IsEqualTo(91.889).Within(0.001); + await Assert.That(cam.GetQ()).IsEqualTo(105.988).Within(0.001); + } + + [Test] + [DisplayName("CAM16 green metrics")] + public async Task Cam_Green() + { + var cam = Cam16.FromInt(Green); + await Assert.That(cam.GetJ()).IsEqualTo(79.331).Within(0.001); + await Assert.That(cam.GetChroma()).IsEqualTo(108.410).Within(0.001); + await Assert.That(cam.GetHue()).IsEqualTo(142.139).Within(0.001); + await Assert.That(cam.GetM()).IsEqualTo(85.587).Within(0.001); + await Assert.That(cam.GetS()).IsEqualTo(78.604).Within(0.001); + await Assert.That(cam.GetQ()).IsEqualTo(138.520).Within(0.001); + } + + [Test] + [DisplayName("CAM16 blue metrics")] + public async Task Cam_Blue() + { + var cam = Cam16.FromInt(Blue); + await Assert.That(cam.GetJ()).IsEqualTo(25.465).Within(0.001); + await Assert.That(cam.GetChroma()).IsEqualTo(87.230).Within(0.001); + await Assert.That(cam.GetHue()).IsEqualTo(282.788).Within(0.001); + await Assert.That(cam.GetM()).IsEqualTo(68.867).Within(0.001); + await Assert.That(cam.GetS()).IsEqualTo(93.674).Within(0.001); + await Assert.That(cam.GetQ()).IsEqualTo(78.481).Within(0.001); + } + + [Test] + [DisplayName("CAM16 black metrics")] + public async Task Cam_Black() + { + var cam = Cam16.FromInt(Black); + await Assert.That(cam.GetJ()).IsEqualTo(0.0).Within(0.001); + await Assert.That(cam.GetChroma()).IsEqualTo(0.0).Within(0.001); + await Assert.That(cam.GetHue()).IsEqualTo(0.0).Within(0.001); + await Assert.That(cam.GetM()).IsEqualTo(0.0).Within(0.001); + await Assert.That(cam.GetS()).IsEqualTo(0.0).Within(0.001); + await Assert.That(cam.GetQ()).IsEqualTo(0.0).Within(0.001); + } + + [Test] + [DisplayName("CAM16 white metrics")] + public async Task Cam_White() + { + var cam = Cam16.FromInt(White); + await Assert.That(cam.GetJ()).IsEqualTo(100.0).Within(0.001); + await Assert.That(cam.GetChroma()).IsEqualTo(2.869).Within(0.001); + await Assert.That(cam.GetHue()).IsEqualTo(209.492).Within(0.001); + await Assert.That(cam.GetM()).IsEqualTo(2.265).Within(0.001); + await Assert.That(cam.GetS()).IsEqualTo(12.068).Within(0.001); + await Assert.That(cam.GetQ()).IsEqualTo(155.521).Within(0.001); + } + + [Test] public async Task GamutMap_Red() => await AssertGamutMapIdentity(Red); + [Test] public async Task GamutMap_Green() => await AssertGamutMapIdentity(Green); + [Test] public async Task GamutMap_Blue() => await AssertGamutMapIdentity(Blue); + [Test] public async Task GamutMap_White() => await AssertGamutMapIdentity(White); + // NOTE: The Dart “midgray” test body actually used `green`; keep parity by testing `green`. + [Test] public async Task GamutMap_Midgray_ParityWithDart() => await AssertGamutMapIdentity(Green); + + private static async Task AssertGamutMapIdentity(int colorToTest) + { + var cam = Cam16.FromInt(colorToTest); + var color = Hct.From(cam.GetHue(), cam.GetChroma(), ColorUtils.LstarFromArgb(colorToTest)).Argb; + await Assert.That(color).IsEqualTo(colorToTest); + } + + [Test] + [DisplayName("HCT returns a sufficiently close color")] + public async Task Hct_Returns_Sufficiently_Close_Color() + { + for (int hue = 15; hue < 360; hue += 30) + for (int chroma = 0; chroma <= 100; chroma += 10) + for (int tone = 20; tone <= 80; tone += 10) + { + var desc = $"H{hue} C{chroma} T{tone}"; + var hct = Hct.From(hue, chroma, tone); + + if (chroma > 0) + { + await Assert.That(hct.Hue) + .IsEqualTo(hue).Within(4.0) + .Because($"Hue should be close for {desc}"); + } + + // chroma ∈ [0, chroma + 2.5] + await Assert.That(hct.Chroma).IsGreaterThanOrEqualTo(0.0) + .Because($"Chroma lower bound for {desc}"); + await Assert.That(hct.Chroma).IsLessThanOrEqualTo(chroma + 2.5) + .Because($"Chroma should be close or less for {desc}"); + + if (hct.Chroma < chroma - 2.5) + { + // Non-sRGB request should land on sRGB cube boundary + await Assert.That(ColorIsOnBoundary(hct.Argb)) + .IsTrue() + .Because($"Out-of-gamut {desc} should be on sRGB boundary, got 0x{hct.Argb:X8}"); + } + + await Assert.That(hct.Tone) + .IsEqualTo(tone).Within(0.5) + .Because($"Tone should be close for {desc}"); + } + } + + [Test] + [DisplayName("CAM16 to XYZ (without preallocated array)")] + public async Task Cam16_To_Xyz_NoArray() + { + var cam = Cam16.FromInt(Red); + + // pass an empty buffer to indicate "no preallocated array" + var xyz = cam.XyzInViewingConditions(ViewingConditions.DEFAULT); + + await Assert.That(xyz[0]).IsEqualTo(41.23).Within(0.01); + await Assert.That(xyz[1]).IsEqualTo(21.26).Within(0.01); + await Assert.That(xyz[2]).IsEqualTo(1.93 ).Within(0.01); + } + + [Test] + [DisplayName("CAM16 to XYZ (with preallocated array)")] + public async Task Cam16_To_Xyz_WithArray() + { + var cam = Cam16.FromInt(Red); + + // Provide a length-3 buffer + var buffer = new double[3]; + var xyz = cam.XyzInViewingConditions(ViewingConditions.DEFAULT, buffer); + + await Assert.That(xyz[0]).IsEqualTo(41.23).Within(0.01); + await Assert.That(xyz[1]).IsEqualTo(21.26).Within(0.01); + await Assert.That(xyz[2]).IsEqualTo(1.93 ).Within(0.01); + + // Optional: verify the implementation reused the provided array + // await Assert.That(ReferenceEquals(xyz, buffer)).IsTrue(); + } + + [Test] + [DisplayName("Color Relativity — red in black/white")] + public async Task ColorRelativity_Red() + { + var hct = Hct.FromInt(Red); + var inBlack = hct.InViewingConditions(ViewingConditions.DefaultWithBackgroundLstar(0.0)).Argb; + var inWhite = hct.InViewingConditions(ViewingConditions.DefaultWithBackgroundLstar(100.0)).Argb; + + await Assert.That(inBlack ).IsEqualTo(unchecked((int)0xFF9F5C51)); + await Assert.That(inWhite ).IsEqualTo(unchecked((int)0xFFFF5D48)); + } + + [Test] + [DisplayName("Color Relativity — green in black/white")] + public async Task ColorRelativity_Green() + { + var hct = Hct.FromInt(Green); + var inBlack = hct.InViewingConditions(ViewingConditions.DefaultWithBackgroundLstar(0.0)).Argb; + var inWhite = hct.InViewingConditions(ViewingConditions.DefaultWithBackgroundLstar(100.0)).Argb; + + await Assert.That(inBlack ).IsEqualTo(unchecked((int)0xFFACD69D)); + await Assert.That(inWhite ).IsEqualTo(unchecked((int)0xFF8EFF77)); + } + + [Test] + [DisplayName("Color Relativity — blue in black/white")] + public async Task ColorRelativity_Blue() + { + var hct = Hct.FromInt(Blue); + var inBlack = hct.InViewingConditions(ViewingConditions.DefaultWithBackgroundLstar(0.0)).Argb; + var inWhite = hct.InViewingConditions(ViewingConditions.DefaultWithBackgroundLstar(100.0)).Argb; + + await Assert.That(inBlack ).IsEqualTo(unchecked((int)0xFF343654)); + await Assert.That(inWhite ).IsEqualTo(unchecked((int)0xFF3F49FF)); + } + + [Test] + [DisplayName("Color Relativity — white in black/white")] + public async Task ColorRelativity_White() + { + var hct = Hct.FromInt(White); + var inBlack = hct.InViewingConditions(ViewingConditions.DefaultWithBackgroundLstar(0.0)).Argb; + var inWhite = hct.InViewingConditions(ViewingConditions.DefaultWithBackgroundLstar(100.0)).Argb; + + await Assert.That(inBlack ).IsEqualTo(unchecked((int)0xFFFFFFFF)); + await Assert.That(inWhite ).IsEqualTo(unchecked((int)0xFFFFFFFF)); + } + + [Test] + [DisplayName("Color Relativity — midgray in black/white")] + public async Task ColorRelativity_MidGray() + { + var hct = Hct.FromInt(MidGray); + var inBlack = hct.InViewingConditions(ViewingConditions.DefaultWithBackgroundLstar(0.0)).Argb; + var inWhite = hct.InViewingConditions(ViewingConditions.DefaultWithBackgroundLstar(100.0)).Argb; + + await Assert.That(inBlack ).IsEqualTo(unchecked((int)0xFF605F5F)); + await Assert.That(inWhite ).IsEqualTo(unchecked((int)0xFF8E8E8E)); + } + + [Test] + [DisplayName("Color Relativity — black in black/white")] + public async Task ColorRelativity_Black() + { + var hct = Hct.FromInt(Black); + var inBlack = hct.InViewingConditions(ViewingConditions.DefaultWithBackgroundLstar(0.0)).Argb; + var inWhite = hct.InViewingConditions(ViewingConditions.DefaultWithBackgroundLstar(100.0)).Argb; + + await Assert.That(inBlack ).IsEqualTo(unchecked((int)0xFF000000)); + await Assert.That(inWhite ).IsEqualTo(unchecked((int)0xFF000000)); + } +} diff --git a/tests/MaterialColorUtilities.Tests/MaterialColorUtilities.Tests.csproj b/tests/MaterialColorUtilities.Tests/MaterialColorUtilities.Tests.csproj new file mode 100644 index 0000000000..34faae9454 --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/MaterialColorUtilities.Tests.csproj @@ -0,0 +1,34 @@ + + + + net8.0-windows + MaterialColorUtilities.Tests + MaterialColorUtilities.Tests + Exe + true + true + true + enable + enable + false + true + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + + + diff --git a/tests/MaterialColorUtilities.Tests/MaterialDynamicColorsTests.cs b/tests/MaterialColorUtilities.Tests/MaterialDynamicColorsTests.cs new file mode 100644 index 0000000000..a0dffff50d --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/MaterialDynamicColorsTests.cs @@ -0,0 +1,243 @@ +namespace MaterialColorUtilities.Tests; + +public sealed class MaterialDynamicColorsTests +{ + private static readonly Hct[] SeedColors = + [ + Hct.FromInt(unchecked((int)0xFFFF0000)), + Hct.FromInt(unchecked((int)0xFFFFFF00)), + Hct.FromInt(unchecked((int)0xFF00FF00)), + Hct.FromInt(unchecked((int)0xFF0000FF)) + ]; + + private static readonly double[] ContrastLevels = [-1.0, -0.5, 0.0, 0.5, 1.0]; + + private sealed record Pair(string ForegroundName, string BackgroundName); + + [Test] + [DisplayName("MaterialDynamicColors: Values are correct (spot checks)")] + public async Task Values_Are_Correct_SpotChecks() + { + var mdc = new MaterialDynamicColors(); + + var onPrimaryContainerArgb = mdc.OnPrimaryContainer.GetArgb( + new SchemeFidelity( + sourceColorHct: Hct.FromInt(unchecked((int)0xFFFF0000)), + isDark: false, + contrastLevel: 0.5)); + await Assert.That(onPrimaryContainerArgb).IsEqualTo(unchecked((int)0xFFFFFFFF)); + + var onSecondaryContainerArgb = mdc.OnSecondaryContainer.GetArgb( + new SchemeContent( + sourceColorHct: Hct.FromInt(unchecked((int)0xFF0000FF)), + isDark: false, + contrastLevel: 0.5)); + await Assert.That(onSecondaryContainerArgb).IsEqualTo(unchecked((int)0xFFFFFFFF)); + + var onTertiaryContainerArgb = mdc.OnTertiaryContainer.GetArgb( + new SchemeContent( + sourceColorHct: Hct.FromInt(unchecked((int)0xFFFFFF00)), + isDark: true, + contrastLevel: -0.5)); + await Assert.That(onTertiaryContainerArgb).IsEqualTo(unchecked((int)0xFF959B1A)); + + var inverseSurfaceArgb = mdc.InverseSurface.GetArgb( + new SchemeContent( + sourceColorHct: Hct.FromInt(unchecked((int)0xFF0000FF)), + isDark: false, + contrastLevel: 0.0)); + await Assert.That(inverseSurfaceArgb).IsEqualTo(unchecked((int)0xFF2F2F3B)); + + var inversePrimaryArgb = mdc.InversePrimary.GetArgb( + new SchemeContent( + sourceColorHct: Hct.FromInt(unchecked((int)0xFFFF0000)), + isDark: false, + contrastLevel: -0.5)); + await Assert.That(inversePrimaryArgb).IsEqualTo(unchecked((int)0xFFFF422F)); + + var outlineVariantArgb = mdc.OutlineVariant.GetArgb( + new SchemeContent( + sourceColorHct: Hct.FromInt(unchecked((int)0xFFFFFF00)), + isDark: true, + contrastLevel: 0.0)); + await Assert.That(outlineVariantArgb).IsEqualTo(unchecked((int)0xFF484831)); + } + + [Test] + [DisplayName("Dynamic schemes respect contrast for text/surface pairs")] + public async Task Dynamic_Schemes_Respect_Contrast_Text_Surface_Pairs() + { + var mdc = new MaterialDynamicColors(); + + // Name -> DynamicColor map (matches the Dart dictionary) + var colors = new Dictionary(StringComparer.Ordinal) + { + ["background"] = mdc.Background, + ["on_background"] = mdc.OnBackground, + ["surface"] = mdc.Surface, + ["surface_dim"] = mdc.SurfaceDim, + ["surface_bright"] = mdc.SurfaceBright, + ["surface_container_lowest"] = mdc.SurfaceContainerLowest, + ["surface_container_low"] = mdc.SurfaceContainerLow, + ["surface_container"] = mdc.SurfaceContainer, + ["surface_container_high"] = mdc.SurfaceContainerHigh, + ["surface_container_highest"] = mdc.SurfaceContainerHighest, + ["on_surface"] = mdc.OnSurface, + ["surface_variant"] = mdc.SurfaceVariant, + ["on_surface_variant"] = mdc.OnSurfaceVariant, + ["inverse_surface"] = mdc.InverseSurface, + ["inverse_on_surface"] = mdc.InverseOnSurface, + ["outline"] = mdc.Outline, + ["outline_variant"] = mdc.OutlineVariant, + ["shadow"] = mdc.Shadow, + ["scrim"] = mdc.Scrim, + ["surface_tint"] = mdc.SurfaceTint, + ["primary"] = mdc.Primary, + ["on_primary"] = mdc.OnPrimary, + ["primary_container"] = mdc.PrimaryContainer, + ["on_primary_container"] = mdc.OnPrimaryContainer, + ["inverse_primary"] = mdc.InversePrimary, + ["secondary"] = mdc.Secondary, + ["on_secondary"] = mdc.OnSecondary, + ["secondary_container"] = mdc.SecondaryContainer, + ["on_secondary_container"] = mdc.OnSecondaryContainer, + ["tertiary"] = mdc.Tertiary, + ["on_tertiary"] = mdc.OnTertiary, + ["tertiary_container"] = mdc.TertiaryContainer, + ["on_tertiary_container"] = mdc.OnTertiaryContainer, + ["error"] = mdc.Error, + ["on_error"] = mdc.OnError, + ["error_container"] = mdc.ErrorContainer, + ["on_error_container"] = mdc.OnErrorContainer, + }; + + var textSurfacePairs = new[] + { + new Pair("on_primary", "primary"), + new Pair("on_primary_container", "primary_container"), + new Pair("on_secondary", "secondary"), + new Pair("on_secondary_container", "secondary_container"), + new Pair("on_tertiary", "tertiary"), + new Pair("on_tertiary_container", "tertiary_container"), + new Pair("on_error", "error"), + new Pair("on_error_container", "error_container"), + new Pair("on_background", "background"), + new Pair("on_surface_variant", "surface_bright"), + new Pair("on_surface_variant", "surface_dim"), + new Pair("inverse_on_surface", "inverse_surface"), + }; + + foreach (var color in SeedColors) + foreach (var contrastLevel in ContrastLevels) + foreach (var isDark in new[] { false, true }) + { + var schemes = new DynamicScheme[] + { + new SchemeContent(sourceColorHct: color, isDark: isDark, contrastLevel: contrastLevel), + new SchemeMonochrome(sourceColorHct: color, isDark: isDark, contrastLevel: contrastLevel), + new SchemeTonalSpot(sourceColorHct: color, isDark: isDark, contrastLevel: contrastLevel), + new SchemeFidelity(sourceColorHct: color, isDark: isDark, contrastLevel: contrastLevel), + }; + + foreach (var scheme in schemes) + { + foreach (var pair in textSurfacePairs) + { + var fg = colors[pair.ForegroundName]; + var bg = colors[pair.BackgroundName]; + + var foregroundTone = fg.GetHct(scheme).Tone; + var backgroundTone = bg.GetHct(scheme).Tone; + var contrast = Contrast.RatioOfTones(foregroundTone, backgroundTone); + + var minimumRequirement = contrastLevel >= 0.0 ? 4.5 : 3.0; + + await Assert.That(contrast) + .IsGreaterThanOrEqualTo(minimumRequirement) + .Because($"Contrast {contrast} is too low between " + + $"foreground ({pair.ForegroundName}; {foregroundTone}) and " + + $"background ({pair.BackgroundName}; {backgroundTone}) " + + $"for scheme={scheme} seed={color} CL={contrastLevel} dark={isDark}"); + } + } + } + } + + [Test] + [DisplayName("Fixed colors in non-monochrome schemes (TonalSpot, dark)")] + public async Task Fixed_Colors_NonMonochrome_TonalSpot_Dark() + { + var mdc = new MaterialDynamicColors(); + var scheme = new SchemeTonalSpot( + sourceColorHct: Hct.FromInt(unchecked((int)0xFFFF0000)), + isDark: true, + contrastLevel: 0.0); + + await Assert.That(mdc.PrimaryFixed.GetHct(scheme).Tone).IsEqualTo(90.0).Within(1.0); + await Assert.That(mdc.PrimaryFixedDim.GetHct(scheme).Tone).IsEqualTo(80.0).Within(1.0); + await Assert.That(mdc.OnPrimaryFixed.GetHct(scheme).Tone).IsEqualTo(10.0).Within(1.0); + await Assert.That(mdc.OnPrimaryFixedVariant.GetHct(scheme).Tone).IsEqualTo(30.0).Within(1.0); + + await Assert.That(mdc.SecondaryFixed.GetHct(scheme).Tone).IsEqualTo(90.0).Within(1.0); + await Assert.That(mdc.SecondaryFixedDim.GetHct(scheme).Tone).IsEqualTo(80.0).Within(1.0); + await Assert.That(mdc.OnSecondaryFixed.GetHct(scheme).Tone).IsEqualTo(10.0).Within(1.0); + await Assert.That(mdc.OnSecondaryFixedVariant.GetHct(scheme).Tone).IsEqualTo(30.0).Within(1.0); + + await Assert.That(mdc.TertiaryFixed.GetHct(scheme).Tone).IsEqualTo(90.0).Within(1.0); + await Assert.That(mdc.TertiaryFixedDim.GetHct(scheme).Tone).IsEqualTo(80.0).Within(1.0); + await Assert.That(mdc.OnTertiaryFixed.GetHct(scheme).Tone).IsEqualTo(10.0).Within(1.0); + await Assert.That(mdc.OnTertiaryFixedVariant.GetHct(scheme).Tone).IsEqualTo(30.0).Within(1.0); + } + + [Test] + [DisplayName("Fixed colors in light monochrome schemes")] + public async Task Fixed_Colors_Light_Monochrome() + { + var mdc = new MaterialDynamicColors(); + var scheme = new SchemeMonochrome( + sourceColorHct: Hct.FromInt(unchecked((int)0xFFFF0000)), + isDark: false, + contrastLevel: 0.0); + + await Assert.That(mdc.PrimaryFixed.GetHct(scheme).Tone).IsEqualTo(40.0).Within(1.0); + await Assert.That(mdc.PrimaryFixedDim.GetHct(scheme).Tone).IsEqualTo(30.0).Within(1.0); + await Assert.That(mdc.OnPrimaryFixed.GetHct(scheme).Tone).IsEqualTo(100.0).Within(1.0); + await Assert.That(mdc.OnPrimaryFixedVariant.GetHct(scheme).Tone).IsEqualTo(90.0).Within(1.0); + + await Assert.That(mdc.SecondaryFixed.GetHct(scheme).Tone).IsEqualTo(80.0).Within(1.0); + await Assert.That(mdc.SecondaryFixedDim.GetHct(scheme).Tone).IsEqualTo(70.0).Within(1.0); + await Assert.That(mdc.OnSecondaryFixed.GetHct(scheme).Tone).IsEqualTo(10.0).Within(1.0); + await Assert.That(mdc.OnSecondaryFixedVariant.GetHct(scheme).Tone).IsEqualTo(25.0).Within(1.0); + + await Assert.That(mdc.TertiaryFixed.GetHct(scheme).Tone).IsEqualTo(40.0).Within(1.0); + await Assert.That(mdc.TertiaryFixedDim.GetHct(scheme).Tone).IsEqualTo(30.0).Within(1.0); + await Assert.That(mdc.OnTertiaryFixed.GetHct(scheme).Tone).IsEqualTo(100.0).Within(1.0); + await Assert.That(mdc.OnTertiaryFixedVariant.GetHct(scheme).Tone).IsEqualTo(90.0).Within(1.0); + } + + [Test] + [DisplayName("Fixed colors in dark monochrome schemes")] + public async Task Fixed_Colors_Dark_Monochrome() + { + var mdc = new MaterialDynamicColors(); + var scheme = new SchemeMonochrome( + sourceColorHct: Hct.FromInt(unchecked((int)0xFFFF0000)), + isDark: true, + contrastLevel: 0.0); + + await Assert.That(mdc.PrimaryFixed.GetHct(scheme).Tone).IsEqualTo(40.0).Within(1.0); + await Assert.That(mdc.PrimaryFixedDim.GetHct(scheme).Tone).IsEqualTo(30.0).Within(1.0); + await Assert.That(mdc.OnPrimaryFixed.GetHct(scheme).Tone).IsEqualTo(100.0).Within(1.0); + await Assert.That(mdc.OnPrimaryFixedVariant.GetHct(scheme).Tone).IsEqualTo(90.0).Within(1.0); + + await Assert.That(mdc.SecondaryFixed.GetHct(scheme).Tone).IsEqualTo(80.0).Within(1.0); + await Assert.That(mdc.SecondaryFixedDim.GetHct(scheme).Tone).IsEqualTo(70.0).Within(1.0); + await Assert.That(mdc.OnSecondaryFixed.GetHct(scheme).Tone).IsEqualTo(10.0).Within(1.0); + await Assert.That(mdc.OnSecondaryFixedVariant.GetHct(scheme).Tone).IsEqualTo(25.0).Within(1.0); + + await Assert.That(mdc.TertiaryFixed.GetHct(scheme).Tone).IsEqualTo(40.0).Within(1.0); + await Assert.That(mdc.TertiaryFixedDim.GetHct(scheme).Tone).IsEqualTo(30.0).Within(1.0); + await Assert.That(mdc.OnTertiaryFixed.GetHct(scheme).Tone).IsEqualTo(100.0).Within(1.0); + await Assert.That(mdc.OnTertiaryFixedVariant.GetHct(scheme).Tone).IsEqualTo(90.0).Within(1.0); + } +} diff --git a/tests/MaterialColorUtilities.Tests/MathUtilsTests.cs b/tests/MaterialColorUtilities.Tests/MathUtilsTests.cs new file mode 100644 index 0000000000..6fd73fe6e7 --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/MathUtilsTests.cs @@ -0,0 +1,48 @@ +namespace MaterialColorUtilities.Tests; + +public sealed class MathUtilsTests +{ + private static double ReferenceRotationDirection(double from, double to) + { + var a = to - from; + var b = to - from + 360.0; + var c = to - from - 360.0; + var aAbs = Math.Abs(a); + var bAbs = Math.Abs(b); + var cAbs = Math.Abs(c); + + if (aAbs <= bAbs && aAbs <= cAbs) + { + return a >= 0.0 ? 1.0 : -1.0; + } + + if (bAbs <= aAbs && bAbs <= cAbs) + { + return b >= 0.0 ? 1.0 : -1.0; + } + + return c >= 0.0 ? 1.0 : -1.0; + } + + [Test] + [DisplayName("rotationDirection behaves correctly")] + public async Task RotationDirection_Behaves_Correctly() + { + for (double from = 0.0; from < 360.0; from += 15.0) + { + for (double to = 7.5; to < 360.0; to += 15.0) + { + var expected = ReferenceRotationDirection(from, to); + var actual = MathUtils.RotationDirection(from, to); + + await Assert.That(actual) + .IsEqualTo(expected) + .Because($"should be {expected} from {from} to {to}"); + + await Assert.That(Math.Abs(actual)) + .IsEqualTo(1.0) + .Because($"should be either +1.0 or -1.0 from {from} to {to} (got {actual})"); + } + } + } +} diff --git a/tests/MaterialColorUtilities.Tests/QuantizerCelebiTests.cs b/tests/MaterialColorUtilities.Tests/QuantizerCelebiTests.cs new file mode 100644 index 0000000000..6aa0d7cb63 --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/QuantizerCelebiTests.cs @@ -0,0 +1,101 @@ +namespace MaterialColorUtilities.Tests; + +public sealed class QuantizerCelebiTests +{ + private const int Red = unchecked((int)0xFFFF0000); + private const int Green = unchecked((int)0xFF00FF00); + private const int Blue = unchecked((int)0xFF0000FF); + private const int MaxColors = 256; + + [Test] + [DisplayName("1R")] + public async Task OneRed() + { + var result = QuantizerCelebi.Quantize([Red], MaxColors); + var colors = result.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + await Assert.That(colors[0]).IsEqualTo(Red); + } + + [Test] + [DisplayName("1G")] + public async Task OneGreen() + { + var result = QuantizerCelebi.Quantize([Green], MaxColors); + var colors = result.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + await Assert.That(colors[0]).IsEqualTo(Green); + } + + [Test] + [DisplayName("1B")] + public async Task OneBlue() + { + var result = QuantizerCelebi.Quantize([Blue], MaxColors); + var colors = result.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + await Assert.That(colors[0]).IsEqualTo(Blue); + } + + [Test] + [DisplayName("5B")] + public async Task FiveBlue() + { + var pixels = new[] { Blue, Blue, Blue, Blue, Blue }; + var result = QuantizerCelebi.Quantize(pixels, MaxColors); + var colors = result.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + await Assert.That(colors[0]).IsEqualTo(Blue); + await Assert.That(result[Blue]).IsEqualTo(5); + } + + [Test] + [DisplayName("1R 1G 1B")] + public async Task OneRedOneGreenOneBlue() + { + var result = QuantizerCelebi.Quantize([Red, Green, Blue], MaxColors); + + // Content (set) must contain exactly the three colors + var set = result.Keys.ToHashSet(); + await Assert.That(set.Count).IsEqualTo(3); + await Assert.That(set.Contains(Blue)).IsTrue(); + await Assert.That(set.Contains(Red)).IsTrue(); + await Assert.That(set.Contains(Green)).IsTrue(); + + // Each should have count 1 + await Assert.That(result[Blue]).IsEqualTo(1); + await Assert.That(result[Red]).IsEqualTo(1); + await Assert.That(result[Green]).IsEqualTo(1); + + // If you want to mimic the Dart list-order assertion, sort by population desc, then by ARGB for ties: + var ordered = result.OrderByDescending(kv => kv.Value).ThenBy(kv => kv.Key).Select(kv => kv.Key).ToList(); + await Assert.That(ordered.ToHashSet().SetEquals([Blue, Red, Green])).IsTrue(); + } + + [Test] + [DisplayName("2R 3G")] + public async Task TwoRedThreeGreen() + { + var pixels = new[] { Red, Red, Green, Green, Green }; + var result = QuantizerCelebi.Quantize(pixels, MaxColors); + + // Exactly two colors present + var set = result.Keys.ToHashSet(); + await Assert.That(set.Count).IsEqualTo(2); + await Assert.That(set.Contains(Green)).IsTrue(); + await Assert.That(set.Contains(Red)).IsTrue(); + + // Counts must reflect populations + await Assert.That(result[Green]).IsEqualTo(3); + await Assert.That(result[Red]).IsEqualTo(2); + + // Verify population ordering (green first) + var ordered = result.OrderByDescending(kv => kv.Value).Select(kv => kv.Key).ToList(); + await Assert.That(ordered[0]).IsEqualTo(Green); + await Assert.That(ordered[1]).IsEqualTo(Red); + } +} diff --git a/tests/MaterialColorUtilities.Tests/QuantizerWsMeansTests.cs b/tests/MaterialColorUtilities.Tests/QuantizerWsMeansTests.cs new file mode 100644 index 0000000000..18a9449a25 --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/QuantizerWsMeansTests.cs @@ -0,0 +1,79 @@ +namespace MaterialColorUtilities.Tests; + +public sealed class QuantizerWsMeansTests +{ + private const int Red = unchecked((int)0xFFFF0000); + private const int Green = unchecked((int)0xFF00FF00); + private const int Blue = unchecked((int)0xFF0000FF); + private const int OneRando = unchecked((int)0xFF141216); + private const int MaxColors = 256; + + private static int[] NoStartingClusters => []; + + [Test] + [DisplayName("1Rando")] + public async Task OneRandomColor() + { + var result = QuantizerWsMeans.Quantize([OneRando], NoStartingClusters, MaxColors); + var colors = result.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + await Assert.That(colors[0]).IsEqualTo(OneRando); + } + + [Test] + [DisplayName("1R (presence)")] + public async Task OneRed_Presence() + { + var result = QuantizerWsMeans.Quantize([Red], NoStartingClusters, MaxColors); + var colors = result.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + } + + [Test] + [DisplayName("1R (exact)")] + public async Task OneRed_Exact() + { + var result = QuantizerWsMeans.Quantize([Red], NoStartingClusters, MaxColors); + var colors = result.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + await Assert.That(colors[0]).IsEqualTo(Red); + } + + [Test] + [DisplayName("1G")] + public async Task OneGreen() + { + var result = QuantizerWsMeans.Quantize([Green], NoStartingClusters, MaxColors); + var colors = result.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + await Assert.That(colors[0]).IsEqualTo(Green); + } + + [Test] + [DisplayName("1B")] + public async Task OneBlue() + { + var result = QuantizerWsMeans.Quantize([Blue], NoStartingClusters, MaxColors); + var colors = result.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + await Assert.That(colors[0]).IsEqualTo(Blue); + } + + [Test] + [DisplayName("5B")] + public async Task FiveBlue() + { + var pixels = new[] { Blue, Blue, Blue, Blue, Blue }; + var result = QuantizerWsMeans.Quantize(pixels, NoStartingClusters, MaxColors); + var colors = result.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + await Assert.That(colors[0]).IsEqualTo(Blue); + await Assert.That(result[Blue]).IsEqualTo(5); + } +} diff --git a/tests/MaterialColorUtilities.Tests/QuantizerWuTests.cs b/tests/MaterialColorUtilities.Tests/QuantizerWuTests.cs new file mode 100644 index 0000000000..c5985a58f3 --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/QuantizerWuTests.cs @@ -0,0 +1,121 @@ +namespace MaterialColorUtilities.Tests; + +public sealed class QuantizerWuTests +{ + private const int Red = unchecked((int)0xFFFF0000); + private const int Green = unchecked((int)0xFF00FF00); + private const int Blue = unchecked((int)0xFF0000FF); + private const int MaxColors = 256; + + [Test] + [DisplayName("1R (presence)")] + public async Task OneRed_Presence() + { + var wu = new QuantizerWu(); + var result = wu.Quantize([Red], MaxColors); + var colors = result.ColorToCount.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + } + + [Test] + [DisplayName("1Rando")] + public async Task OneRandom() + { + var wu = new QuantizerWu(); + var argb = unchecked((int)0xFF141216); + var result = wu.Quantize([argb], MaxColors); + var colors = result.ColorToCount.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + await Assert.That(colors[0]).IsEqualTo(argb); + } + + [Test] + [DisplayName("1R (exact)")] + public async Task OneRed_Exact() + { + var wu = new QuantizerWu(); + var result = wu.Quantize([Red], MaxColors); + var colors = result.ColorToCount.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + await Assert.That(colors[0]).IsEqualTo(Red); + } + + [Test] + [DisplayName("1G")] + public async Task OneGreen() + { + var wu = new QuantizerWu(); + var result = wu.Quantize([Green], MaxColors); + var colors = result.ColorToCount.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + await Assert.That(colors[0]).IsEqualTo(Green); + } + + [Test] + [DisplayName("1B")] + public async Task OneBlue() + { + var wu = new QuantizerWu(); + var result = wu.Quantize([Blue], MaxColors); + var colors = result.ColorToCount.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + await Assert.That(colors[0]).IsEqualTo(Blue); + } + + [Test] + [DisplayName("5B")] + public async Task FiveBlue() + { + var wu = new QuantizerWu(); + var pixels = new[] { Blue, Blue, Blue, Blue, Blue }; + var result = wu.Quantize(pixels, MaxColors); + var colors = result.ColorToCount.Keys.ToList(); + + await Assert.That(colors.Count).IsEqualTo(1); + await Assert.That(colors[0]).IsEqualTo(Blue); + } + + [Test] + [DisplayName("2R 3G")] + public async Task TwoRed_ThreeGreen() + { + var wu = new QuantizerWu(); + var pixels = new[] { Red, Red, Green, Green, Green }; + var result = wu.Quantize(pixels, MaxColors); + var colors = result.ColorToCount.Keys.ToList(); + + // Set membership + await Assert.That(colors.ToHashSet().Count).IsEqualTo(2); + await Assert.That(colors.Contains(Green)).IsTrue(); + await Assert.That(colors.Contains(Red)).IsTrue(); + + // Dart asserts order: [green, red] + await Assert.That(colors[0]).IsEqualTo(Green); + await Assert.That(colors[1]).IsEqualTo(Red); + } + + [Test] + [DisplayName("1R 1G 1B")] + public async Task OneRed_OneGreen_OneBlue() + { + var wu = new QuantizerWu(); + var result = wu.Quantize([Red, Green, Blue], MaxColors); + var colors = result.ColorToCount.Keys.ToList(); + + // Set membership + await Assert.That(colors.ToHashSet().Count).IsEqualTo(3); + await Assert.That(colors.Contains(Blue)).IsTrue(); + await Assert.That(colors.Contains(Red)).IsTrue(); + await Assert.That(colors.Contains(Green)).IsTrue(); + + // Dart asserts order: [blue, red, green] + await Assert.That(colors[0]).IsEqualTo(Blue); + await Assert.That(colors[1]).IsEqualTo(Red); + await Assert.That(colors[2]).IsEqualTo(Green); + } +} diff --git a/tests/MaterialColorUtilities.Tests/SchemeMonochromeTests.cs b/tests/MaterialColorUtilities.Tests/SchemeMonochromeTests.cs new file mode 100644 index 0000000000..f1ac5ed46f --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/SchemeMonochromeTests.cs @@ -0,0 +1,60 @@ +namespace MaterialColorUtilities.Tests; + +public sealed class SchemeMonochromeTests +{ + private static readonly int Blue = unchecked((int)0xFF0000FF); + + [Test] + [DisplayName("Monochrome spec (dark theme)")] + public async Task DarkTheme_MonochromeSpec() + { + var mdc = new MaterialDynamicColors(); + var scheme = new SchemeMonochrome( + sourceColorHct: Hct.FromInt(Blue), + isDark: true, + contrastLevel: 0.0 + ); + + await Assert.That(mdc.Primary.GetHct(scheme).Tone).IsEqualTo(100).Within(1); + await Assert.That(mdc.OnPrimary.GetHct(scheme).Tone).IsEqualTo(10).Within(1); + await Assert.That(mdc.PrimaryContainer.GetHct(scheme).Tone).IsEqualTo(85).Within(1); + await Assert.That(mdc.OnPrimaryContainer.GetHct(scheme).Tone).IsEqualTo(0).Within(1); + + await Assert.That(mdc.Secondary.GetHct(scheme).Tone).IsEqualTo(80).Within(1); + await Assert.That(mdc.OnSecondary.GetHct(scheme).Tone).IsEqualTo(10).Within(1); + await Assert.That(mdc.SecondaryContainer.GetHct(scheme).Tone).IsEqualTo(30).Within(1); + await Assert.That(mdc.OnSecondaryContainer.GetHct(scheme).Tone).IsEqualTo(90).Within(1); + + await Assert.That(mdc.Tertiary.GetHct(scheme).Tone).IsEqualTo(90).Within(1); + await Assert.That(mdc.OnTertiary.GetHct(scheme).Tone).IsEqualTo(10).Within(1); + await Assert.That(mdc.TertiaryContainer.GetHct(scheme).Tone).IsEqualTo(60).Within(1); + await Assert.That(mdc.OnTertiaryContainer.GetHct(scheme).Tone).IsEqualTo(0).Within(1); + } + + [Test] + [DisplayName("Monochrome spec (light theme)")] + public async Task LightTheme_MonochromeSpec() + { + var mdc = new MaterialDynamicColors(); + var scheme = new SchemeMonochrome( + sourceColorHct: Hct.FromInt(Blue), + isDark: false, + contrastLevel: 0.0 + ); + + await Assert.That(mdc.Primary.GetHct(scheme).Tone).IsEqualTo(0).Within(1); + await Assert.That(mdc.OnPrimary.GetHct(scheme).Tone).IsEqualTo(90).Within(1); + await Assert.That(mdc.PrimaryContainer.GetHct(scheme).Tone).IsEqualTo(25).Within(1); + await Assert.That(mdc.OnPrimaryContainer.GetHct(scheme).Tone).IsEqualTo(100).Within(1); + + await Assert.That(mdc.Secondary.GetHct(scheme).Tone).IsEqualTo(40).Within(1); + await Assert.That(mdc.OnSecondary.GetHct(scheme).Tone).IsEqualTo(100).Within(1); + await Assert.That(mdc.SecondaryContainer.GetHct(scheme).Tone).IsEqualTo(85).Within(1); + await Assert.That(mdc.OnSecondaryContainer.GetHct(scheme).Tone).IsEqualTo(10).Within(1); + + await Assert.That(mdc.Tertiary.GetHct(scheme).Tone).IsEqualTo(25).Within(1); + await Assert.That(mdc.OnTertiary.GetHct(scheme).Tone).IsEqualTo(90).Within(1); + await Assert.That(mdc.TertiaryContainer.GetHct(scheme).Tone).IsEqualTo(49).Within(1); + await Assert.That(mdc.OnTertiaryContainer.GetHct(scheme).Tone).IsEqualTo(100).Within(1); + } +} diff --git a/tests/MaterialColorUtilities.Tests/ScoreTests.cs b/tests/MaterialColorUtilities.Tests/ScoreTests.cs new file mode 100644 index 0000000000..9350efff87 --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/ScoreTests.cs @@ -0,0 +1,332 @@ +namespace MaterialColorUtilities.Tests; + +public sealed class ScoreTests +{ + private const int Red = unchecked((int)0xFFFF0000); + private const int Green = unchecked((int)0xFF00FF00); + private const int Blue = unchecked((int)0xFF0000FF); + + [Test] + [DisplayName("Prioritizes chroma")] + public async Task Prioritizes_Chroma() + { + var colorsToPopulation = new Dictionary + { + [unchecked((int)0xFF000000)] = 1, + [unchecked((int)0xFFFFFFFF)] = 1, + [Blue] = 1, + }; + + var ranked = Score.ScoreColors(colorsToPopulation, desired: 4).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(1); + await Assert.That(ranked[0]).IsEqualTo(Blue); + } + + [Test] + [DisplayName("Prioritizes chroma when proportions equal")] + public async Task Prioritizes_Chroma_When_Proportions_Equal() + { + var colorsToPopulation = new Dictionary + { + [Red] = 1, + [Green] = 1, + [Blue] = 1, + }; + + var ranked = Score.ScoreColors(colorsToPopulation, desired: 4).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(3); + await Assert.That(ranked[0]).IsEqualTo(Red); + await Assert.That(ranked[1]).IsEqualTo(Green); + await Assert.That(ranked[2]).IsEqualTo(Blue); + } + + [Test] + [DisplayName("Generates Google Blue when no colors available")] + public async Task Generates_GoogleBlue_When_No_Colors_Available() + { + var colorsToPopulation = new Dictionary + { + [unchecked((int)0xFF000000)] = 1 + }; + + var ranked = Score.ScoreColors(colorsToPopulation, desired: 4).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(1); + await Assert.That(ranked[0]).IsEqualTo(unchecked((int)0xFF4285F4)); + } + + [Test] + [DisplayName("Dedupes nearby hues")] + public async Task Dedupes_Nearby_Hues() + { + var colorsToPopulation = new Dictionary + { + [unchecked((int)0xFF008772)] = 1, // H 180 C 42 T 50 + [unchecked((int)0xFF318477)] = 1, // H 184 C 35 T 50 + }; + + var ranked = Score.ScoreColors(colorsToPopulation, desired: 4).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(1); + await Assert.That(ranked[0]).IsEqualTo(unchecked((int)0xFF008772)); + } + + [Test] + [DisplayName("Maximizes hue distance")] + public async Task Maximizes_Hue_Distance() + { + var colorsToPopulation = new Dictionary + { + [unchecked((int)0xFF008772)] = 1, // H 180 C 42 T 50 + [unchecked((int)0xFF008587)] = 1, // H 198 C 50 T 50 + [unchecked((int)0xFF007EBC)] = 1, // H 245 C 50 T 50 + }; + + var ranked = Score.ScoreColors(colorsToPopulation, desired: 2).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(2); + await Assert.That(ranked[0]).IsEqualTo(unchecked((int)0xFF007EBC)); + await Assert.That(ranked[1]).IsEqualTo(unchecked((int)0xFF008772)); + } + + [Test] + [DisplayName("Generated scenario one")] + public async Task Generated_Scenario_One() + { + var colorsToPopulation = new Dictionary + { + [unchecked((int)0xFF7EA16D)] = 67, + [unchecked((int)0xFFD8CCAE)] = 67, + [unchecked((int)0xFF835C0D)] = 49, + }; + + var ranked = Score.ScoreColors( + colorsToPopulation, + desired: 3, + fallbackColorArgb: unchecked((int)0xFF8D3819), + filter: false).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(3); + await Assert.That(ranked[0]).IsEqualTo(unchecked((int)0xFF7EA16D)); + await Assert.That(ranked[1]).IsEqualTo(unchecked((int)0xFFD8CCAE)); + await Assert.That(ranked[2]).IsEqualTo(unchecked((int)0xFF835C0D)); + } + + [Test] + [DisplayName("Generated scenario two")] + public async Task Generated_Scenario_Two() + { + var colorsToPopulation = new Dictionary + { + [unchecked((int)0xFFD33881)] = 14, + [unchecked((int)0xFF3205CC)] = 77, + [unchecked((int)0xFF0B48CF)] = 36, + [unchecked((int)0xFFA08F5D)] = 81, + }; + + var ranked = Score.ScoreColors( + colorsToPopulation, + desired: 4, + fallbackColorArgb: unchecked((int)0xFF7D772B), + filter: true).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(3); + await Assert.That(ranked[0]).IsEqualTo(unchecked((int)0xFF3205CC)); + await Assert.That(ranked[1]).IsEqualTo(unchecked((int)0xFFA08F5D)); + await Assert.That(ranked[2]).IsEqualTo(unchecked((int)0xFFD33881)); + } + + [Test] + [DisplayName("Generated scenario three")] + public async Task Generated_Scenario_Three() + { + var colorsToPopulation = new Dictionary + { + [unchecked((int)0xFFBE94A6)] = 23, + [unchecked((int)0xFFC33FD7)] = 42, + [unchecked((int)0xFF899F36)] = 90, + [unchecked((int)0xFF94C574)] = 82, + }; + + var ranked = Score.ScoreColors( + colorsToPopulation, + desired: 3, + fallbackColorArgb: unchecked((int)0xFFAA79A4), + filter: true).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(3); + await Assert.That(ranked[0]).IsEqualTo(unchecked((int)0xFF94C574)); + await Assert.That(ranked[1]).IsEqualTo(unchecked((int)0xFFC33FD7)); + await Assert.That(ranked[2]).IsEqualTo(unchecked((int)0xFFBE94A6)); + } + + [Test] + [DisplayName("Generated scenario four")] + public async Task Generated_Scenario_Four() + { + var colorsToPopulation = new Dictionary + { + [unchecked((int)0xFFDF241C)] = 85, + [unchecked((int)0xFF685859)] = 44, + [unchecked((int)0xFFD06D5F)] = 34, + [unchecked((int)0xFF561C54)] = 27, + [unchecked((int)0xFF713090)] = 88, + }; + + var ranked = Score.ScoreColors( + colorsToPopulation, + desired: 5, + fallbackColorArgb: unchecked((int)0xFF58C19C), + filter: false).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(2); + await Assert.That(ranked[0]).IsEqualTo(unchecked((int)0xFFDF241C)); + await Assert.That(ranked[1]).IsEqualTo(unchecked((int)0xFF561C54)); + } + + [Test] + [DisplayName("Generated scenario five")] + public async Task Generated_Scenario_Five() + { + var colorsToPopulation = new Dictionary + { + [unchecked((int)0xFFBE66F8)] = 41, + [unchecked((int)0xFF4BBDA9)] = 88, + [unchecked((int)0xFF80F6F9)] = 44, + [unchecked((int)0xFFAB8017)] = 43, + [unchecked((int)0xFFE89307)] = 65, + }; + + var ranked = Score.ScoreColors( + colorsToPopulation, + desired: 3, + fallbackColorArgb: unchecked((int)0xFF916691), + filter: false).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(3); + await Assert.That(ranked[0]).IsEqualTo(unchecked((int)0xFFAB8017)); + await Assert.That(ranked[1]).IsEqualTo(unchecked((int)0xFF4BBDA9)); + await Assert.That(ranked[2]).IsEqualTo(unchecked((int)0xFFBE66F8)); + } + + [Test] + [DisplayName("Generated scenario six")] + public async Task Generated_Scenario_Six() + { + var colorsToPopulation = new Dictionary + { + [unchecked((int)0xFF18EA8F)] = 93, + [unchecked((int)0xFF327593)] = 18, + [unchecked((int)0xFF066A18)] = 53, + [unchecked((int)0xFFFA8A23)] = 74, + [unchecked((int)0xFF04CA1F)] = 62, + }; + + var ranked = Score.ScoreColors( + colorsToPopulation, + desired: 2, + fallbackColorArgb: unchecked((int)0xFF4C377A), + filter: false).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(2); + await Assert.That(ranked[0]).IsEqualTo(unchecked((int)0xFF18EA8F)); + await Assert.That(ranked[1]).IsEqualTo(unchecked((int)0xFFFA8A23)); + } + + [Test] + [DisplayName("Generated scenario seven")] + public async Task Generated_Scenario_Seven() + { + var colorsToPopulation = new Dictionary + { + [unchecked((int)0xFF2E05ED)] = 23, + [unchecked((int)0xFF153E55)] = 90, + [unchecked((int)0xFF9AB220)] = 23, + [unchecked((int)0xFF153379)] = 66, + [unchecked((int)0xFF68BCC3)] = 81, + }; + + var ranked = Score.ScoreColors( + colorsToPopulation, + desired: 2, + fallbackColorArgb: unchecked((int)0xFFF588DC), + filter: true).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(2); + await Assert.That(ranked[0]).IsEqualTo(unchecked((int)0xFF2E05ED)); + await Assert.That(ranked[1]).IsEqualTo(unchecked((int)0xFF9AB220)); + } + + [Test] + [DisplayName("Generated scenario eight")] + public async Task Generated_Scenario_Eight() + { + var colorsToPopulation = new Dictionary + { + [unchecked((int)0xFF816EC5)] = 24, + [unchecked((int)0xFF6DCB94)] = 19, + [unchecked((int)0xFF3CAE91)] = 98, + [unchecked((int)0xFF5B542F)] = 25, + }; + + var ranked = Score.ScoreColors( + colorsToPopulation, + desired: 1, + fallbackColorArgb: unchecked((int)0xFF84B0FD), + filter: false).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(1); + await Assert.That(ranked[0]).IsEqualTo(unchecked((int)0xFF3CAE91)); + } + + [Test] + [DisplayName("Generated scenario nine")] + public async Task Generated_Scenario_Nine() + { + var colorsToPopulation = new Dictionary + { + [unchecked((int)0xFF206F86)] = 52, + [unchecked((int)0xFF4A620D)] = 96, + [unchecked((int)0xFFF51401)] = 85, + [unchecked((int)0xFF2B8EBF)] = 3, + [unchecked((int)0xFF277766)] = 59, + }; + + var ranked = Score.ScoreColors( + colorsToPopulation, + desired: 3, + fallbackColorArgb: unchecked((int)0xFF02B415), + filter: true).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(3); + await Assert.That(ranked[0]).IsEqualTo(unchecked((int)0xFFF51401)); + await Assert.That(ranked[1]).IsEqualTo(unchecked((int)0xFF4A620D)); + await Assert.That(ranked[2]).IsEqualTo(unchecked((int)0xFF2B8EBF)); + } + + [Test] + [DisplayName("Generated scenario ten")] + public async Task Generated_Scenario_Ten() + { + var colorsToPopulation = new Dictionary + { + [unchecked((int)0xFF8B1D99)] = 54, + [unchecked((int)0xFF27EFFE)] = 43, + [unchecked((int)0xFF6F558D)] = 2, + [unchecked((int)0xFF77FDF2)] = 78, + }; + + var ranked = Score.ScoreColors( + colorsToPopulation, + desired: 4, + fallbackColorArgb: unchecked((int)0xFF5E7A10), + filter: true).ToList(); + + await Assert.That(ranked.Count).IsEqualTo(3); + await Assert.That(ranked[0]).IsEqualTo(unchecked((int)0xFF27EFFE)); + await Assert.That(ranked[1]).IsEqualTo(unchecked((int)0xFF8B1D99)); + await Assert.That(ranked[2]).IsEqualTo(unchecked((int)0xFF6F558D)); + } +} diff --git a/tests/MaterialColorUtilities.Tests/TemperatureCacheTests.cs b/tests/MaterialColorUtilities.Tests/TemperatureCacheTests.cs new file mode 100644 index 0000000000..b997efd38c --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/TemperatureCacheTests.cs @@ -0,0 +1,126 @@ +namespace MaterialColorUtilities.Tests; + +public sealed class TemperatureCacheTests +{ + [Test] + [DisplayName("TemperatureCache.rawTemperature")] + public async Task Raw_Temperature() + { + var blueTemp = TemperatureCache.RawTemperature(Hct.FromInt(unchecked((int)0xFF0000FF))); + var redTemp = TemperatureCache.RawTemperature(Hct.FromInt(unchecked((int)0xFFFF0000))); + var greenTemp = TemperatureCache.RawTemperature(Hct.FromInt(unchecked((int)0xFF00FF00))); + var whiteTemp = TemperatureCache.RawTemperature(Hct.FromInt(unchecked((int)0xFFFFFFFF))); + var blackTemp = TemperatureCache.RawTemperature(Hct.FromInt(unchecked((int)0xFF000000))); + + await Assert.That(blueTemp ).IsEqualTo(-1.393).Within(0.001); + await Assert.That(redTemp ).IsEqualTo( 2.351).Within(0.001); + await Assert.That(greenTemp).IsEqualTo(-0.267).Within(0.001); + await Assert.That(whiteTemp).IsEqualTo(-0.5 ).Within(0.001); + await Assert.That(blackTemp).IsEqualTo(-0.5 ).Within(0.001); + } + + [Test] + [DisplayName("TemperatureCache.inputRelativeTemperature")] + public async Task Relative_Temperature() + { + var blue = Hct.FromInt(unchecked((int)0xFF0000FF)); + var red = Hct.FromInt(unchecked((int)0xFFFF0000)); + var green = Hct.FromInt(unchecked((int)0xFF00FF00)); + var white = Hct.FromInt(unchecked((int)0xFFFFFFFF)); + var black = Hct.FromInt(unchecked((int)0xFF000000)); + + var blueTemp = new TemperatureCache(blue ).GetRelativeTemperature(blue); + var redTemp = new TemperatureCache(red ).GetRelativeTemperature(red); + var greenTemp = new TemperatureCache(green).GetRelativeTemperature(green); + var whiteTemp = new TemperatureCache(white).GetRelativeTemperature(white); + var blackTemp = new TemperatureCache(black).GetRelativeTemperature(black); + + await Assert.That(blueTemp ).IsEqualTo(0.000).Within(0.001); + await Assert.That(redTemp ).IsEqualTo(1.000).Within(0.001); + await Assert.That(greenTemp).IsEqualTo(0.467).Within(0.001); + await Assert.That(whiteTemp).IsEqualTo(0.500).Within(0.001); + await Assert.That(blackTemp).IsEqualTo(0.500).Within(0.001); + } + + [Test] + [DisplayName("TemperatureCache.complement")] + public async Task Complement() + { + var blueComp = new TemperatureCache(Hct.FromInt(unchecked((int)0xFF0000FF))).GetComplement().Argb; + var redComp = new TemperatureCache(Hct.FromInt(unchecked((int)0xFFFF0000))).GetComplement().Argb; + var greenComp = new TemperatureCache(Hct.FromInt(unchecked((int)0xFF00FF00))).GetComplement().Argb; + var whiteComp = new TemperatureCache(Hct.FromInt(unchecked((int)0xFFFFFFFF))).GetComplement().Argb; + var blackComp = new TemperatureCache(Hct.FromInt(unchecked((int)0xFF000000))).GetComplement().Argb; + + await Assert.That(blueComp ).IsEqualTo(unchecked((int)0xFF9D0002)); + await Assert.That(redComp ).IsEqualTo(unchecked((int)0xFF007BFC)); + await Assert.That(greenComp).IsEqualTo(unchecked((int)0xFFFFD2C9)); + await Assert.That(whiteComp).IsEqualTo(unchecked((int)0xFFFFFFFF)); + await Assert.That(blackComp).IsEqualTo(unchecked((int)0xFF000000)); + } + + [Test] + [DisplayName("TemperatureCache.analogous")] + public async Task Analogous() + { + // Blue + var blueAnalogous = new TemperatureCache(Hct.FromInt(unchecked((int)0xFF0000FF))) + .GetAnalogousColors() + .Select(h => h.Argb) + .ToList(); + + await Assert.That(blueAnalogous[0]).IsEqualTo(unchecked((int)0xFF00590C)); + await Assert.That(blueAnalogous[1]).IsEqualTo(unchecked((int)0xFF00564E)); + await Assert.That(blueAnalogous[2]).IsEqualTo(unchecked((int)0xFF0000FF)); + await Assert.That(blueAnalogous[3]).IsEqualTo(unchecked((int)0xFF6700CC)); + await Assert.That(blueAnalogous[4]).IsEqualTo(unchecked((int)0xFF81009F)); + + // Red + var redAnalogous = new TemperatureCache(Hct.FromInt(unchecked((int)0xFFFF0000))) + .GetAnalogousColors() + .Select(h => h.Argb) + .ToList(); + + await Assert.That(redAnalogous[0]).IsEqualTo(unchecked((int)0xFFF60082)); + await Assert.That(redAnalogous[1]).IsEqualTo(unchecked((int)0xFFFC004C)); + await Assert.That(redAnalogous[2]).IsEqualTo(unchecked((int)0xFFFF0000)); + await Assert.That(redAnalogous[3]).IsEqualTo(unchecked((int)0xFFD95500)); + await Assert.That(redAnalogous[4]).IsEqualTo(unchecked((int)0xFFAF7200)); + + // Green + var greenAnalogous = new TemperatureCache(Hct.FromInt(unchecked((int)0xFF00FF00))) + .GetAnalogousColors() + .Select(h => h.Argb) + .ToList(); + + await Assert.That(greenAnalogous[0]).IsEqualTo(unchecked((int)0xFFCEE900)); + await Assert.That(greenAnalogous[1]).IsEqualTo(unchecked((int)0xFF92F500)); + await Assert.That(greenAnalogous[2]).IsEqualTo(unchecked((int)0xFF00FF00)); + await Assert.That(greenAnalogous[3]).IsEqualTo(unchecked((int)0xFF00FD6F)); + await Assert.That(greenAnalogous[4]).IsEqualTo(unchecked((int)0xFF00FAB3)); + + // Black → all black + var blackAnalogous = new TemperatureCache(Hct.FromInt(unchecked((int)0xFF000000))) + .GetAnalogousColors() + .Select(h => h.Argb) + .ToList(); + + await Assert.That(blackAnalogous[0]).IsEqualTo(unchecked((int)0xFF000000)); + await Assert.That(blackAnalogous[1]).IsEqualTo(unchecked((int)0xFF000000)); + await Assert.That(blackAnalogous[2]).IsEqualTo(unchecked((int)0xFF000000)); + await Assert.That(blackAnalogous[3]).IsEqualTo(unchecked((int)0xFF000000)); + await Assert.That(blackAnalogous[4]).IsEqualTo(unchecked((int)0xFF000000)); + + // White → all white + var whiteAnalogous = new TemperatureCache(Hct.FromInt(unchecked((int)0xFFFFFFFF))) + .GetAnalogousColors() + .Select(h => h.Argb) + .ToList(); + + await Assert.That(whiteAnalogous[0]).IsEqualTo(unchecked((int)0xFFFFFFFF)); + await Assert.That(whiteAnalogous[1]).IsEqualTo(unchecked((int)0xFFFFFFFF)); + await Assert.That(whiteAnalogous[2]).IsEqualTo(unchecked((int)0xFFFFFFFF)); + await Assert.That(whiteAnalogous[3]).IsEqualTo(unchecked((int)0xFFFFFFFF)); + await Assert.That(whiteAnalogous[4]).IsEqualTo(unchecked((int)0xFFFFFFFF)); + } +} diff --git a/tests/MaterialColorUtilities.Tests/TonalPaletteTests.cs b/tests/MaterialColorUtilities.Tests/TonalPaletteTests.cs new file mode 100644 index 0000000000..921853a485 --- /dev/null +++ b/tests/MaterialColorUtilities.Tests/TonalPaletteTests.cs @@ -0,0 +1,128 @@ +namespace MaterialColorUtilities.Tests; + +public sealed class TonalPaletteTests +{ + private static readonly int[] CommonTones = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 95, 99, 100]; + + private static int[] BuildArgbList(TonalPalette p) => CommonTones.Select(p.Tone).ToArray(); + + [Test] + [DisplayName("[FromHueAndChroma] tones of blue")] + public async Task FromHueAndChroma_Tones_Of_Blue() + { + var hctBlue = Hct.FromInt(unchecked((int)0xFF0000FF)); + var tones = TonalPalette.FromHueAndChroma(hctBlue.Hue, hctBlue.Chroma); + + await Assert.That(tones.Tone(0)).IsEqualTo(unchecked((int)0xFF000000)); + await Assert.That(tones.Tone(10)).IsEqualTo(unchecked((int)0xFF00006E)); + await Assert.That(tones.Tone(20)).IsEqualTo(unchecked((int)0xFF0001AC)); + await Assert.That(tones.Tone(30)).IsEqualTo(unchecked((int)0xFF0000EF)); + await Assert.That(tones.Tone(40)).IsEqualTo(unchecked((int)0xFF343DFF)); + await Assert.That(tones.Tone(50)).IsEqualTo(unchecked((int)0xFF5A64FF)); + await Assert.That(tones.Tone(60)).IsEqualTo(unchecked((int)0xFF7C84FF)); + await Assert.That(tones.Tone(70)).IsEqualTo(unchecked((int)0xFF9DA3FF)); + await Assert.That(tones.Tone(80)).IsEqualTo(unchecked((int)0xFFBEC2FF)); + await Assert.That(tones.Tone(90)).IsEqualTo(unchecked((int)0xFFE0E0FF)); + await Assert.That(tones.Tone(95)).IsEqualTo(unchecked((int)0xFFF1EFFF)); + await Assert.That(tones.Tone(99)).IsEqualTo(unchecked((int)0xFFFFFBFF)); + await Assert.That(tones.Tone(100)).IsEqualTo(unchecked((int)0xFFFFFFFF)); + + // Tone not in Dart's commonTones: 3 + await Assert.That(tones.Tone(3)).IsEqualTo(unchecked((int)0xFF00003C)); + } + + [Test] + [DisplayName("[FromHueAndChroma] asList (common tones)")] + public async Task FromHueAndChroma_AsList_CommonTones() + { + var hctBlue = Hct.FromInt(unchecked((int)0xFF0000FF)); + var tones = TonalPalette.FromHueAndChroma(hctBlue.Hue, hctBlue.Chroma); + + var expected = new[] + { + unchecked((int)0xFF000000), + unchecked((int)0xFF00006E), + unchecked((int)0xFF0001AC), + unchecked((int)0xFF0000EF), + unchecked((int)0xFF343DFF), + unchecked((int)0xFF5A64FF), + unchecked((int)0xFF7C84FF), + unchecked((int)0xFF9DA3FF), + unchecked((int)0xFFBEC2FF), + unchecked((int)0xFFE0E0FF), + unchecked((int)0xFFF1EFFF), + unchecked((int)0xFFFFFBFF), + unchecked((int)0xFFFFFFFF), + }; + + var actual = BuildArgbList(tones); + + // Compare element-wise + await Assert.That(actual.Length).IsEqualTo(expected.Length); + for (int i = 0; i < expected.Length; i++) + await Assert.That(actual[i]).IsEqualTo(expected[i]); + } + + [Test] + [DisplayName("[FromHueAndChroma] equivalence by generated tones (==/hashCode analog)")] + public async Task FromHueAndChroma_Equivalence_By_Tones() + { + var hctAB = Hct.FromInt(unchecked((int)0xFF0000FF)); + var tonesA = TonalPalette.FromHueAndChroma(hctAB.Hue, hctAB.Chroma); + var tonesB = TonalPalette.FromHueAndChroma(hctAB.Hue, hctAB.Chroma); + + var hctC = Hct.FromInt(unchecked((int)0xFF123456)); + var tonesC = TonalPalette.FromHueAndChroma(hctC.Hue, hctC.Chroma); + + var listA = BuildArgbList(tonesA); + var listB = BuildArgbList(tonesB); + var listC = BuildArgbList(tonesC); + + // A equals B functionally + for (int i = 0; i < listA.Length; i++) + await Assert.That(listA[i]).IsEqualTo(listB[i]); + + // B differs from C at least at one tone + bool anyDiff = listB.Where((v, i) => v != listC[i]).Any(); + await Assert.That(anyDiff).IsTrue(); + } + + [Test] + [DisplayName("KeyColor: exact chroma is available")] + public async Task KeyColor_Exact_Chroma() + { + var palette = TonalPalette.FromHueAndChroma(50.0, 60.0); + var result = palette.GetKeyColor(); + + await Assert.That(result.Hue).IsEqualTo(50.0).Within(10.0); + await Assert.That(result.Chroma).IsEqualTo(60.0).Within(0.5); + await Assert.That(result.Tone).IsGreaterThan(0.0); + await Assert.That(result.Tone).IsLessThan(100.0); + } + + [Test] + [DisplayName("KeyColor: requesting unusually high chroma")] + public async Task KeyColor_Unusually_High_Chroma() + { + // For Hue 149, chroma peak ~89.6 — result should approach peak if 200 requested. + var palette = TonalPalette.FromHueAndChroma(149.0, 200.0); + var result = palette.GetKeyColor(); + + await Assert.That(result.Hue).IsEqualTo(149.0).Within(10.0); + await Assert.That(result.Chroma).IsGreaterThan(89.0); + await Assert.That(result.Tone).IsGreaterThan(0.0); + await Assert.That(result.Tone).IsLessThan(100.0); + } + + [Test] + [DisplayName("KeyColor: requesting unusually low chroma")] + public async Task KeyColor_Unusually_Low_Chroma() + { + var palette = TonalPalette.FromHueAndChroma(50.0, 3.0); + var result = palette.GetKeyColor(); + + await Assert.That(result.Hue).IsEqualTo(50.0).Within(10.0); + await Assert.That(result.Chroma).IsEqualTo(3.0).Within(0.5); + await Assert.That(result.Tone).IsEqualTo(50.0).Within(0.5); + } +}