Реализация цветовых моделей на C: RGB, CMYK, HSV в программировании

// RGB модель
typedef struct {
uint8_t r; // 0-255
uint8_t g; // 0-255
uint8_t b; // 0-255
} RGB;

// CMYK модель
typedef struct {
float c; // 0.0-1.0
float m; // 0.0-1.0
float y; // 0.0-1.0
float k; // 0.0-1.0
} CMYK;

// HSV модель
typedef struct {
float h; // 0-360 (градусы)
float s; // 0.0-1.0
float v; // 0.0-1.0
} HSV;

// Базовое представление с отдельными компонентами
typedef struct {
uint8_t r, g, b;
} RGB_Color;

// Упакованное 24-битное представление
typedef uint32_t Packed_RGB;

// Макросы для работы с упакованным представлением
#define RGB_PACK(r, g, b) ((uint32_t)((r << 16) | (g << 8) | b))
#define RGB_GET_R(rgb) (((rgb) >> 16) & 0xFF)
#define RGB_GET_G(rgb) (((rgb) >> 8) & 0xFF)
#define RGB_GET_B(rgb) ((rgb) & 0xFF)

// Создание буфера кадра
RGB_Color* create_framebuffer(int width, int height) {
return (RGB_Color*)malloc(width * height * sizeof(RGB_Color));
}

// Установка пикселя в определённые координаты
void set_pixel(RGB_Color* buffer, int width, int x, int y, RGB_Color color) {
if (x >= 0 && y >= 0 && x < width) {
buffer[y * width + x] = color;
}
}

// Плавный переход между цветами (линейная интерполяция)
RGB_Color lerp_rgb(RGB_Color a, RGB_Color b, float t) {
RGB_Color result;
result.r = (uint8_t)(a.r + t * (b.r – a.r));
result.g = (uint8_t)(a.g + t * (b.g – a.g));
result.b = (uint8_t)(a.b + t * (b.b – a.b));
return result;
}

// Быстрое смешивание цветов без умножения (для альфа = 128, т.е. 50%)
Packed_RGB fast_blend_half(Packed_RGB bg, Packed_RGB fg) {
// Извлекаем компоненты, используя маски
uint32_t rb_mask = 0xFF00FF;
uint32_t bg_rb = bg & rb_mask;
uint32_t fg_rb = fg & rb_mask;
uint32_t bg_g = bg & 0x00FF00;
uint32_t fg_g = fg & 0x00FF00;

// Вычисляем средние значения без умножения (деление битовым сдвигом)
uint32_t result_rb = ((bg_rb + fg_rb) >> 1) & rb_mask;
uint32_t result_g = ((bg_g + fg_g) >> 1) & 0x00FF00;

return result_rb | result_g;
}

void save_rgb_buffer_to_ppm(const char* filename, RGB_Color* buffer, int width, int height) {
FILE* fp = fopen(filename, "wb");
if (!fp) return;

// Заголовок PPM формата
fprintf(fp, "P6\n%d %d\n255\n", width, height);

// Запись данных RGB
for (int i = 0; i < width * height; i++) {
fwrite(&buffer[i].r, 1, 1, fp);
fwrite(&buffer[i].g, 1, 1, fp);
fwrite(&buffer[i].b, 1, 1, fp);
}

fclose(fp);
}

typedef struct {
float c; // Cyan (0.0-1.0)
float m; // Magenta (0.0-1.0)
float y; // Yellow (0.0-1.0)
float k; // Key/Black (0.0-1.0)
} CMYK_Color;

CMYK_Color rgb_to_cmyk(RGB_Color rgb) {
CMYK_Color cmyk;

// Нормализация RGB компонентов к диапазону 0.0-1.0
float r = rgb.r / 255.0f;
float g = rgb.g / 255.0f;
float b = rgb.b / 255.0f;

// Вычисление компоненты K (черный)
float k = 1.0f – fmaxf(fmaxf(r, g), b);

// Избегаем деления на ноль
if (fabs(k – 1.0f) < 0.000001f) {
cmyk.c = 0.0f;
cmyk.m = 0.0f;
cmyk.y = 0.0f;
} else {
cmyk.c = (1.0f – r – k) / (1.0f – k);
cmyk.m = (1.0f – g – k) / (1.0f – k);
cmyk.y = (1.0f – b – k) / (1.0f – k);
}

cmyk.k = k;
return cmyk;
}

CMYK_Color apply_gcr(CMYK_Color cmyk, float strength) {
CMYK_Color result = cmyk;

// Находим минимальное значение из CMY – это "серый" компонент
float gray_component = fminf(fminf(cmyk.c, cmyk.m), cmyk.y);

// Применяем GCR с заданной интенсивностью
float replacement = gray_component * strength;

// Вычитаем из CMY и добавляем к K
result.c -= replacement;
result.m -= replacement;
result.y -= replacement;
result.k = fminf(1.0f, cmyk.k + replacement);

return result;
}

// Создание LUT для быстрого преобразования RGB в CMYK
CMYK_Color* create_rgb_to_cmyk_lut() {
CMYK_Color* lut = (CMYK_Color*)malloc(256 * 256 * 256 * sizeof(CMYK_Color));
if (!lut) return NULL;

for (int r = 0; r < 256; r++) {
for (int g = 0; g < 256; g++) {
for (int b = 0; b < 256; b++) {
RGB_Color rgb = {r, g, b};
CMYK_Color cmyk = rgb_to_cmyk(rgb);
lut[(r << 16) | (g << 8) | b] = cmyk;
}
}
}

return lut;
}

typedef struct {
float h; // Hue (0-360)
float s; // Saturation (0.0-1.0)
float v; // Value (0.0-1.0)
} HSV_Color;

HSV_Color rgb_to_hsv(RGB_Color rgb) {
HSV_Color hsv;
float r = rgb.r / 255.0f;
float g = rgb.g / 255.0f;
float b = rgb.b / 255.0f;

float max_val = fmaxf(fmaxf(r, g), b);
float min_val = fminf(fminf(r, g), b);
float delta = max_val – min_val;

// Вычисление Value
hsv.v = max_val;

// Вычисление Saturation
if (max_val == 0.0f) {
hsv.s = 0.0f;
} else {
hsv.s = delta / max_val;
}

// Вычисление Hue
if (delta < 0.00001f) {
hsv.h = 0.0f; // Нейтральный цвет
} else if (max_val == r) {
hsv.h = 60.0f * fmodf(((g – b) / delta), 6.0f);
} else if (max_val == g) {
hsv.h = 60.0f * (((b – r) / delta) + 2.0f);
} else { // max_val == b
hsv.h = 60.0f * (((r – g) / delta) + 4.0f);
}

// Нормализация Hue к положительному значению
if (hsv.h < 0.0f) hsv.h += 360.0f;

return hsv;
}

RGB_Color hsv_to_rgb(HSV_Color hsv) {
RGB_Color rgb;
float c = hsv.v * hsv.s;
float h_prime = hsv.h / 60.0f;
float x = c * (1.0f – fabsf(fmodf(h_prime, 2.0f) – 1.0f));
float m = hsv.v – c;
float r, g, b;

if (h_prime < 1.0f) {
r = c; g = x; b = 0.0f;
} else if (h_prime < 2.0f) {
r = x; g = c; b = 0.0f;
} else if (h_prime < 3.0f) {
r = 0.0f; g = c; b = x;
} else if (h_prime < 4.0f) {
r = 0.0f; g = x; b = c;
} else if (h_prime < 5.0f) {
r = x; g = 0.0f; b = c;
} else {
r = c; g = 0.0f; b = x;
}

rgb.r = (uint8_t)roundf((r + m) * 255.0f);
rgb.g = (uint8_t)roundf((g + m) * 255.0f);
rgb.b = (uint8_t)roundf((b + m) * 255.0f);

return rgb;
}

// Создание термокарты на основе двумерного массива значений
void generate_heatmap(float** data, int width, int height, RGB_Color* buffer,
float min_val, float max_val, float hue_min, float hue_max) {
float range = max_val – min_val;

for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
// Нормализация значения к диапазону 0.0-1.0
float normalized = (data[y][x] – min_val) / range;
normalized = fmaxf(0.0f, fminf(1.0f, normalized));

// Интерполяция оттенка между минимальным и максимальным
HSV_Color hsv;
hsv.h = hue_min + normalized * (hue_max – hue_min);
hsv.s = 1.0f; // Полная насыщенность
hsv.v = 1.0f; // Полная яркость

// Преобразование в RGB и запись в буфер
buffer[y * width + x] = hsv_to_rgb(hsv);
}
}
}

// Создание цветовой шкалы HSV с плавным переходом между контрольными точками
void create_hsv_color_scale(HSV_Color* scale, int size, HSV_Color* control_points, 
int num_points, float* positions) {
for (int i = 0; i < size; i++) {
float pos = (float)i / (size – 1);

// Найти два ближайших контрольных цвета
int idx = 0;
while (idx < num_points – 1 && positions[idx + 1] <= pos) idx++;

if (idx == num_points – 1 || fabs(positions[idx] – pos) < 0.0001f) {
// Точное совпадение с контрольной точкой
scale[i] = control_points[idx];
} else {
// Интерполяция между контрольными точками
float local_t = (pos – positions[idx]) / (positions[idx + 1] – positions[idx]);
HSV_Color a = control_points[idx];
HSV_Color b = control_points[idx + 1];

// Особая обработка для оттенка (кратчайший путь по кругу)
float h_diff = b.h – a.h;
if (h_diff > 180.0f) h_diff -= 360.0f;
else if (h_diff < -180.0f) h_diff += 360.0f;

scale[i].h = fmodf(a.h + local_t * h_diff + 360.0f, 360.0f);
scale[i].s = a.s + local_t * (b.s – a.s);
scale[i].v = a.v + local_t * (b.v – a.v);
}
}
}

// Простой алгоритм цветовой сегментации в HSV пространстве
void hsv_color_segmentation(RGB_Color* input, uint8_t* mask, int width, int height,
float h_min, float h_max, float s_min, float v_min) {
for (int i = 0; i < width * height; i++) {
HSV_Color hsv = rgb_to_hsv(input[i]);

// Проверка оттенка с учетом цикличности
bool h_match;
if (h_min <= h_max) {
h_match = (hsv.h >= h_min && hsv.h <= h_max);
} else {
h_match = (hsv.h >= h_min || hsv.h <= h_max);
}

// Проверка насыщенности и яркости
bool s_match = (hsv.s >= s_min);
bool v_match = (hsv.v >= v_min);

// Заполнение маски
mask[i] = (h_match && s_match && v_match) ? 255 : 0;
}
}

// Универсальная структура для представления цвета в любой модели
typedef struct {
union {
struct { uint8_t r, g, b; }; // RGB
struct { float c, m, y, k; }; // CMYK
struct { float h, s, v; }; // HSV
};
enum { RGB_MODEL, CMYK_MODEL, HSV_MODEL } model;
} Universal_Color;

// Функция конвертации между любыми моделями
Universal_Color convert_color(Universal_Color color, int target_model) {
Universal_Color result;
result.model = target_model;

// Если исходная модель совпадает с целевой, просто копируем данные
if (color.model == target_model) {
memcpy(&result, &color, sizeof(Universal_Color));
return result;
}

// Сначала конвертируем в RGB как промежуточный формат, если нужно
RGB_Color rgb;
switch (color.model) {
case RGB_MODEL:
rgb.r = color.r;
rgb.g = color.g;
rgb.b = color.b;
break;
case CMYK_MODEL:
rgb = cmyk_to_rgb((CMYK_Color){color.c, color.m, color.y, color.k});
break;
case HSV_MODEL:
rgb = hsv_to_rgb((HSV_Color){color.h, color.s, color.v});
break;
}

// Затем из RGB конвертируем в целевую модель
switch (target_model) {
case RGB_MODEL:
result.r = rgb.r;
result.g = rgb.g;
result.b = rgb.b;
break;
case CMYK_MODEL: {
CMYK_Color cmyk = rgb_to_cmyk(rgb);
result.c = cmyk.c;
result.m = cmyk.m;
result.y = cmyk.y;
result.k = cmyk.k;
break;
}
case HSV_MODEL: {
HSV_Color hsv = rgb_to_hsv(rgb);
result.h = hsv.h;
result.s = hsv.s;
result.v = hsv.v;
break;
}
}

return result;
}

// Структура для передачи параметров в поток
typedef struct {
RGB_Color* input;
HSV_Color* output;
int start_idx;
int end_idx;
HSV_Color* lut; // Указатель на таблицу предвычислений
} ThreadData;

// Функция для вычисления таблицы RGB -> HSV (для часто используемых значений)
HSV_Color* create_rgb_to_hsv_lut() {
// Создаем таблицу для 32^3 = 32768 цветов (компромисс между памятью и точностью)
HSV_Color* lut = (HSV_Color*)malloc(32 * 32 * 32 * sizeof(HSV_Color));

for (int r = 0; r < 32; r++) {
for (int g = 0; g < 32; g++) {
for (int b = 0; b < 32; b++) {
// Масштабируем значения к полному 8-битному диапазону
RGB_Color rgb = {
(uint8_t)((r * 255) / 31),
(uint8_t)((g * 255) / 31),
(uint8_t)((b * 255) / 31)
};

// Вычисляем точное значение HSV для этого цвета
HSV_Color hsv = rgb_to_hsv(rgb);

// Сохраняем в таблице
lut[(r << 10) | (g << 5) | b] = hsv;
}
}
}

return lut;
}

// Функция потока для параллельной конвертации
void* convert_thread_func(void* arg) {
ThreadData* data = (ThreadData*)arg;

for (int i = data->start_idx; i < data->end_idx; i++) {
RGB_Color rgb = data->input[i];

// Используем таблицу предвычислений с линейной интерполяцией
int r_idx = (rgb.r * 31) / 255;
int g_idx = (rgb.g * 31) / 255;
int b_idx = (rgb.b * 31) / 255;

// Быстрый поиск по таблице
data->output[i] = data->lut[(r_idx << 10) | (g_idx << 5) | b_idx];
}

return NULL;
}

// Функция для конвертации изображения с использованием оптимизаций
void convert_image_rgb_to_hsv_optimized(RGB_Color* input, HSV_Color* output, int width, int height) {
int num_pixels = width * height;
int num_threads = 8; // Или определять динамически на основе доступных ядер
pthread_t threads[num_threads];
ThreadData thread_data[num_threads];

// Создаем таблицу предвычислений
HSV_Color* lut = create_rgb_to_hsv_lut();

// Запускаем потоки для параллельной обработки
int pixels_per_thread = num_pixels / num_threads;
for (int i = 0; i < num_threads; i++) {
thread_data[i].input = input;
thread_data[i].output = output;
thread_data[i].start_idx = i * pixels_per_thread;
thread_data[i].end_idx = (i == num_threads – 1) ? num_pixels : (i + 1) * pixels_per_thread;
thread_data[i].lut = lut;

pthread_create(&threads[i], NULL, convert_thread_func, &thread_data[i]);
}

// Ожидаем завершения всех потоков
for (int i = 0; i < num_threads; i++) {
pthread_join(threads[i], NULL);
}

// Освобождаем память таблицы
free(lut);
}

#include <lcms2.h>

// Функция для преобразования с учетом цветовых профилей
void convert_with_color_profiles(RGB_Color* input, RGB_Color* output, int num_pixels,
const char* input_profile_path, const char* output_profile_path) {
// Загрузка цветовых профилей
cmsHPROFILE input_profile = cmsOpenProfileFromFile(input_profile_path, "r");
cmsHPROFILE output_profile = cmsOpenProfileFromFile(output_profile_path, "r");

// Создание преобразования
cmsHTRANSFORM transform = cmsCreateTransform(
input_profile, TYPE_RGB_8, 
output_profile, TYPE_RGB_8,
INTENT_PERCEPTUAL, 0);

// Применение преобразования
cmsDoTransform(transform, input, output, num_pixels);

// Освобождение ресурсов
cmsDeleteTransform(transform);
cmsCloseProfile(input_profile);
cmsCloseProfile(output_profile);
}