如何用curses模块显示HSL模型计算的颜色并匹配长度？

基于HSL（色相Hue、饱和度Saturation、亮度Lightness）三个核心组件实现颜色条：

• 色相：代表颜色本身（如红、绿、蓝），取值为0-360度的角度值
• 饱和度：表示颜色的纯度或鲜艳度，范围0-100%
• 亮度：控制颜色明暗，范围0-100%

原C代码运行后可生成预期的渐变颜色条效果，但将代码转换为curses模块实现时，得到的颜色条效果完全不同，且无法匹配原代码的颜色条长度。

原C代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

typedef struct {
  int r;
  int g;
  int b;
} RGB;

RGB newRGB(int r, int g, int b) {
  RGB color;
  color.r = r;
  color.g = g;
  color.b = b;
  return color;
}

void calcColor(RGB* colors, int totalColors, int currentIndex, float saturation, float lightness);

int main() {
  int totalColors = 60;
  RGB colors[totalColors];
  float saturation = 1.0;
  float lightness = 0.3;

  int end = totalColors - 18; // Define the final index of the last desired colors
  int start = end - 42;

  for (int i = start; i <= end; i++) {
    calcColor(&colors[i], totalColors, i, saturation, lightness);
  }

  // Print the colors in a block
  for (int i = end; i >= start; i--) {
    printf("\033[48;2;%d;%d;%dm  \033[0m", colors[i].r, colors[i].g, colors[i].b);
  }

  return 0;
}

void calcColor(RGB* colors, int totalColors, int currentIndex, float saturation, float lightness) {
  float hue = currentIndex * (360.0 / totalColors);
  float chroma = (1 - fabs(2 * lightness - 1)) * saturation;
  float x = chroma * (1 - fabs(fmod(hue / 60, 2) - 1));
  float m = lightness - chroma / 2;

  float r, g, b;
  if (hue >= 0 && hue < 60) {
    r = chroma;
    g = x;
    b = 0;
  } else if (hue >= 60 && hue < 120) {
    r = x;
    g = chroma;
    b = 0;
  } else if (hue >= 120 && hue < 180) {
    r = 0;
    g = chroma;
    b = x;
  } else if (hue >= 180 && hue < 240) {
    r = 0;
    g = x;
    b = chroma;
  } else if (hue >= 240 && hue < 300) {
    r = x;
    g = 0;
    b = chroma;
  } else {
    r = chroma;
    g = 0;
    b = x;
  }

  colors->r = (r + m) * 255;
  colors->g = (g + m) * 255;
  colors->b = (b + m) * 255;
}

问题分析 #

1. 颜色映射偏差：curses默认依赖终端预设颜色对，若直接用简化的RGB转索引逻辑，会丢失颜色精度，导致效果不符。需通过init_color精确设置自定义颜色。
2. 长度不匹配：原C代码生成43个颜色块（start到end共42+1个），每个块用两个空格填充。curses实现时需保证循环范围、输出字符数与原代码完全对齐。

修复步骤 #

1. 复用HSL转RGB逻辑：完全照搬原C代码的颜色计算逻辑，确保生成的RGB值和原代码一致。
2. 初始化自定义颜色：利用curses的init_color接口，将计算出的RGB值（转换为0-1000范围）设置为自定义颜色，避免覆盖默认颜色。
3. 对齐输出逻辑：按照原代码的反向顺序输出颜色块，每个块输出两个空格，保证长度和视觉效果一致。

正确的curses实现代码 #

import curses
import math

def calc_color(total_colors, current_index, saturation, lightness):
    hue = current_index * (360.0 / total_colors)
    chroma = (1 - abs(2 * lightness - 1)) * saturation
    x = chroma * (1 - abs(math.fmod(hue / 60, 2) - 1))
    m = lightness - chroma / 2

    r, g, b = 0, 0, 0
    if 0 <= hue < 60:
        r, g, b = chroma, x, 0
    elif 60 <= hue < 120:
        r, g, b = x, chroma, 0
    elif 120 <= hue < 180:
        r, g, b = 0, chroma, x
    elif 180 <= hue < 240:
        r, g, b = 0, x, chroma
    elif 240 <= hue < 300:
        r, g, b = x, 0, chroma
    else:
        r, g, b = chroma, 0, x

    # 转换为curses要求的0-1000范围RGB值
    return int((r + m) * 1000), int((g + m) * 1000), int((b + m) * 1000)

def main(stdscr):
    # 隐藏光标
    curses.curs_set(0)
    # 检查终端颜色支持
    if not curses.has_colors():
        print("当前终端不支持颜色显示")
        return
    curses.start_color()

    total_colors = 60
    saturation = 1.0
    lightness = 0.3
    end = total_colors - 18
    start = end - 42

    # 预计算并初始化所有需要的颜色
    color_pairs = {}
    color_idx = 10  # 从10开始，避免覆盖终端默认颜色
    for i in range(start, end + 1):
        r, g, b = calc_color(total_colors, i, saturation, lightness)
        curses.init_color(color_idx, r, g, b)
        curses.init_pair(color_idx, curses.COLOR_WHITE, color_idx)
        color_pairs[i] = color_idx
        color_idx += 1

    # 反向输出颜色块，和原代码顺序一致
    y_pos = 0
    x_pos = 0
    for i in range(end, start - 1, -1):
        stdscr.attron(curses.color_pair(color_pairs[i]))
        stdscr.addstr(y_pos, x_pos, "  ")
        stdscr.attroff(curses.color_pair(color_pairs[i]))
        x_pos += 2

    stdscr.refresh()
    stdscr.getch()

if __name__ == "__main__":
    curses.wrapper(main)

关键说明 #

• 颜色范围转换：curses的init_color接受0-1000的RGB值，因此将原代码中0-255的比例值直接转换为0-1000，保证颜色精度一致。
• 循环范围对齐：严格使用原代码的start和end计算逻辑，确保生成43个颜色块，且输出顺序与原代码反向一致。
• 颜色对绑定：每个自定义颜色对应一个颜色对，设置背景色为目标颜色，前景色设为白色不影响视觉效果，输出两个空格模拟原代码的块大小。

内容的提问来源于stack exchange，提问作者Exponecial