Unicolour

https://unicolour.wacton.xyz
Admin
Comprehensive .NET library for colour space conversion, mixing, blending, comparison, and gamut...
Tokens:13,879
Snippets:171
Trust Score:5.3
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install Unicolour Experimental Package

Source: https://unicolour.wacton.xyz/README_us.html

Install the Unicolour.Experimental package using the .NET CLI.

```bash
dotnet add package Wacton.Unicolour.Experimental

```

--------------------------------

### Install Unicolour Datasets Package

Source: https://unicolour.wacton.xyz/README_us.html

Install the Unicolour.Datasets package using the .NET CLI.

```bash
dotnet add package Wacton.Unicolour.Datasets

```

--------------------------------

### Install Unicolour Package

Source: https://unicolour.wacton.xyz/README_us.html

Shows the command to add the Unicolour NuGet package to your .NET project. This is the first step to using the library.

```bash
dotnet add package Wacton.Unicolour
```

--------------------------------

### Configuration with Predefined Rec. 2020 RGB and D50 XYZ

Source: https://unicolour.wacton.xyz/

Example of creating a Unicolour with predefined Rec. 2020 RGB and Illuminant D50 (2° observer) XYZ configurations.

```csharp
Configuration config = new(RgbConfiguration.Rec2020, XyzConfiguration.D50);
Unicolour colour = new(config, ColourSpace.Rgb255, 204, 64, 132);
```

--------------------------------

### Configuration with Custom Wide-Gamut RGB and D50 XYZ

Source: https://unicolour.wacton.xyz/

Example of creating a Unicolour with manually defined wide-gamut RGB and Illuminant C (10° observer) XYZ, using Von Kries adaptation.

```csharp
var rgbConfig = new RgbConfiguration(
    chromaticityR: new(0.7347, 0.2653),
    chromaticityG: new(0.1152, 0.8264),
    chromaticityB: new(0.1566, 0.0177),
    whitePoint: Illuminant.D50.GetWhitePoint(Observer.Degree2),
    fromLinear: value => Math.Pow(value, 1 / 2.19921875),
    toLinear: value => Math.Pow(value, 2.19921875)
);

var xyzConfig = new XyzConfiguration(Illuminant.C, Observer.Degree10, ChromaticAdaptation.VonKries);

var config = new Configuration(rgbConfig, xyzConfig);
var colour = new Unicolour(config, ColourSpace.Rgb255, 202, 97, 143);
```

--------------------------------

### Convert RGB to WXY

Source: https://unicolour.wacton.xyz/wxy-colour-space.html

Shows how to convert an RGB colour to the WXY colour space using the Unicolour library. This example assumes standard illuminant D65 and a 2° observer.

```javascript
var green = new Unicolour(ColourSpace.Rgb, 0, 1, 0);
Console.WriteLine(green.Wxy); // 549.1nm 73.4% 0.7152
```

--------------------------------

### Default Configuration with sRGB and D65

Source: https://unicolour.wacton.xyz/README_us.html

Utilize the default Unicolour configuration, which uses sRGB as the default RGB model and D65 as the standard illuminant. This provides a consistent starting point for applications.

```csharp
var defaultConfig = new Configuration(RgbConfiguration.StandardRgb, XyzConfiguration.D65);
var color = new Unicolour(defaultConfig, ColourSpace.Rgb255, 192, 255, 238);
```

--------------------------------

### Get Chromaticity and Related Color Properties

Source: https://unicolour.wacton.xyz/README_us.html

Demonstrates accessing various color properties like relative luminance, chromaticity coordinates (xy and uv), dominant wavelength, and color temperature from a Unicolour instance.

```csharp
var equalEnergy = new Unicolour(ColourSpace.Xyz, 0.5, 0.5, 0.5);
Console.WriteLine(equalEnergy.RelativeLuminance);  // 0.5
Console.WriteLine(equalEnergy.Chromaticity.Xy);    // (0.3333, 0.3333)
Console.WriteLine(equalEnergy.Chromaticity.Uv);    // (0.2105, 0.3158)
Console.WriteLine(equalEnergy.Temperature);        // 5455.5 K (Δuv -0.00442)
Console.WriteLine(equalEnergy.DominantWavelength); // 596.1
```

--------------------------------

### Blend Colors with Normal and Screen Modes

Source: https://unicolour.wacton.xyz/README_us.html

Applies blending operations between two Unicolour objects using the source-over compositing operator. Examples show the 'Normal' and 'Screen' blend modes.

```csharp
var blue = new Unicolour(ColourSpace.Rgb, 240, 1.0, 1.0, alpha: 0.5);
var red = new Unicolour(ColourSpace.Rgb, 1.0, 0.0, 0.0);
var purple = blue.Blend(red, BlendMode.Normal);
var pink = blue.Blend(red, BlendMode.Screen);
```

--------------------------------

### Get Wavelength Attributes

Source: https://unicolour.wacton.xyz/README_us.html

Ascertain dominant wavelength and excitation purity of a color using the spectral locus. These can be used to create a color in the WXY color space. Ensure Unicolour and Chromaticity are imported.

```javascript
var chromaticity = new Chromaticity(0.1, 0.8);
var hyperGreen = new Unicolour(chromaticity);
var dominantWavelength = hyperGreen.DominantWavelength;
var excitationPurity = hyperGreen.ExcitationPurity;

var laserRed = new Unicolour(ColourSpace.Wxy, 670, 1.0, 0.5);
```

--------------------------------

### Create Unicolour Instance and Access Oklab

Source: https://unicolour.wacton.xyz/README_us.html

Demonstrates creating a Unicolour instance from a hex string and accessing its Oklab representation. This is useful for working with perceptually uniform color spaces.

```csharp
Unicolour pink = new("#FF1493");
Console.WriteLine(pink.Oklab); // 0.65 +0.26 -0.01
```

--------------------------------

### Convert Between RGB Configurations

Source: https://unicolour.wacton.xyz/README_us.html

Demonstrates converting a color from sRGB to Display P3 and then to Rec. 2020 using Unicolour. Requires initialization of Configuration objects for each target color space.

```csharp
/* pure sRGB green */
var srgbConfig = new Configuration(RgbConfiguration.StandardRgb);
var srgbColor = new Unicolour(srgbConfig, ColourSpace.Rgb, 0, 1, 0);
Console.WriteLine(srgbColour.Rgb); // 0.00 1.00 0.00

/* 
Convert to Display P3 */
var displayP3Config = new Configuration(RgbConfiguration.DisplayP3);
var displayP3Color = srgbColour.ConvertToConfiguration(displayP3Config);
Console.WriteLine(displayP3Colour.Rgb); // 0.46 0.99 0.30

/* 
Convert to Rec. 2020 */
var rec2020Config = new Configuration(RgbConfiguration.Rec2020);
var rec2020Color = displayP3Colour.ConvertToConfiguration(rec2020Config);
Console.WriteLine(rec2020Colour.Rgb); // 0.57 0.96 0.27

```

--------------------------------

### Import Unicolour Experimental Namespace

Source: https://unicolour.wacton.xyz/README_us.html

Import the Wacton.Unicolour.Experimental namespace to use experimental features.

```csharp
using Wacton.Unicolour.Experimental;

```

--------------------------------

### Convert WXY to RGB and Oklab

Source: https://unicolour.wacton.xyz/wxy-colour-space.html

Demonstrates converting a WXY colour to RGB and Oklab colour spaces using the Unicolour library. Ensure the Unicolour library is imported and initialized.

```javascript
var yellow = new Unicolour(ColourSpace.Wxy, 570, 0.75, 0.9);
Console.WriteLine(yellow.Rgb);   // 0.97 0.99 0.19
Console.WriteLine(yellow.Oklab); // 0.96 -0.07 +0.19
```

--------------------------------

### C# Gamut Mapping in WXY

Source: https://unicolour.wacton.xyz/wxy-colour-space.html

Demonstrates how to map an out-of-gamut WXY colour to an in-gamut colour by iteratively reducing its purity. This method preserves the original wavelength and luminance.

```csharp
const double decrement = 0.05; // reduce for greater accuracy

var (w, x, y) = (530, 0.5, 0.7);
var colour = new Unicolour(ColourSpace.Wxy, w, x, y);
while (!colour.IsInRgbGamut)
{
    x -= decrement;
    colour = new Unicolour(ColourSpace.Wxy, w, x, y);
}

Console.WriteLine(colour.Wxy); // 530.0nm 30.0% 0.7000
Console.WriteLine(colour.Hex); // #0FF993

```

--------------------------------

### Create Unicolour Instance with Specific Color Space

Source: https://unicolour.wacton.xyz/README_us.html

Demonstrates creating a Unicolour instance specifying the color space and its components. This allows for precise color initialization.

```csharp
Unicolour color = new(ColourSpace.Rgb255, 192, 255, 238);
```

--------------------------------

### Import Unicolour Datasets Namespace

Source: https://unicolour.wacton.xyz/README_us.html

Import the Wacton.Unicolour.Datasets namespace to access predefined colors and color maps.

```csharp
using Wacton.Unicolour.Datasets;

```

--------------------------------

### Predefined Configuration with Rec. 2020 RGB and D50

Source: https://unicolour.wacton.xyz/README_us.html

Create a configuration using predefined Rec. 2020 RGB and Illuminant D50 (2° observer) XYZ settings. This is suitable for applications requiring specific color standards.

```csharp
Configuration config = new(RgbConfiguration.Rec2020, XyzConfiguration.D50);
Unicolour color = new(config, ColourSpace.Rgb255, 204, 64, 132);
```

--------------------------------

### Custom Configuration with Wide-gamut RGB and Illuminant C

Source: https://unicolour.wacton.xyz/README_us.html

Define a custom configuration for wide-gamut RGB and Illuminant C (10° observer) XYZ, including Von Kries white point adaptation. This allows for precise control over color space definitions.

```csharp
var rgbConfig = new RgbConfiguration(
    chromaticityR: new(0.7347, 0.2653),
    chromaticityG: new(0.1152, 0.8264),
    chromaticityB: new(0.1566, 0.0177),
    whitePoint: Illuminant.D50.GetWhitePoint(Observer.Degree2),
    fromLinear: value => Math.Pow(value, 1 / 2.19921875),
    toLinear: value => Math.Pow(value, 2.19921875)
);

var xyzConfig = new XyzConfiguration(Illuminant.C, Observer.Degree10, ChromaticAdaptation.VonKries);

var config = new Configuration(rgbConfig, xyzConfig);
var color = new Unicolour(config, ColourSpace.Rgb255, 202, 97, 143);
```

--------------------------------

### Convert RGB to Oklch

Source: https://unicolour.wacton.xyz/README_us.html

Demonstrates converting an RGB color to the Oklch color space. Ensure the Unicolour library is imported.

```csharp
Unicolour color = new(ColourSpace.Rgb255, 192, 255, 238);
var (l, c, h) = color.Oklch;
```

--------------------------------

### Import Unicolour Namespace

Source: https://unicolour.wacton.xyz/README_us.html

Illustrates how to import the Unicolour namespace into your C# code. This is necessary to use the library's classes and methods.

```csharp
using Wacton.Unicolour;
```

--------------------------------

### Convert RGB color between different configurations

Source: https://unicolour.wacton.xyz/

Demonstrates converting a pure sRGB green color to Display P3 and then to Rec. 2020 configurations. Requires Unicolour library and specific RGB configuration objects.

```javascript
/* pure sRGB green */
var srgbConfig = new Configuration(RgbConfiguration.StandardRgb);
var srgbColour = new Unicolour(srgbConfig, ColourSpace.Rgb, 0, 1, 0);
Console.WriteLine(srgbColour.Rgb); // 0.00 1.00 0.00

/* 	Display P3 */
var displayP3Config = new Configuration(RgbConfiguration.DisplayP3);
var displayP3Colour = srgbColour.ConvertToConfiguration(displayP3Config);
Console.WriteLine(displayP3Colour.Rgb); // 0.46 0.99 0.30

/* 	Rec. 2020 */
var rec2020Config = new Configuration(RgbConfiguration.Rec2020);
var rec2020Colour = displayP3Colour.ConvertToConfiguration(rec2020Config);
Console.WriteLine(rec2020Colour.Rgb); // 0.57 0.96 0.27

```

--------------------------------

### Reference Predefined Unicolour Colors and Color Maps

Source: https://unicolour.wacton.xyz/README_us.html

Access predefined colors from CSS, xkcd, and color maps like Viridis and Turbo.

```csharp
var pink = Css.DeepPink;
var green = Xkcd.NastyGreen;
var mapped = Colourmaps.Viridis.Map(0.5);
var palette = Colourmaps.Turbo.Palette(10);

```

--------------------------------

### Compare Colors with Contrast and Difference

Source: https://unicolour.wacton.xyz/README_us.html

Calculate the contrast and difference between two colors using specified delta E metrics. Ensure Unicolour and ColourSpace are imported.

```javascript
var red = new Unicolour(ColourSpace.Rgb, 1.0, 0.0, 0.0);
var blue = new Unicolour(ColourSpace.Hsb, 240, 1.0, 1.0);
var contrast = red.Contrast(blue);
var difference = red.Difference(blue, DeltaE.Cie76);
```

--------------------------------

### Approximate Pigments from Color

Source: https://unicolour.wacton.xyz/README_us.html

Generate a single-constant pigment approximation from a given color, enabling pigment mixing without reflectance measurements.

```csharp
var redPigment = PigmentGenerator.From(new Unicolour("#FF0000"));
var bluePigment = PigmentGenerator.From(new Unicolour("#0000FF"));
var magenta = new Unicolour([redPigment, bluePigment], [0.5, 0.5]);

```

--------------------------------

### Convert Color to HSL

Source: https://unicolour.wacton.xyz/README_us.html

Shows how to create a Unicolour instance from a hex string and then access its HSL representation. Useful for understanding color hue, saturation, and lightness.

```csharp
var cyan = new Unicolour("#00FFFF");
Console.WriteLine(cyan.Hsl); // 180.0° 100.0% 50.0%
```

--------------------------------

### Generate Colour Wheel and Harmonies

Source: https://unicolour.wacton.xyz/

Create a colour wheel from pigments or a colour space and generate harmonious colour combinations.

```csharp
/* populate pigment k and s with measurement data */
var quinaRed = new Pigment(380, 1, k: [], s: []);
var bismuthYellow = new Pigment(380, 1, k: [], s: []);
var ceruleanBlue = new Pigment(380, 1, k: [], s: []);
var titaniumWhite = new Pigment(380, 1, k: [], s: []);
var boneBlack = new Pigment(380, 1, k: [], s: []);

var colourWheel = usePigments 
    ? ColourWheel.From(quinaRed, bismuthYellow, ceruleanBlue, titaniumWhite, boneBlack)
    : ColourWheel.From(ColourSpace.Oklch, reference: new Unicolour("ff0000"));

var orange = colourWheel.Pure(hue: 60);
var lightGreen = colourWheel.Tint(hue: 180, weight: 1);
var darkPurple = colourWheel.Shade(hue: 300, weight: 1);
var greyRed = colourWheel.Tone(hue: 0, weight: 1);

var orangePalette = colourWheel.Harmony(hue: 60, Harmony.Analogous);

```

--------------------------------

### Convert Color to Hex

Source: https://unicolour.wacton.xyz/README_us.html

Demonstrates creating a Unicolour instance from specified RGB values and then accessing its Hexadecimal representation. Useful for web and CSS color formats.

```csharp
var yellow = new Unicolour(ColourSpace.Rgb255, 255, 255, 0);
Console.WriteLine(yellow.Hex); // #FFFF00
```

--------------------------------

### Model Pigment and Paint Colors

Source: https://unicolour.wacton.xyz/README_us.html

Combine pigments using the Kubelka-Munk theory to simulate natural paint mixing. Requires pigment measurement data for absorption (k) and scattering (s) coefficients.

```csharp
/* populate k and s with measurement data */
var phthaloBlue = new Pigment(startWavelength: 380, wavelengthInterval: 10, k: [], s: []);
var hansaYellow = new Pigment(startWavelength: 380, wavelengthInterval: 10, k: [], s: []);
var green = new Unicolour(pigments: [phthaloBlue, hansaYellow], weights: [0.5, 0.5]);
```

--------------------------------

### Generate Color Wheel and Harmonies

Source: https://unicolour.wacton.xyz/README_us.html

Create a color wheel from pigments or a hued color space and generate color harmonies like analogous, complementary, and triadic.

```csharp
/* populate pigment k and s with measurement data */
var quinaRed = new Pigment(380, 1, k: [], s: []);
var bismuthYellow = new Pigment(380, 1, k: [], s: []);
var ceruleanBlue = new Pigment(380, 1, k: [], s: []);
var titaniumWhite = new Pigment(380, 1, k: [], s: []);
var boneBlack = new Pigment(380, 1, k: [], s: []);

var colorWheel = usePigments 
    ? ColourWheel.From(quinaRed, bismuthYellow, ceruleanBlue, titaniumWhite, boneBlack)
    : ColourWheel.From(ColourSpace.Oklch, reference: new Unicolour("ff0000"));

var orange = colorWheel.Pure(hue: 60);
var lightGreen = colorWheel.Tint(hue: 180, weight: 1);
var darkPurple = colorWheel.Shade(hue: 300, weight: 1);
var greyRed = colorWheel.Tone(hue: 0, weight: 1);

var orangePalette = colorWheel.Harmony(hue: 60, Harmony.Analogous);

```

--------------------------------

### Generate Color Palette

Source: https://unicolour.wacton.xyz/README_us.html

Demonstrates generating a palette of 5 colors by interpolating between two Unicolour instances (red and blue) in the HSL color space. Useful for creating color schemes.

```csharp
// #FF0000, #FF0080, #FF00FF, #8000FF, #0000FF
var palette = red.Palette(blue, ColourSpace.Hsl, 5);
Console.WriteLine(palette.Select(colour => color.Hex));
```

--------------------------------

### Derive Temperature Metrics

Source: https://unicolour.wacton.xyz/README_us.html

Derive correlated color temperature (CCT) and delta UV (∆uv) from a color, and create colors from temperature metrics. Ensure Unicolour and Chromaticity are imported.

```javascript
var chromaticity = new Chromaticity(0.3457, 0.3585);
var d50 = new Unicolour(chromaticity);
var (cct, duv) = d50.Temperature;

var temperature = new Temperature(6504, 0.0032);
var d65 = new Unicolour(temperature);
var (x, y) = d65.Chromaticity;
```

--------------------------------

### Mix Achromatic Colors with Hue Control

Source: https://unicolour.wacton.xyz/README_us.html

Demonstrates mixing achromatic colors, showing how hue is handled when one of the colors is achromatic. The hue can either be preserved or ignored based on the input.

```csharp
var yellow = new Unicolour(ColourSpace.Hsb, 60, 1, 1);

// hue moves 50% from 60° to 240° = 150°
var blackWithBlueHue = new Unicolour(ColourSpace.Hsb, 240, 0, 0);
var darkGreen = yellow.Mix(blackWithBlueHue, ColourSpace.Hsb);

// hue stays at 60°
var blackWithNoHue = new Unicolour(ColourSpace.Hsb, grey: 0);
var darkYellow = yellow.Mix(blackWithNoHue, ColourSpace.Hsb);
```

--------------------------------

### Access Colorimetric Components

Source: https://unicolour.wacton.xyz/README_us.html

Access and create colors using colorimetric components like chromaticity and relative luminance. Ensure Unicolour and ColourSpace are imported.

```javascript
var gray = new Unicolour(ColourSpace.RgbLinear, 0.5, 0.5, 0.5);
var chromaticity = gray.Chromaticity;
var luminance = gray.RelativeLuminance;

var white = new Unicolour(chromaticity, luminance: 1.0);
```

--------------------------------

### Create Colour from Spectral Power Distribution

Source: https://unicolour.wacton.xyz/

Create a Unicolour object from a spectral power distribution (SPD). Wavelengths should be provided in 1 nm or 5 nm intervals.

```javascript
/* [575 nm] -> 0.5 
 * [580 nm] -> 1.0 
 * [585 nm] -> 0.5 */
var spd = new Spd(start: 575, interval: 5, coefficients: [0.5, 1.0, 0.5]);
var intenseYellow = new Unicolour(spd);
```

--------------------------------

### Create Achromatic Unicolour

Source: https://unicolour.wacton.xyz/README_us.html

Initializes a Unicolour object with an achromatic (grayscale) value. This is useful for creating shades of gray.

```csharp
Unicolour gray = new(ColourSpace.Rgb, 0.5);
var hex = gray.Hex; // #808080
```

--------------------------------

### Interpret Spectral Power Distributions

Source: https://unicolour.wacton.xyz/README_us.html

Create a color from a spectral power distribution (SPD), providing wavelengths in 1 nm or 5 nm intervals. Ensure Spd is imported.

```javascript
/* [575 nm] -> 0.5 Â· [580 nm] -> 1.0 Â· [585 nm] -> 0.5 */
var spd = new Spd(start: 575, interval: 5, coefficients: [0.5, 1.0, 0.5]);
var intenseYellow = new Unicolour(spd);
```

--------------------------------

### Calculate Color Difference using Delta E

Source: https://unicolour.wacton.xyz/README_us.html

Shows how to calculate the difference between two Unicolour instances (white and black) using the CIEDE2000 delta E metric. Useful for comparing color similarity.

```csharp
var white = new Unicolour(ColourSpace.Oklab, 1.0, 0.0, 0.0);
var black = new Unicolour(ColourSpace.Oklab, 0.0, 0.0, 0.0);
var difference = white.Difference(black, DeltaE.Ciede2000);
Console.WriteLine(difference); // 100.0000
```

--------------------------------

### Construct Achromatic Color

Source: https://unicolour.wacton.xyz/

Illustrates creating an achromatic color (grayscale) using a single value. The hex output will represent the corresponding grayscale color.

```csharp
Unicolour grey = new(ColourSpace.Rgb, 0.5);
var hex = grey.Hex; // #808080
```

--------------------------------

### Create Munsell Color

Source: https://unicolour.wacton.xyz/README_us.html

Initializes a Unicolour object using Munsell color attributes. Requires converting Munsell hue notation to degrees using Hue.FromMunsell().

```csharp
Unicolour pink = new(ColourSpace.Munsell, Hue.FromMunsell(6.1, "RP"), 5.5, 19.5);
Console.WriteLine(pink.Munsell); // 6.1RP 5.5/19.5
```

--------------------------------

### Purity-Reduction Gamut Mapping in C#

Source: https://unicolour.wacton.xyz/wxy-colour-space_us.html

This snippet demonstrates how to map an out-of-gamut WXY color to an in-gamut color by iteratively reducing its purity. It shows how to check if a color is within the sRGB gamut and how to retrieve the mapped color's WXY and Hex values.

```csharp
const double decrement = 0.05; // reduce for greater accuracy

var (w, x, y) = (530, 0.5, 0.7);
var color = new Unicolour(ColourSpace.Wxy, w, x, y);
while (!color.IsInRgbGamut)
{
    x -= decrement;
    color = new Unicolour(ColourSpace.Wxy, w, x, y);
}

Console.WriteLine(color.Wxy); // 530.0nm 30.0% 0.7000
Console.WriteLine(color.Hex); // #0FF993

```

--------------------------------

### Emulate Spectral.js Pigment Mixing

Source: https://unicolour.wacton.xyz/README_us.html

Mix colors using a method that emulates Spectral.js, adjusting concentrations based on luminance and a custom weighting curve. This allows for mixing more than two colors.

```csharp
var blue = new Unicolour("#0000FF");
var yellow = new Unicolour("#FFFF00");
var green = SpectralJs.Mix([blue, yellow], [0.5, 0.5]);
var palette = SpectralJs.Palette(blue, yellow, 9);

```

--------------------------------

### Use ICC Profiles for CMYK Conversion

Source: https://unicolour.wacton.xyz/README_us.html

Convert colors using ICC profiles for device-dependent CMYK output. Supports various profile versions and device classes. Falls back to naive conversion if profiles are incompatible or not provided.

```csharp
using Wacton.Unicolour.Icc;

var fogra39 = new IccConfiguration("./Fogra39.icc", Intent.RelativeColorimetric);
var config = new Configuration(iccConfig: fogra39);

var navyRgb = new Unicolour(config, ColourSpace.Rgb255, 0, 0, 128);
Console.WriteLine(navyRgb.Icc); // 1.0000 0.8977 0.0001 0.2867 CMYK

var navyCmyk = new Unicolour(config, new Channels(1.0, 1.0, 0.0, 0.5));
Console.WriteLine(navyCmyk.Rgb.Byte255); // 46 37 87
```

--------------------------------

### Mix Colors in RGB Color Space

Source: https://unicolour.wacton.xyz/README_us.html

Illustrates mixing two Unicolour instances (red and blue) in the RGB color space. This is useful for creating intermediate colors.

```csharp
var red = new Unicolour(ColourSpace.Rgb, 1.0, 0.0, 0.0);
var blue = new Unicolour(ColourSpace.Hsb, 240, 1.0, 1.0);

/* RGB: [1, 0, 0] ⟶ [0, 0, 1] = [0.5, 0, 0.5] */
var purple = red.Mix(blue, ColourSpace.Rgb);
Console.WriteLine(purple.Rgb); // 0.50 0.00 0.50
Console.WriteLine(purple.Hex); // #800080
```

--------------------------------

### Access Colorimetric Components

Source: https://unicolour.wacton.xyz/

Access and utilize colorimetric components like chromaticity and relative luminance to create new colors. Useful for precise color manipulation.

```javascript
var grey = new Unicolour(ColourSpace.RgbLinear, 0.5, 0.5, 0.5);
var chromaticity = grey.Chromaticity;
var luminance = grey.RelativeLuminance;

var white = new Unicolour(chromaticity, luminance: 1.0);
```

--------------------------------

### Mix colors in RGB and HSL

Source: https://unicolour.wacton.xyz/

Mix two colors using different color spaces (RGB and HSL) and display the resulting color's RGB and Hex values.

```csharp
var red = new Unicolour(ColourSpace.Rgb, 1.0, 0.0, 0.0);
var blue = new Unicolour(ColourSpace.Hsb, 240, 1.0, 1.0);

/* RGB: [1, 0, 0] ⟶ [0, 0, 1] = [0.5, 0, 0.5] */
var purple = red.Mix(blue, ColourSpace.Rgb);
Console.WriteLine(purple.Rgb); // 0.50 0.00 0.50
Console.WriteLine(purple.Hex); // #800080

/* HSL: [0, 1, 0.5] ⟶ [240, 1, 0.5] = [300, 1, 0.5] */
var magenta = red.Mix(blue, ColourSpace.Hsl);
Console.WriteLine(magenta.Rgb); // 1.00 0.00 1.00
Console.WriteLine(magenta.Hex); // #FF00FF
```

--------------------------------

### Create Unicolour from Hex String

Source: https://unicolour.wacton.xyz/README_us.html

Constructs a Unicolour object directly from a hexadecimal color string. The resulting color is in the RGB255 color space.

```csharp
Unicolour pink = new("ff1493");
var hex = pink.Hex; // #FF1493
```

--------------------------------

### Mix Colors in HSL Color Space

Source: https://unicolour.wacton.xyz/README_us.html

Shows mixing two Unicolour instances (red and blue) in the HSL color space. This demonstrates color mixing across different color representations.

```csharp
/* HSL: [0, 1, 0.5] ⟶ [240, 1, 0.5] = [300, 1, 0.5] */
var magenta = red.Mix(blue, ColourSpace.Hsl);
Console.WriteLine(magenta.Rgb); // 1.00 0.00 1.00
Console.WriteLine(magenta.Hex); // #FF00FF
```

--------------------------------

### Map Color to RGB Gamut

Source: https://unicolour.wacton.xyz/README_us.html

Map a color to the closest in-gamut RGB color. This can be done by clipping, reducing chroma, or reducing purity. Ensure Unicolour and ColourSpace are imported.

```javascript
var veryRed = new Unicolour(ColourSpace.Rgb, 1.25, -0.39, -0.14);

var isDisplayable = veryRed.IsInRgbGamut;
var displayRed = veryRed.MapToRgbGamut();

var isEmpiricalSurface = veryRed.IsInPointerGamut;
var empiricalRed = veryRed.MapToPointerGamut();

var isTheoreticalSurface = veryRed.IsInMacAdamLimits;
var theoreticalRed = veryRed.MapToMacAdamLimits();
```

--------------------------------

### Handle Invalid Values Safely

Source: https://unicolour.wacton.xyz/README_us.html

Propagate invalid or unreasonable numerical values (like NaN, Infinity) through calculations without causing exceptions. Useful for handling potential conversion limitations or user input errors.

```csharp
var bad1 = new Unicolour(ColourSpace.Oklab, double.NegativeInfinity, double.NaN, double.Epsilon);
var bad2 = new Unicolour(ColourSpace.Cam16, double.NaN, double.MaxValue, double.MinValue);
var bad3 = bad1.Mix(bad2, ColourSpace.Hct, amount: double.PositiveInfinity);
```

--------------------------------

### Simulate Color Vision Deficiency (CVD)

Source: https://unicolour.wacton.xyz/

Simulate how a color might be perceived by individuals with different types of color vision deficiency. Supports anomalous trichromacy with a severity adjustment.

```javascript
var colour = new Unicolour(ColourSpace.Rgb255, 192, 255, 238);
var missingRed = colour.Simulate(Cvd.Protanopia);
var defectiveRed = colour.Simulate(Cvd.Protanomaly, 0.5);
```

--------------------------------

### Detect Imaginary Colors

Source: https://unicolour.wacton.xyz/README_us.html

Detect imaginary colors, which are mathematically possible but lie outside the spectral locus of the CIE xy chromaticity diagram. Ensure Unicolour and Chromaticity are imported.

```javascript
var chromaticity = new Chromaticity(0.05, 0.05);
var impossibleBlue = new Unicolour(chromaticity);
var isImaginary = impossibleBlue.IsImaginary;
```

--------------------------------

### Simulate Color Vision Deficiency

Source: https://unicolour.wacton.xyz/README_us.html

Simulate various types of color vision deficiency (CVD), including anomalous trichromacy with adjustable severity. Ensure Unicolour and Cvd are imported.

```javascript
var color = new Unicolour(ColourSpace.Rgb255, 192, 255, 238);
var missingRed = color.Simulate(Cvd.Protanopia);
var defectiveRed = color.Simulate(Cvd.Protanomaly, 0.5);
```

--------------------------------

### Mix Colors in HSL Space

Source: https://unicolour.wacton.xyz/README_us.html

Blends two Unicolour objects in the HSL color space with specified hue span and interpolation distance. The palette function generates a series of intermediate colors.

```csharp
var red = new Unicolour(ColourSpace.Rgb, 1.0, 0.0, 0.0, alpha: 1.0);
var blue = new Unicolour(ColourSpace.Hsb, 240, 1.0, 1.0, alpha: 1.0);
var magenta = red.Mix(blue, ColourSpace.Hsl, 0.5, HueSpan.Decreasing);
var green = red.Mix(blue, ColourSpace.Hsl, 0.5, HueSpan.Increasing);
var palette = red.Palette(blue, ColourSpace.Hsl, 10, HueSpan.Longer);
```
Tokens:
Raw