Trait ansi_colours::AsRGB
source · pub trait AsRGB {
fn as_u32(&self) -> u32;
fn to_ansi256(&self) -> u8 { ... }
}
Expand description
Type which (can) represent an sRGB colour. Used to provide overloaded
versions of ansi256_from_rgb
function.
Required Methods§
Provided Methods§
sourcefn to_ansi256(&self) -> u8
fn to_ansi256(&self) -> u8
Returns index of a colour in 256-colour ANSI palette approximating given sRGB colour.
This is provided by default and uses Self::as_u32
to determine
24-bit sRGB representation of the colour.
An implementation should provide its own definition if it can offer
a more direct approximation. For example, if Self
represents shades
of grey, it’s faster to use ansi256_from_grey
than relay on to_u32
conversion; or if it represents a variant which can store index in the
palette or an RGB colour, it’s better to either return the index or
perform approximation depending on the variant.
Examples found in repository?
More examples
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
fn to_ansi256(&self) -> u8 {
match self.clone() {
Self::Black => 0,
Self::Red => 1,
Self::Green => 2,
Self::Yellow => 3,
Self::Blue => 4,
Self::Purple => 5,
Self::Cyan => 6,
Self::White => 7,
Self::Fixed(idx) => idx,
Self::RGB(r, g, b) => (r, g, b).to_ansi256(),
}
}
}
#[cfg(feature = "ansi_term")]
impl super::ColourExt for ansi_term::Colour {
/// Constructs a `Fixed` colour which approximates given sRGB colour.
///
/// This implementation is present only if `ansi_term` crate feature is
/// enabled.
///
/// # Examples
///
/// ```
/// use ansi_colours::ColourExt;
/// use ansi_term::Colour;
///
/// assert_eq!(Colour::Fixed( 16), Colour::approx_rgb( 0, 0, 0));
/// assert_eq!(Colour::Fixed( 16), Colour::approx_rgb( 0, 1, 2));
/// assert_eq!(Colour::Fixed( 67), Colour::approx_rgb( 95, 135, 175));
/// assert_eq!(Colour::Fixed(231), Colour::approx_rgb(255, 255, 255));
/// ```
#[inline]
fn approx_rgb(r: u8, g: u8, b: u8) -> Self {
Self::Fixed(ansi256_from_rgb((r, g, b)))
}
/// Converts the colour into 256-colour-compatible format.
///
/// If the colour represents an RGB colour, converts it into a `Fixed`
/// variant using [`ansi256_from_rgb`] function. Otherwise, returns the
/// colour unchanged.
///
/// This implementation is present only if `ansi_term` crate feature is
/// enabled.
///
/// # Examples
///
/// ```
/// use ansi_colours::ColourExt;
/// use ansi_term::Colour;
///
/// assert_eq!(Colour::Red, Colour::Red.to_256());
/// assert_eq!(Colour::Fixed( 11), Colour::Fixed(11).to_256());
/// assert_eq!(Colour::Fixed( 16), Colour::RGB( 0, 0, 0).to_256());
/// assert_eq!(Colour::Fixed( 16), Colour::RGB( 0, 1, 2).to_256());
/// assert_eq!(Colour::Fixed( 67), Colour::RGB( 95, 135, 175).to_256());
/// assert_eq!(Colour::Fixed(231), Colour::RGB(255, 255, 255).to_256());
/// ```
#[inline]
fn to_256(&self) -> Self {
if let Self::RGB(r, g, b) = self {
Self::Fixed(ansi256_from_rgb((*r, *g, *b)))
} else {
*self
}
}
/// Converts the colour into sRGB.
///
/// Named colours (`Black`, `Red` etc. through `White`) are treated like
/// `Fixed` colours with indexes 0 through 7. `Fixed` colours are converted
/// into sRGB using [`rgb_from_ansi256`] function. `RGB` colours are
/// returned unchanged.
///
/// This implementation is present only if `ansi_term` crate feature is
/// enabled.
///
/// # Examples
///
/// ```
/// use ansi_colours::ColourExt;
/// use ansi_term::Colour;
///
/// assert_eq!(( 0, 0, 0), Colour::Fixed( 16).to_rgb());
/// assert_eq!(( 95, 135, 175), Colour::Fixed( 67).to_rgb());
/// assert_eq!((255, 255, 255), Colour::Fixed(231).to_rgb());
/// assert_eq!((238, 238, 238), Colour::Fixed(255).to_rgb());
/// assert_eq!(( 42, 24, 0), Colour::RGB(42, 24, 0).to_rgb());
/// ```
#[inline]
fn to_rgb(&self) -> (u8, u8, u8) {
let idx = match self.clone() {
Self::Black => 0,
Self::Red => 1,
Self::Green => 2,
Self::Yellow => 3,
Self::Blue => 4,
Self::Purple => 5,
Self::Cyan => 6,
Self::White => 7,
Self::Fixed(idx) => idx,
Self::RGB(r, g, b) => return (r, g, b),
};
rgb_from_ansi256(idx)
}
}
#[cfg(feature = "termcolor")]
impl AsRGB for termcolor::Color {
/// Returns sRGB colour corresponding to escape code represented by
/// [`termcolor::Color`].
///
/// Behaves slightly differently depending on the variant of the enum.
/// - For named colour variants (`Black`, `Red` etc. up till `White`),
/// returns corresponding system colour with indexes going from 0 to 7.
/// - Similarly, for `Ansi256` variant returns colour corresponding to
/// specified index. See [`rgb_from_ansi256`](`rgb_from_ansi256`).
/// - Lastly, for `Rgb` variant converts it to 24-bit `0xRRGGBB`
/// representation.
///
/// This implementation is present only if `termcolor` crate feature is
/// enabled.
#[inline]
fn as_u32(&self) -> u32 {
match self.clone() {
Self::Black => ansi256::ANSI_COLOURS[0],
Self::Blue => ansi256::ANSI_COLOURS[4],
Self::Green => ansi256::ANSI_COLOURS[2],
Self::Red => ansi256::ANSI_COLOURS[1],
Self::Cyan => ansi256::ANSI_COLOURS[6],
Self::Magenta => ansi256::ANSI_COLOURS[5],
Self::Yellow => ansi256::ANSI_COLOURS[3],
Self::White => ansi256::ANSI_COLOURS[7],
Self::Ansi256(idx) => ansi256::ANSI_COLOURS[idx as usize],
Self::Rgb(r, g, b) => (r, g, b).as_u32(),
_ => unreachable!(),
}
}
/// Returns index of a colour in 256-colour ANSI palette approximating given
/// sRGB colour.
///
/// Behaves slightly differently depending on the variant of the enum.
/// - For named colour variants (`Black`, `Red` etc. up till `White`),
/// returns index going from 0 to 7.
/// - For `Ansi256` variant simply returns index encoded in the variant.
/// - Lastly, for `Rgb` variant, approximates the colour and returns index
/// of closest colour in 256-colour palette.
///
/// This implementation is present only if `termcolor` crate feature is
/// enabled.
///
/// # Examples
///
/// ```
/// use ansi_colours::AsRGB;
///
/// assert_eq!( 0, termcolor::Color::Black.to_ansi256());
/// assert_eq!( 7, termcolor::Color::White.to_ansi256());
/// assert_eq!( 42, termcolor::Color::Ansi256(42).to_ansi256());
/// assert_eq!( 16, termcolor::Color::Rgb( 0, 0, 0).to_ansi256());
/// assert_eq!( 16, termcolor::Color::Rgb( 1, 1, 1).to_ansi256());
/// assert_eq!( 16, termcolor::Color::Rgb( 0, 1, 2).to_ansi256());
/// assert_eq!( 67, termcolor::Color::Rgb( 95, 135, 175).to_ansi256());
/// assert_eq!(231, termcolor::Color::Rgb(255, 255, 255).to_ansi256());
/// ```
#[inline]
fn to_ansi256(&self) -> u8 {
match self.clone() {
Self::Black => 0,
Self::Blue => 4,
Self::Green => 2,
Self::Red => 1,
Self::Cyan => 6,
Self::Magenta => 5,
Self::Yellow => 3,
Self::White => 7,
Self::Ansi256(idx) => idx,
Self::Rgb(r, g, b) => (r, g, b).to_ansi256(),
_ => unreachable!(),
}
}
Implementations on Foreign Types§
source§impl<C: Component> AsRGB for RGB<C>
impl<C: Component> AsRGB for RGB<C>
source§fn as_u32(&self) -> u32
fn as_u32(&self) -> u32
Returns representation of the sRGB colour as a 24-bit 0xRRGGBB
integer.
This implementation is present only if rgb
crate feature is enabled.
Implementation is provided for u8
and u16
colour component types.
Examples
use ansi_colours::{AsRGB, ansi256_from_rgb};
assert_eq!(0x123456, rgb::RGB8::new(0x12, 0x34, 0x56).as_u32());
assert_eq!( 16, ansi256_from_rgb(rgb::RGB8::new( 1, 1, 1)));
assert_eq!( 16, ansi256_from_rgb(rgb::RGB8::new( 0, 1, 2)));
assert_eq!( 67, ansi256_from_rgb(rgb::RGB8::new( 95, 135, 175)));
assert_eq!(231, ansi256_from_rgb(rgb::RGB8::new(255, 255, 255)));
assert_eq!(0x123456, rgb::RGB16::new(0x12ab, 0x34cd, 0x56ef).as_u32());
assert_eq!( 16, ansi256_from_rgb(rgb::RGB16::new( 256, 511, 256)));
assert_eq!( 16, ansi256_from_rgb(rgb::RGB16::new( 128, 256, 512)));
assert_eq!( 67, ansi256_from_rgb(rgb::RGB16::new(24500, 34600, 44800)));
assert_eq!(231, ansi256_from_rgb(rgb::RGB16::new(65535, 65535, 65535)));
source§impl<C: Component> AsRGB for Gray<C>
impl<C: Component> AsRGB for Gray<C>
source§fn to_ansi256(&self) -> u8
fn to_ansi256(&self) -> u8
Returns index of a colour in 256-colour ANSI palette approximating given shade grey.
This implementation is present only if rgb
crate feature is enabled.
Implementation is provided for u8
and u16
colour component types.
Examples
use ansi_colours::ansi256_from_rgb;
assert_eq!(244, ansi256_from_rgb(rgb::alt::Gray::<u8>(128)));
assert_eq!(244, ansi256_from_rgb(rgb::alt::Gray::<u16>(33023)));
fn as_u32(&self) -> u32
source§impl<C: Component> AsRGB for BGR<C>
impl<C: Component> AsRGB for BGR<C>
source§fn as_u32(&self) -> u32
fn as_u32(&self) -> u32
Returns representation of the sRGB colour as a 24-bit 0xRRGGBB
integer.
This implementation is present only if rgb
crate feature is enabled.
Implementation is provided for u8
and u16
colour component types.
Examples
use ansi_colours::{AsRGB, ansi256_from_rgb};
use rgb::alt::{BGR8, BGR16};
assert_eq!(0x123456, BGR8 { b: 0x56, g: 0x34, r: 0x12 }.as_u32());
assert_eq!( 16, ansi256_from_rgb(BGR8 { r: 1, g: 1, b: 1 }));
assert_eq!( 16, ansi256_from_rgb(BGR8 { r: 0, g: 1, b: 2 }));
assert_eq!( 67, ansi256_from_rgb(BGR8 { r: 95, g: 135, b: 175 }));
assert_eq!(231, ansi256_from_rgb(BGR8 { r: 255, g: 255, b: 255 }));
assert_eq!(0x123456, BGR16 { b: 0x56ef, g: 0x34cd, r: 0x12ab }.as_u32());
assert_eq!( 16, ansi256_from_rgb(BGR16 { r: 256, g: 511, b: 256 }));
assert_eq!( 16, ansi256_from_rgb(BGR16 { r: 128, g: 256, b: 512 }));
assert_eq!( 67, ansi256_from_rgb(BGR16 { r: 24500, g: 34600, b: 44800 }));
assert_eq!(231, ansi256_from_rgb(BGR16 { r: 65535, g: 65535, b: 65535 }));
source§impl AsRGB for Colour
impl AsRGB for Colour
source§fn as_u32(&self) -> u32
fn as_u32(&self) -> u32
Returns sRGB colour corresponding to escape code represented by
ansi_term::Colour
.
Behaves slightly differently depending on the variant of the enum.
- For named colour variants (
Black
,Red
etc. up tillWhite
), returns corresponding system colour with indexes going from 0 to 7. - Similarly, for
Fixed
variant returns colour corresponding to specified index. Seergb_from_ansi256
. - Lastly, for
RGB
variant converts it to 24-bit0xRRGGBB
representation.
This implementation is present only if ansi_term
crate feature is
enabled.
source§fn to_ansi256(&self) -> u8
fn to_ansi256(&self) -> u8
Returns index of a colour in 256-colour ANSI palette approximating given sRGB colour.
Behaves slightly differently depending on the variant of the enum.
- For named colour variants (
Black
,Red
etc. up tillWhite
), returns index going from 0 to 7. - For
Fixed
variant simply returns index encoded in the variant. - Lastly, for
RGB
variant, approximates the colour and returns index of closest colour in 256-colour palette.
This implementation is present only if ansi_term
crate feature is
enabled.
Examples
use ansi_colours::AsRGB;
assert_eq!( 0, ansi_term::Colour::Black.to_ansi256());
assert_eq!( 7, ansi_term::Colour::White.to_ansi256());
assert_eq!( 42, ansi_term::Colour::Fixed(42).to_ansi256());
assert_eq!( 16, ansi_term::Colour::RGB( 0, 0, 0).to_ansi256());
assert_eq!( 16, ansi_term::Colour::RGB( 1, 1, 1).to_ansi256());
assert_eq!( 16, ansi_term::Colour::RGB( 0, 1, 2).to_ansi256());
assert_eq!( 67, ansi_term::Colour::RGB( 95, 135, 175).to_ansi256());
assert_eq!(231, ansi_term::Colour::RGB(255, 255, 255).to_ansi256());
source§impl AsRGB for Color
impl AsRGB for Color
source§fn as_u32(&self) -> u32
fn as_u32(&self) -> u32
Returns sRGB colour corresponding to escape code represented by
termcolor::Color
.
Behaves slightly differently depending on the variant of the enum.
- For named colour variants (
Black
,Red
etc. up tillWhite
), returns corresponding system colour with indexes going from 0 to 7. - Similarly, for
Ansi256
variant returns colour corresponding to specified index. Seergb_from_ansi256
. - Lastly, for
Rgb
variant converts it to 24-bit0xRRGGBB
representation.
This implementation is present only if termcolor
crate feature is
enabled.
source§fn to_ansi256(&self) -> u8
fn to_ansi256(&self) -> u8
Returns index of a colour in 256-colour ANSI palette approximating given sRGB colour.
Behaves slightly differently depending on the variant of the enum.
- For named colour variants (
Black
,Red
etc. up tillWhite
), returns index going from 0 to 7. - For
Ansi256
variant simply returns index encoded in the variant. - Lastly, for
Rgb
variant, approximates the colour and returns index of closest colour in 256-colour palette.
This implementation is present only if termcolor
crate feature is
enabled.
Examples
use ansi_colours::AsRGB;
assert_eq!( 0, termcolor::Color::Black.to_ansi256());
assert_eq!( 7, termcolor::Color::White.to_ansi256());
assert_eq!( 42, termcolor::Color::Ansi256(42).to_ansi256());
assert_eq!( 16, termcolor::Color::Rgb( 0, 0, 0).to_ansi256());
assert_eq!( 16, termcolor::Color::Rgb( 1, 1, 1).to_ansi256());
assert_eq!( 16, termcolor::Color::Rgb( 0, 1, 2).to_ansi256());
assert_eq!( 67, termcolor::Color::Rgb( 95, 135, 175).to_ansi256());
assert_eq!(231, termcolor::Color::Rgb(255, 255, 255).to_ansi256());