Mixbox色彩混合库C版使用指南-优快云博客

Mixbox色彩混合库C版使用指南

还在为传统RGB线性混合产生的灰暗、不自然的颜色过渡而烦恼吗？Mixbox基于真实颜料物理原理，提供自然的色彩混合效果，让蓝色和黄色混合出鲜活的绿色，而不是沉闷的灰色。本文将详细介绍如何在C/C++项目中使用Mixbox库。

什么是Mixbox？

Mixbox是一种基于Kubelka-Munk理论的色彩混合方法，它模拟真实颜料的物理混合行为。与传统的RGB线性混合不同，Mixbox能够：

🎨 产生饱和的色彩渐变
🌈 实现自然的色调偏移
🖌️ 生成逼真的二次色
🔄 简单的RGB输入输出接口

快速开始

1. 获取Mixbox C++库

首先将Mixbox库文件添加到您的项目中：

// 下载或复制以下文件到您的项目目录：
// - mixbox.h   (头文件)
// - mixbox.cpp (实现文件)

2. 基本色彩混合

使用mixbox_lerp函数进行两色混合：

#include <stdio.h>
#include "mixbox.h"

int main() {
    // 定义两个颜色：蓝色和黄色
    unsigned char r1 =   0, g1 = 33,  b1 = 133; // 钴蓝色
    unsigned char r2 = 252, g2 = 211, b2 = 0;   // 汉莎黄色
    float t = 0.5;                              // 混合比例 (0.0-1.0)
    unsigned char r, g, b;                      // 结果颜色

    // 执行色彩混合
    mixbox_lerp(r1, g1, b1,   // 第一个颜色
                r2, g2, b2,   // 第二个颜色
                t,            // 混合比例
                &r, &g, &b);  // 输出结果

    printf("混合结果: %d %d %d\n", r, g, b);
    return 0;
}

3. 编译和运行

使用您喜欢的编译器进行编译：

# 使用gcc编译
gcc -o mixbox_demo mixbox.cpp main.c -lstdc++ -lm

# 或者使用g++
g++ -o mixbox_demo mixbox.cpp main.cpp -lm

# 运行程序
./mixbox_demo

高级功能

多颜色混合

Mixbox支持同时混合多个颜色：

#include "mixbox.h"

void mix_multiple_colors() {
    unsigned char r1 = 255, g1 = 39,  b1 = 2;   // 镉红色
    unsigned char r2 = 252, g2 = 211, b2 = 0;   // 汉莎黄色
    unsigned char r3 = 0,   g3 = 33,  b3 = 133; // 钴蓝色
    
    mixbox_latent z1, z2, z3, z_mix;
    unsigned char r, g, b;

    // 将RGB颜色转换为潜在空间表示
    mixbox_rgb_to_latent(r1, g1, b1, z1);
    mixbox_rgb_to_latent(r2, g2, b2, z2);
    mixbox_rgb_to_latent(r3, g3, b3, z3);

    // 在潜在空间中进行线性混合
    for (int i = 0; i < MIXBOX_LATENT_SIZE; i++) {
        // 混合比例：30% 红色, 60% 黄色, 10% 蓝色
        z_mix[i] = 0.3f * z1[i] + 0.6f * z2[i] + 0.1f * z3[i];
    }

    // 将混合结果转换回RGB空间
    mixbox_latent_to_rgb(z_mix, &r, &g, &b);
    
    printf("多色混合结果: %d %d %d\n", r, g, b);
}

浮点数颜色支持

Mixbox提供多种颜色格式支持：

void float_color_examples() {
    // 使用0-255整型颜色
    unsigned char r_byte = 255, g_byte = 100, b_byte = 50;
    
    // 使用0.0-1.0浮点颜色
    float r_float = 1.0f, g_float = 0.392f, b_float = 0.196f;
    
    // 使用线性空间浮点颜色
    float r_linear = 1.0f, g_linear = 0.141f, b_linear = 0.027f;
    
    mixbox_latent latent;
    unsigned char out_r, out_g, out_b;
    float out_rf, out_gf, out_bf;

    // 不同格式的转换函数
    mixbox_rgb_to_latent(r_byte, g_byte, b_byte, latent);
    mixbox_float_rgb_to_latent(r_float, g_float, b_float, latent);
    mixbox_linear_float_rgb_to_latent(r_linear, g_linear, b_linear, latent);
    
    // 相应的输出函数
    mixbox_latent_to_rgb(latent, &out_r, &out_g, &out_b);
    mixbox_latent_to_float_rgb(latent, &out_rf, &out_gf, &out_bf);
    mixbox_latent_to_linear_float_rgb(latent, &out_rf, &out_gf, &out_bf);
}

预定义颜料颜色

Mixbox基于13种真实颜料进行色彩建模：

颜料名称	RGB值	浮点RGB	线性RGB	颜色示例
镉黄色 (Cadmium Yellow)	254, 236, 0	0.996, 0.925, 0.0	0.991, 0.839, 0.0	🟨
汉莎黄色 (Hansa Yellow)	252, 211, 0	0.988, 0.827, 0.0	0.973, 0.651, 0.0	🟨
镉橙色 (Cadmium Orange)	255, 105, 0	1.0, 0.412, 0.0	1.0, 0.141, 0.0	🟧
镉红色 (Cadmium Red)	255, 39, 2	1.0, 0.153, 0.008	1.0, 0.02, 0.001	🟥
喹吖啶酮洋红 (Quinacridone Magenta)	128, 2, 46	0.502, 0.008, 0.18	0.216, 0.001, 0.027	🟪
钴紫色 (Cobalt Violet)	78, 0, 66	0.306, 0.0, 0.259	0.076, 0.0, 0.054	🟪
群青蓝 (Ultramarine Blue)	25, 0, 89	0.098, 0.0, 0.349	0.01, 0.0, 0.1	🟦
钴蓝色 (Cobalt Blue)	0, 33, 133	0.0, 0.129, 0.522	0.0, 0.015, 0.235	🟦
酞菁蓝 (Phthalo Blue)	13, 27, 68	0.051, 0.106, 0.267	0.004, 0.011, 0.058	🟦
酞菁绿 (Phthalo Green)	0, 60, 50	0.0, 0.235, 0.196	0.0, 0.045, 0.032	🟩
永久绿 (Permanent Green)	7, 109, 22	0.027, 0.427, 0.086	0.002, 0.153, 0.008	🟩
树汁绿 (Sap Green)	107, 148, 4	0.42, 0.58, 0.016	0.147, 0.296, 0.001	🟩
熟赭色 (Burnt Sienna)	123, 72, 0	0.482, 0.282, 0.0	0.198, 0.065, 0.0	🟫

实际应用示例

创建色彩渐变

#include "mixbox.h"
#include <vector>

std::vector<unsigned char> create_gradient(
    unsigned char r1, unsigned char g1, unsigned char b1,
    unsigned char r2, unsigned char g2, unsigned char b2,
    int steps
) {
    std::vector<unsigned char> gradient;
    gradient.reserve(steps * 3);
    
    for (int i = 0; i < steps; i++) {
        float t = static_cast<float>(i) / (steps - 1);
        unsigned char r, g, b;
        
        mixbox_lerp(r1, g1, b1, r2, g2, b2, t, &r, &g, &b);
        
        gradient.push_back(r);
        gradient.push_back(g);
        gradient.push_back(b);
    }
    
    return gradient;
}

// 使用示例：创建从蓝色到黄色的渐变
auto gradient = create_gradient(0, 33, 133, 252, 211, 0, 10);

图像处理应用

#include "mixbox.h"
#include <stdint.h>

void apply_mixbox_to_image(
    uint8_t* image_data, 
    int width, 
    int height,
    unsigned char target_r, 
    unsigned char target_g, 
    unsigned char target_b,
    float strength
) {
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            int index = (y * width + x) * 3;
            
            unsigned char r = image_data[index];
            unsigned char g = image_data[index + 1];
            unsigned char b = image_data[index + 2];
            
            unsigned char mixed_r, mixed_g, mixed_b;
            mixbox_lerp(r, g, b, target_r, target_g, target_b, 
                       strength, &mixed_r, &mixed_g, &mixed_b);
            
            image_data[index] = mixed_r;
            image_data[index + 1] = mixed_g;
            image_data[index + 2] = mixed_b;
        }
    }
}

性能优化技巧

1. 批量处理

void batch_mixbox_lerp(
    const unsigned char* colors1,
    const unsigned char* colors2,
    const float* ratios,
    unsigned char* results,
    int count
) {
    #pragma omp parallel for
    for (int i = 0; i < count; i++) {
        int idx = i * 3;
        mixbox_lerp(
            colors1[idx], colors1[idx+1], colors1[idx+2],
            colors2[idx], colors2[idx+1], colors2[idx+2],
            ratios[i],
            &results[idx], &results[idx+1], &results[idx+2]
        );
    }
}

2. 预计算潜在空间

void precompute_latents(
    const unsigned char* rgb_colors,
    mixbox_latent* latents,
    int count
) {
    for (int i = 0; i < count; i++) {
        int idx = i * 3;
        mixbox_rgb_to_latent(
            rgb_colors[idx], rgb_colors[idx+1], rgb_colors[idx+2],
            latents[i]
        );
    }
}

void fast_mixing(
    const mixbox_latent* latents1,
    const mixbox_latent* latents2,
    const float* ratios,
    unsigned char* results,
    int count
) {
    for (int i = 0; i < count; i++) {
        mixbox_latent mixed;
        for (int j = 0; j < MIXBOX_LATENT_SIZE; j++) {
            mixed[j] = (1 - ratios[i]) * latents1[i][j] + 
                       ratios[i] * latents2[i][j];
        }
        mixbox_latent_to_rgb(mixed, 
            &results[i*3], &results[i*3+1], &results[i*3+2]);
    }
}

常见问题解答

Q: Mixbox与传统RGB混合有何不同？

A: 传统RGB混合是线性操作，经常产生灰暗、不自然的结果。Mixbox基于物理颜料混合原理，产生更自然、饱和的色彩过渡。

Q: 性能如何？

A: Mixbox经过高度优化，单次混合操作只需微秒级别的时间。对于实时应用，建议预计算或使用批处理。

Q: 支持哪些颜色空间？

A: 支持标准RGB（0-255）、浮点RGB（0.0-1.0）和线性RGB空间。

Q: 是否可以商用？

A: Mixbox采用CC BY-NC 4.0许可证，非商业使用免费。商业使用需要联系作者获取商业许可证。

完整示例项目

// mixbox_demo.c - 完整的演示程序
#include <stdio.h>
#include <stdlib.h>
#include "mixbox.h"

void demo_basic_mixing() {
    printf("=== 基础色彩混合演示 ===\n");
    
    // 蓝色和黄色混合
    unsigned char blue[] = {0, 33, 133};
    unsigned char yellow[] = {252, 211, 0};
    
    for (float t = 0.0f; t <= 1.0f; t += 0.1f) {
        unsigned char r, g, b;
        mixbox_lerp(blue[0], blue[1], blue[2],
                   yellow[0], yellow[1], yellow[2],
                   t, &r, &g, &b);
        
        printf("比例 %.1f: RGB(%3d, %3d, %3d)\n", t, r, g, b);
    }
}

void demo_multicolor_mixing() {
    printf("\n=== 多颜色混合演示 ===\n");
    
    unsigned char red[] = {255, 39, 2};
    unsigned char yellow[] = {252, 211, 0};
    unsigned char blue[] = {0, 33, 133};
    
    mixbox_latent z_red, z_yellow, z_blue, z_mix;
    unsigned char r, g, b;
    
    mixbox_rgb_to_latent(red[0], red[1], red[2], z_red);
    mixbox_rgb_to_latent(yellow[0], yellow[1], yellow[2], z_yellow);
    mixbox_rgb_to_latent(blue[0], blue[1], blue[2], z_blue);
    
    // 尝试不同的混合比例
    float ratios[][3] = {
        {0.6f, 0.3f, 0.1f},  // 60%红, 30%黄, 10%蓝
        {0.3f, 0.6f, 0.1f},  // 30%红, 60%黄, 10%蓝
        {0.1f, 0.3f, 0.6f},  // 10%红, 30%黄, 60%蓝
    };
    
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < MIXBOX_LATENT_SIZE; j++) {
            z_mix[j] = ratios[i][0] * z_red[j] + 
                       ratios[i][1] * z_yellow[j] + 
                       ratios[i][2] * z_blue[j];
        }
        
        mixbox_latent_to_rgb(z_mix, &r, &g, &b);
        printf("比例 %.0f:%.0f:%.0f: RGB(%3d, %3d, %3d)\n",
               ratios[i][0]*100, ratios[i][1]*100, ratios[i][2]*100,
               r, g, b);
    }
}

int main() {
    printf("Mixbox C/C++ 库演示程序\n");
    printf("=======================\n");
    
    demo_basic_mixing();
    demo_multicolor_mixing();
    
    printf("\n演示完成！\n");
    return 0;
}

编译和运行说明

编译命令

# 使用gcc编译（需要链接C++标准库）
gcc -o mixbox_demo mixbox.cpp mixbox_demo.c -lstdc++ -lm -O2

# 使用g++编译
g++ -o mixbox_demo mixbox.cpp mixbox_demo.cpp -lm -O2

# 启用OpenMP并行优化
g++ -o mixbox_demo mixbox.cpp mixbox_demo.cpp -lm -O2 -fopenmp

运行输出示例

Mixbox C/C++ 库演示程序
=======================
=== 基础色彩混合演示 ===
比例 0.0: RGB(  0,  33, 133)
比例 0.1: RGB( 25,  46, 119)
比例 0.2: RGB( 50,  65, 104)
比例 0.3: RGB( 79,  87,  88)
比例 0.4: RGB(112, 112,  70)
比例 0.5: RGB(148, 139,  50)
比例 0.6: RGB(183, 166,  31)
比例 0.7: RGB(213, 189,  15)
比例 0.8: RGB(232, 205,   5)
比例 0.9: RGB(244, 211,   1)
比例 1.0: RGB(252, 211,   0)

=== 多颜色混合演示 ===
比例 60:30:10: RGB(223, 108,  15)
比例 30:60:10: RGB(223, 166,  15)
比例 10:30:60: RGB( 66, 108, 108)

演示完成！

总结

Mixbox为C/C++开发者提供了一个强大而易用的色彩混合解决方案。通过模拟真实颜料的物理特性，它能够产生比传统RGB混合更自然、更生动的色彩效果。无论是图形应用程序、游戏开发还是图像处理，Mixbox都能为您的项目增添专业的色彩处理能力。

记住：蓝色和黄色混合应该产生鲜活的绿色，而不是沉闷的灰色——这就是Mixbox的魅力所在！

注意: 本文档中的代码示例基于Mixbox 2.0版本。使用时请确保遵守相应的开源许可证条款。

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考