如何将ARGB颜色值转换为描述性文本颜色？求API/替代方案

你的自定义阈值判断逻辑依赖固定数值区间，容易出现颜色匹配不准确或"Unknown Color"过多的情况，以下是几种更可靠的方案：

一、使用第三方颜色命名库 #

直接借助成熟库处理颜色到名称的映射，这类库内置大量调校后的颜色数据，匹配精度更高：

ColorNamer #

这是专门用于颜色命名的Java库，支持根据RGB值返回贴近人类认知的颜色名称，还可调整匹配严格度。

1. 引入Gradle依赖：

implementation 'com.github.arcadefire:namer:1.0.0'

2. 使用示例：

import com.github.arcadefire.color.Namer;

public String argbToTextColor(int argb) {
    int red = (argb >> 16) & 0xFF;
    int green = (argb >> 8) & 0xFF;
    int blue = argb & 0xFF;
    
    Namer namer = new Namer();
    return namer.name(red, green, blue);
}

二、改进自定义匹配逻辑：基于颜色距离的匹配 #

放弃硬阈值判断，通过计算输入颜色与标准颜色的欧氏距离选择最接近的名称，更符合颜色的连续特性：

import java.util.HashMap;
import java.util.Map;

public class ColorUtils {
    // 定义标准颜色的RGB值
    private static final Map<String, int[]> STANDARD_COLORS = new HashMap<>();
    
    static {
        STANDARD_COLORS.put("Black", new int[]{0, 0, 0});
        STANDARD_COLORS.put("White", new int[]{255, 255, 255});
        STANDARD_COLORS.put("Red", new int[]{255, 0, 0});
        STANDARD_COLORS.put("Green", new int[]{0, 255, 0});
        STANDARD_COLORS.put("Blue", new int[]{0, 0, 255});
        STANDARD_COLORS.put("Yellow", new int[]{255, 255, 0});
        STANDARD_COLORS.put("Magenta", new int[]{255, 0, 255});
        STANDARD_COLORS.put("Cyan", new int[]{0, 255, 255});
        STANDARD_COLORS.put("Orange", new int[]{255, 165, 0});
        STANDARD_COLORS.put("Gray", new int[]{128, 128, 128});
        STANDARD_COLORS.put("Purple", new int[]{128, 0, 128});
        STANDARD_COLORS.put("Pink", new int[]{255, 192, 203});
        STANDARD_COLORS.put("Brown", new int[]{165, 42, 42});
    }

    public String argbToTextColor(int argb) {
        int red = (argb >> 16) & 0xFF;
        int green = (argb >> 8) & 0xFF;
        int blue = argb & 0xFF;

        String closestColor = "Unknown Color";
        int minDistance = Integer.MAX_VALUE;
        // 设定最大可接受距离，超过则返回未知
        int maxAcceptableDistance = 60;

        for (Map.Entry<String, int[]> entry : STANDARD_COLORS.entrySet()) {
            int[] standardRgb = entry.getValue();
            // 计算RGB空间的欧氏距离
            int distance = (int) Math.sqrt(
                Math.pow(red - standardRgb[0], 2) +
                Math.pow(green - standardRgb[1], 2) +
                Math.pow(blue - standardRgb[2], 2)
            );
            if (distance < minDistance) {
                minDistance = distance;
                closestColor = entry.getKey();
            }
        }

        return minDistance <= maxAcceptableDistance ? closestColor : "Unknown Color";
    }
}

三、优化颜色空间：使用HSV提升匹配准确性 #

RGB空间的距离不完全对应人眼感知的颜色差异，转换成**HSV（色相-饱和度-明度）**空间计算距离，匹配结果更贴合人类视觉：

import android.graphics.Color;
import java.util.HashMap;
import java.util.Map;

public class ColorUtils {
    private static final Map<String, float[]> STANDARD_HSV = new HashMap<>();
    
    static {
        // 初始化标准颜色的HSV值
        STANDARD_HSV.put("Red", Color.RGBToHSV(255, 0, 0, null));
        STANDARD_HSV.put("Orange", Color.RGBToHSV(255, 165, 0, null));
        STANDARD_HSV.put("Yellow", Color.RGBToHSV(255, 255, 0, null));
        STANDARD_HSV.put("Green", Color.RGBToHSV(0, 255, 0, null));
        STANDARD_HSV.put("Blue", Color.RGBToHSV(0, 0, 255, null));
        // 补充其他标准颜色的HSV值...
    }

    public String argbToTextColor(int argb) {
        int red = (argb >> 16) & 0xFF;
        int green = (argb >> 8) & 0xFF;
        int blue = argb & 0xFF;
        
        float[] inputHsv = new float[3];
        Color.RGBToHSV(red, green, blue, inputHsv);

        String closestColor = "Unknown Color";
        double minWeightedDistance = Double.MAX_VALUE;

        for (Map.Entry<String, float[]> entry : STANDARD_HSV.entrySet()) {
            float[] standardHsv = entry.getValue();
            // 处理色相的环形连续性（0°和360°为同一颜色）
            double hDistance = Math.min(
                Math.abs(inputHsv[0] - standardHsv[0]),
                360 - Math.abs(inputHsv[0] - standardHsv[0])
            );
            // 给色相更高权重（3倍），饱和度和明度权重为1
            double weightedDistance = hDistance * 3 + 
                                     Math.abs(inputHsv[1] - standardHsv[1]) + 
                                     Math.abs(inputHsv[2] - standardHsv[2]);
            
            if (weightedDistance < minWeightedDistance) {
                minWeightedDistance = weightedDistance;
                closestColor = entry.getKey();
            }
        }

        return closestColor;
    }
}

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