Rust颜色处理库colorsys的使用,支持RGB、HSL、HSV等多种颜色模型的转换与操作

Rust颜色处理库colorsys的使用,支持RGB、HSL、HSV等多种颜色模型的转换与操作

一个用Rust编写的颜色转换和变异的模块。 目前支持以下颜色模型:

  • RGB(a)(也支持十六进制)
  • HSL(a)
  • CMYK(a)
  • ANSI256代码

它能做什么

getters & setters

use colorsys::{Rgb, Hsl, ColorAlpha};

let rgb = Rgb::from((57.3, 12.7, 53.0));
let r = rgb.red();
// 57.3

let mut hsl = Hsl::default();
// Hsl { h: 0, s: 0, l: 0, a: 1 }
hsl.set_saturation(13.98);
hsl.set_saturation(305.71);
hsl.set_alpha(0.75);
// Hsl { h: 305.71, s: 13.98, l: 0, a: 0.75 }

conversion

查看文档中的From/FromStr/Into特性实现以获取更多信息

use colorsys::{Rgb, Hsl};

let rbga_tuple = (57.3, 12.7, 53.0, 0.33);
let rgba = Rgb::from(&rbga_tuple);
let hsla: Hsl = rgba.as_ref().into();
// ~Hsl { h: 305.78, s: 63.71, l: 13.73, a: 0.33 }

let rgb_arr: [u8; 3] = Rgb::from(&hsla).into();
// ~[57, 13, 53]

let hsla_tuple: (f64,f64,f64,f64) = Hsl::from( Rgb::from(rgb_tuple) ).into();
// ~Hsl { h: 305.78, s: 63.71, l: 13.73, a: 1 }

let hex: String = rgba.to_hex_string();
// #390d35

//
// From/Into
//
let rgb1 = Rgb::from_hex_str("37ea4c").unwrap();
  
let rgb2 = Rgb::from(
Into::<[f32; 4]>::into(Rgb::from(
  Into::<[u8; 3]>::into(
    Rgb::from(
      Into::<(i32,i32,i32)>::into(
        Rgb::from(
          Into::<[i64; 3]>::into(&rgb1)
        )
      )
    )
  )
))
);

assert_eq!(rgb1, rgb2);

//
// Ratio
//
use colorsys::{RgbRatio, ApproxEq};
let blue = Rgb::from([34, 111, 235]);

let ratio: [f32; 4] = blue.as_ratio().into();
// ~[0.133, 0.435, 0.922, 1.0]

let converted: Rgb = RgbRatio::from(&ratio).into();
assert!(blue.approx_eq_clarify(&converted, 0.0001));

modification

查看文档中的ColorTransform/Add*/Sub*..特性以获取更多信息

use colorsys::{Hsl, Rgb, ColorTransform,ColorAlpha, SaturationInSpace};

let mut rgb: Rgb = (245.0,152.0,53.0).into();

rgb.lighten(20.1);
// ~Rgb { r: 249.83, g: 201.80, b: 150.67 }

rgb.opacify(-0.7);
rgb.saturate( SaturationInSpace::Hsl(-35.7) );
// ~Rgb { r: 230.29, g: 201.19, b: 170.21, a: 0.3 }

rgb.grayscale_simple();
// ~Rgb { r: 200.255, g: 200.255, b: 200.255, a: 0.3 }


let mut hsl = Hsl::from(&rgb);
hsl.opacify(1.0);
// ~Hsl { h: 0.0, s: 0.0, l: 78.53 }

hsl.adjust_hue(231.99);
hsl.saturate(SaturationInSpace::Hsl(55.7));

let mut rgb2: Rgb = hsl.as_ref().into();
// ~Rgb { r: 169.76, g: 177.9, b: 230.75}

rgb2.invert();
// ~Rgb { r: 85.24, g: 77.09, b: 24.25 }

let rgb3 = rgb - rgb2;
// ~Rgb { r: 115.01, g: 123.16, b: 176.0 }

let hsl2 = hsl + rgb3.into();
// ~Hsl { h: 0.0, s: 83.55, l: 100.0 }

parsing from string & css string representation

use colorsys::{Hsl, Rgb};
use std::str::FromStr;

let s = "rgb(177, 255, 176)";

let rgb: Rgb = s.parse().unwrap();

rgb.to_css_string();
// String: "rgb(177,255,176)"

rgb.to_hex_string();
// #b1ffb0

Hsl::from_str("hsl(168, 52%, 42%)").unwrap().to_css_string();
// String: hsl(168,52%,42%)

no_std

该crate有一个名为"std"的Cargo特性,默认启用。 要在no_std上下文中使用colorsys,需要禁用此特性。 修改您的依赖项以选择退出默认启用的特性。

[dependencies]
colorsys = { version = "*", default-features = false }

颜色单位范围

所有颜色单位都是f64。以下是它们的范围:

  • red: 0.0 - 255.0
  • green: 0.0 - 255.0
  • blue: 0.0 - 255.0
  • hue: 0.0 - 360.0
  • saturation: 0.0 - 100.0
  • lightness: 0.0 - 100.0
  • cmyk中的所有值都是: 0.0 - 100.0
  • alpha: 0.0 - 1.0
  • ansi256代码是u8

如果您指定的值不在这些范围内,它们将被替换为最小值或最大值。

享受使用!

完整示例代码

use colorsys::{Rgb, Hsl, ColorAlpha, ColorTransform, SaturationInSpace};
use std::str::FromStr;

fn main() {
    // 创建RGB颜色
    let rgb = Rgb::from((57.3, 12.7, 53.0));
    println!("RGB颜色: {:?}", rgb);
    
    // 获取红色分量
    let r = rgb.red();
    println!("红色分量: {}", r);
    
    // 创建HSL颜色并设置属性
    let mut hsl = Hsl::default();
    hsl.set_hue(305.71);
    hsl.set_saturation(13.98);
    hsl.set_lightness(50.0);
    hsl.set_alpha(0.75);
    println!("HSL颜色: {:?}", hsl);
    
    // 颜色转换
    let rgba_tuple = (57.3, 12.7, 53.0, 0.33);
    let rgba = Rgb::from(&rgba_tuple);
    let hsla: Hsl = rgba.as_ref().into();
    println!("RGB转HSL: {:?}", hsla);
    
    // 转换为十六进制
    let hex: String = rgba.to_hex_string();
    println!("十六进制: {}", hex);
    
    // 从字符串解析
    let s = "rgb(177, 255, 176)";
    let rgb_from_str: Rgb = s.parse().unwrap();
    println!("从字符串解析: {:?}", rgb_from_str);
    
    // CSS字符串表示
    println!("CSS字符串: {}", rgb_from_str.to_css_string());
    
    // 颜色操作
    let mut rgb_oper: Rgb = (245.0, 152.0, 53.0).into();
    rgb_oper.lighten(20.1);
    println!("变亮后的RGB: {:?}", rgb_oper);
    
    // 饱和度调整
    rgb_oper.saturate(SaturationInSpace::Hsl(-35.7));
    println!("调整饱和度后的RGB: {:?}", rgb_oper);
}

1 回复

Rust颜色处理库colorsys的使用指南

概述

colorsys是一个功能强大的Rust颜色处理库,支持RGB、HSL、HSV等多种颜色模型的转换与操作。该库提供了简洁的API,让开发者能够轻松处理颜色相关的计算和转换任务。

主要特性

  • 支持RGB、HSL、HSV、CMYK等多种颜色模型
  • 颜色模型间的相互转换
  • 颜色操作(调整亮度、饱和度等)
  • 颜色格式化输出
  • 类型安全且高性能

安装方法

在Cargo.toml中添加依赖:

[dependencies]
colorsys = "0.6"

基本使用方法

1. 创建颜色对象

use colorsys::{Rgb, Hsl, Hsv};

// 创建RGB颜色
let rgb = Rgb::from((255, 100, 50));

// 创建HSL颜色
let hsl = Hsl::from((120.0, 0.5, 0.75));

// 创建HSV颜色
let hsv = Hsv::from((240.0, 0.8, 0.9));

2. 颜色模型转换

// RGB转HSL
let rgb = Rgb::from((255, 100, 50));
let hsl: Hsl = rgb.into();

// HSL转HSV
let hsl = Hsl::from((120.0, 0.5, 0.75));
let hsv: Hsv = hsl.into();

// HSV转RGB
let hsv = Hsv::from((240.0, 0.8, 0.9));
let rgb: Rgb = hsv.into();

3. 颜色操作示例

use colorsys::{Rgb, Hsl};

// 调整亮度
let mut hsl = Hsl::from((120.0, 0.5, 0.5));
hsl.set_lightness(0.8);

// 调整饱和度
hsl.set_saturation(0.9);

// 获取十六进制表示
let rgb = Rgb::from((255, 100, 50));
let hex = rgb.to_hex_string();
println!("十六进制颜色: {}", hex); // 输出: #ff6432

4. 颜色比较和运算

use colorsys::Rgb;

let color1 = Rgb::from((255, 0, 0));
let color2 = Rgb::from((0, 255, 0));

// 颜色混合
let mixed = color1.mix(&color2, 0.5);

5. 从字符串解析颜色

use colorsys::Rgb;

// 从十六进制字符串解析
let rgb = Rgb::from_hex_str("#ff6432").unwrap();

// 从RGB字符串解析
let rgb = Rgb::from_str("rgb(255, 100, 50)").unwrap();

完整示例

use colorsys::{Rgb, Hsl, Hsv};

fn main() {
    // 创建红色
    let red = Rgb::from((255, 0, 0));
    
    // 转换为HSL
    let hsl: Hsl = red.into();
    println!("红色在HSL模型: {:?}", hsl);
    
    // 转换为HSV
    let hsv: Hsv = red.into();
    println!("红色在HSV模型: {:?}", hsv);
    
    // 调整亮度并转回RGB
    let mut dark_red_hsl: Hsl = red.into();
    dark_red_hsl.set_lightness(0.3);
    let dark_red: Rgb = dark_red_hsl.into();
    println!("暗红色: {}", dark_red.to_hex_string());
}

完整示例demo

use colorsys::{Rgb, Hsl, Hsv, Cmyk};

fn main() {
    println!("=== colorsys库完整使用示例 ===");
    
    // 示例1: 创建不同颜色模型的对象
    println!("\n1. 创建颜色对象:");
    let rgb_color = Rgb::from((255, 100, 50)); // RGB颜色
    let hsl_color = Hsl::from((120.0, 0.5, 0.75)); // HSL颜色
    let hsv_color = Hsv::from((240.0, 0.8, 0.9)); // HSV颜色
    let cmyk_color = Cmyk::from((0.1, 0.8, 0.9, 0.2)); // CMYK颜色
    
    println!("RGB颜色: {:?}", rgb_color);
    println!("HSL颜色: {:?}", hsl_color);
    println!("HSV颜色: {:?}", hsv_color);
    println!("CMYK颜色: {:?}", cmyk_color);
    
    // 示例2: 颜色模型转换
    println!("\n2. 颜色模型转换:");
    
    // RGB转HSL
    let rgb_to_hsl: Hsl = rgb_color.into();
    println!("RGB转HSL: {:?}", rgb_to_hsl);
    
    // HSL转HSV
    let hsl_to_hsv: Hsv = hsl_color.into();
    println!("HSL转HSV: {:?}", hsl_to_hsv);
    
    // HSV转RGB
    let hsv_to_rgb: Rgb = hsv_color.into();
    println!("HSV转RGB: {:?}", hsv_to_rgb);
    
    // RGB转CMYK
    let rgb_to_cmyk: Cmyk = rgb_color.into();
    println!("RGB转CMYK: {:?}", rgb_to_cmyk);
    
    // 示例3: 颜色操作
    println!("\n3. 颜色操作:");
    
    // 调整HSL颜色的亮度和饱和度
    let mut adjustable_hsl = Hsl::from((200.0, 0.6, 0.5));
    println!("原始HSL: {:?}", adjustable_hsl);
    
    adjustable_hsl.set_lightness(0.8); // 增加亮度
    println!("增加亮度后: {:?}", adjustable_hsl);
    
    adjustable_hsl.set_saturation(0.9); // 增加饱和度
    println!("增加饱和度后: {:?}", adjustable_hsl);
    
    // 获取十六进制表示
    let hex_string = rgb_color.to_hex_string();
    println!("RGB颜色的十六进制表示: {}", hex_string);
    
    // 示例4: 颜色混合
    println!("\n4. 颜色混合:");
    let blue = Rgb::from((0, 0, 255));
    let yellow = Rgb::from((255, 255, 0));
    
    let mixed_color = blue.mix(&yellow, 0.5); // 50%混合
    println!("蓝色和黄色混合结果: {:?}", mixed_color);
    println!("混合颜色的十六进制: {}", mixed_color.to_hex_string());
    
    // 示例5: 从字符串解析颜色
    println!("\n5. 从字符串解析颜色:");
    
    // 解析十六进制颜色
    match Rgb::from_hex_str("#ff6432") {
        Ok(parsed_rgb) => println!("解析十六进制颜色: {:?}", parsed_rgb),
        Err(e) => println!("解析失败: {}", e),
    }
    
    // 解析RGB字符串
    match Rgb::from_str("rgb(255, 100, 50)") {
        Ok(parsed_rgb) => println!("解析RGB字符串: {:?}", parsed_rgb),
        Err(e) => println!("解析失败: {}", e),
    }
    
    // 示例6: 完整工作流程
    println!("\n6. 完整工作流程示例:");
    
    // 从十六进制创建颜色
    let start_color = Rgb::from_hex_str("#3498db").unwrap();
    println!("起始颜色: {}", start_color.to_hex_string());
    
    // 转换为HSL进行调整
    let mut hsl_version: Hsl = start_color.into();
    hsl_version.set_hue(180.0); // 改变色相
    hsl_version.set_saturation(0.9); // 增加饱和度
    
    // 转回RGB
    let final_color: Rgb = hsl_version.into();
    println!("调整后的颜色: {}", final_color.to_hex_string());
    
    println!("\n=== 示例执行完成 ===");
}

注意事项

  • 所有颜色值都经过验证,确保在有效范围内
  • 转换操作可能会产生浮点数精度误差
  • 建议使用库提供的类型而不是原始数值来处理颜色

这个库为Rust开发者提供了完整的颜色处理解决方案,适合图形处理、UI开发、数据可视化等各种需要颜色操作的场景。

回到顶部