Trait IColor 

pub trait IColor: Sized + ToColor<Self::Component> {
    type Component: Primitive;

    const TRANSPARENT: Self;
    const BLACK: Self;
    const GREY: Self;
    const WHITE: Self;
    const RED: Self;
    const GREEN: Self;
    const BLUE: Self;
    const CYAN: Self;
    const MAGENTA: Self;
    const YELLOW: Self;
    const SPRING: Self;
    const AZURE: Self;
    const VIOLET: Self;
    const ROSE: Self;
    const ORANGE: Self;
    const LIME: Self;
    const CANARY: Self;
    const PINK: Self;
    const GLACE: Self;

    // Required methods
    fn to_rgba_of<R>(self) -> RgbaOf<R>
       where R: Primitive + CastRangeFrom<Self::Component>;
    fn to_hsla_of<R>(self) -> HslaOf<R>
       where R: Float + CastRangeFrom<Self::Component>;
    fn from_rgba_u8(rgba: RgbaOf<u8>) -> Self;
    fn from_rgba_u16(rgba: RgbaOf<u16>) -> Self;
    fn from_rgba_f32(rgba: RgbaOf<f32>) -> Self;
    fn from_rgba_f64(rgba: RgbaOf<f64>) -> Self;
    fn from_rgba_float(rgba: RgbaOf<f32>) -> Self;
}

Constant color name are based on https://colornames.org/

(+-1 u8 unit per channel, otherwise #FF7F00 should be named Orange Juice and not Orange, because Orange is #FF7F00)

Required Associated Constants

const TRANSPARENT: Self

const BLACK: Self

#000000

⬛ : ⬛⬛⬛

const GREY: Self

#777777

If you preferer the name Gray, just do :

use hexga_image::prelude::*;
use hexga_math::prelude::*;

pub trait IPreferGray
{
   const GRAY : Self;
}
impl<C> IPreferGray for C where C: IColor
{
   const GRAY : Self = Self::GREY;
}

const WHITE: Self

#FFFFFF

⬜ : 🟥🟩🟦

const RED: Self

#FF0000

🟥 : 🟥⬛⬛

const GREEN: Self

#00FF00

🟩 : ⬛🟩⬛

const BLUE: Self

#0000FF

🟦 : ⬛⬛🟦

const CYAN: Self

#00FFFF

_ : ⬛🟩🟦

const MAGENTA: Self

#FF00FF

_ : 🟥⬛🟦

const YELLOW: Self

#FFFF00

🟨 : 🟥🟩⬛

const SPRING: Self

#00FF7F

const AZURE: Self

#007FFF

const VIOLET: Self

#7F00FF

const ROSE: Self

#FF007F

const ORANGE: Self

#FF7F00

const LIME: Self

#7FFF00

const CANARY: Self

#FFFF7F

const PINK: Self

#FF7FFF

const GLACE: Self

#7FFFFF

Required Associated Types

type Component: Primitive

Required Methods

fn to_rgba_of<R>(self) -> RgbaOf<R>

where R: Primitive + CastRangeFrom<Self::Component>,

fn to_hsla_of<R>(self) -> HslaOf<R>

where R: Float + CastRangeFrom<Self::Component>,

fn from_rgba_u8(rgba: RgbaOf<u8>) -> Self

fn from_rgba_u16(rgba: RgbaOf<u16>) -> Self

fn from_rgba_f32(rgba: RgbaOf<f32>) -> Self

fn from_rgba_f64(rgba: RgbaOf<f64>) -> Self

fn from_rgba_float(rgba: RgbaOf<f32>) -> Self

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<T> IColor for HslaOf<T>

where T: Float,

const TRANSPARENT: HslaOf<T>

const BLACK: HslaOf<T>

const GREY: HslaOf<T>

const WHITE: HslaOf<T>

const RED: HslaOf<T>

const GREEN: HslaOf<T>

const BLUE: HslaOf<T>

const CYAN: HslaOf<T>

const MAGENTA: HslaOf<T>

const YELLOW: HslaOf<T>

const SPRING: HslaOf<T>

const AZURE: HslaOf<T>

const VIOLET: HslaOf<T>

const ROSE: HslaOf<T>

const ORANGE: HslaOf<T>

const LIME: HslaOf<T>

const CANARY: HslaOf<T>

const PINK: HslaOf<T>

const GLACE: HslaOf<T>

type Component = T

impl<T> IColor for RgbaOf<T>

where T: Primitive,

const TRANSPARENT: RgbaOf<T>

const BLACK: RgbaOf<T>

const GREY: RgbaOf<T>

const WHITE: RgbaOf<T>

const RED: RgbaOf<T>

const GREEN: RgbaOf<T>

const BLUE: RgbaOf<T>

const CYAN: RgbaOf<T>

const MAGENTA: RgbaOf<T>

const YELLOW: RgbaOf<T>

const SPRING: RgbaOf<T>

const AZURE: RgbaOf<T>

const VIOLET: RgbaOf<T>

const ROSE: RgbaOf<T>

const ORANGE: RgbaOf<T>

const LIME: RgbaOf<T>

const CANARY: RgbaOf<T>

const PINK: RgbaOf<T>

const GLACE: RgbaOf<T>

type Component = T