Kotlin/Java中如何高效显示带自定义调色板的单通道索引图像？

好问题！在Android的Kotlin/Java开发场景下，我们有几种实用且高效的方案来实现你的需求，下面我会逐一拆解你的疑问：

• 大部分场景下需要手动将单通道矩阵转换为RGB Bitmap，这是最直观、兼容性最好的方案；
• Android原生没有直接支持自定义调色板的单通道图像显示控件，但我们可以通过自定义View或ColorFilter间接实现；
• 最优方案取决于你的内存和性能需求，下面是具体实现细节：

1. 推荐方案：手动转换为RGB Bitmap（简单高效） #

因为你的像素值范围只有0-14，非常小，我们可以预先定义一个调色板数组，然后遍历单通道矩阵，把每个像素值映射为对应的RGB颜色，生成标准的RGB Bitmap后直接用ImageView显示即可。

步骤1：定义自定义调色板 #

// 索引对应你的像素值0-14，按需替换成你需要的颜色
private val colorPalette = intArrayOf(
    Color.BLACK,    // 0
    Color.RED,      // 1
    Color.GREEN,    // 2
    Color.BLUE,     // 3
    Color.CYAN,     // 4
    Color.MAGENTA,  // 5
    Color.YELLOW,   // 6
    Color.GRAY,     // 7
    Color.DKGRAY,   // 8
    Color.LTGRAY,   // 9
    Color.WHITE,    // 10
    Color.parseColor("#FFA500"), // 11：橙色
    Color.parseColor("#800080"), // 12：紫色
    Color.parseColor("#00FF00"), // 13：亮绿
    Color.parseColor("#0000FF")  // 14：亮蓝
)

步骤2：单通道矩阵转RGB Bitmap #

fun convertToRgbBitmap(grayMatrix: Array<IntArray>, width: Int, height: Int): Bitmap {
    val rgbPixels = IntArray(width * height)
    var pixelIndex = 0
    
    // 遍历矩阵，映射颜色
    for (y in 0 until height) {
        for (x in 0 until width) {
            val pixelValue = grayMatrix[y][x]
            // 确保像素值在0-14范围内，避免数组越界
            val safeValue = pixelValue.coerceIn(0, 14)
            rgbPixels[pixelIndex++] = colorPalette[safeValue]
        }
    }
    
    // 创建ARGB_8888格式的Bitmap（原生控件都支持）
    return Bitmap.createBitmap(rgbPixels, width, height, Bitmap.Config.ARGB_8888)
}

步骤3：显示Bitmap #

// 假设你已经有了单通道矩阵grayMatrix
val rgbBitmap = convertToRgbBitmap(grayMatrix, width, height)
imageView.setImageBitmap(rgbBitmap)

这种方案的优势是：

• 实现简单，代码可读性高；
• 性能优异：线性遍历的时间复杂度是O(n)，对于常规尺寸的图像完全无压力；
• 兼容性拉满：所有Android原生控件都支持显示RGB Bitmap。

2. 内存敏感场景：自定义View实时绘制 #

如果你的矩阵尺寸特别大（比如4K以上分辨率），提前转换为RGB Bitmap会占用较多内存（ARGB_8888格式每个像素占4字节），这时候可以用自定义View实时绘制，避免提前占用大量内存。

自定义View实现 #

class PaletteMatrixView(context: Context, attrs: AttributeSet?) : View(context, attrs) {
    // 自定义调色板
    private val colorPalette = intArrayOf(/* 填充你的颜色 */)
    private var grayMatrix: Array<IntArray>? = null
    private val drawPaint = Paint().apply { isAntiAlias = false } // 关闭抗锯齿，提升绘制速度

    // 设置要显示的矩阵
    fun setMatrix(matrix: Array<IntArray>) {
        grayMatrix = matrix
        requestLayout() // 矩阵尺寸变化时重新布局
        invalidate() // 触发重绘
    }

    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)
        val matrix = grayMatrix ?: return
        val matrixWidth = matrix[0].size
        val matrixHeight = matrix.size
        
        // 计算每个像素在View上的绘制尺寸（适配View大小）
        val pixelDrawWidth = measuredWidth.toFloat() / matrixWidth
        val pixelDrawHeight = measuredHeight.toFloat() / matrixHeight

        // 遍历矩阵绘制每个像素对应的颜色块
        for (y in 0 until matrixHeight) {
            for (x in 0 until matrixWidth) {
                val pixelValue = matrix[y][x]
                val safeValue = pixelValue.coerceIn(0, 14)
                drawPaint.color = colorPalette[safeValue]
                
                // 计算当前像素的绘制区域
                val left = x * pixelDrawWidth
                val top = y * pixelDrawHeight
                val right = left + pixelDrawWidth
                val bottom = top + pixelDrawHeight
                
                canvas.drawRect(left, top, right, bottom, drawPaint)
            }
        }
    }

    // 保持矩阵的宽高比
    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec)
        val matrix = grayMatrix ?: return
        
        val desiredWidth = matrix[0].size
        val desiredHeight = matrix.size
        val widthMode = MeasureSpec.getMode(widthMeasureSpec)
        val widthSize = MeasureSpec.getSize(widthMeasureSpec)
        val heightMode = MeasureSpec.getMode(heightMeasureSpec)
        val heightSize = MeasureSpec.getSize(heightMeasureSpec)

        val finalWidth = when (widthMode) {
            MeasureSpec.EXACTLY -> widthSize
            else -> desiredWidth
        }
        val finalHeight = when (heightMode) {
            MeasureSpec.EXACTLY -> heightSize
            else -> desiredHeight
        }
        setMeasuredDimension(finalWidth, finalHeight)
    }
}

使用自定义View #

// 在布局中添加自定义View
val paletteView = findViewById<PaletteMatrixView>(R.id.palette_matrix_view)
paletteView.setMatrix(grayMatrix)

这种方案的优势是内存占用极低，不需要提前生成整个RGB Bitmap，适合超大矩阵的显示场景。

3. 底层原生方案：利用Alpha通道+ColorFilter #

如果你想尝试更底层的实现，可以用Bitmap.Config.ALPHA_8创建单通道Bitmap，然后通过ColorFilter将Alpha值映射为自定义颜色。不过这种方式配置起来比较繁琐，不如前两种方案直观，仅作了解：

// 创建单通道Alpha Bitmap
fun createAlphaBitmap(grayMatrix: Array<IntArray>, width: Int, height: Int): Bitmap {
    val alphaPixels = ByteArray(width * height)
    var index = 0
    for (y in 0 until height) {
        for (x in 0 until width) {
            // 将0-14的像素值直接存入Alpha通道
            alphaPixels[index++] = grayMatrix[y][x].toByte()
        }
    }
    return Bitmap.createBitmap(width, height, Bitmap.Config.ALPHA_8).apply {
        copyPixelsFromBuffer(ByteBuffer.wrap(alphaPixels))
    }
}

// 配置ColorFilter映射颜色
fun getPaletteColorFilter(): ColorFilter {
    val colorMatrix = ColorMatrix()
    // 这里需要构建一个矩阵，将0-14的Alpha值映射到对应的RGB颜色
    // 由于ColorMatrix默认处理0-255范围的值，需要先做归一化处理
    val scale = 1f / 14f
    colorMatrix.setScale(scale, scale, scale, 1f)
    // 后续需手动将归一化值与调色板颜色绑定，过程繁琐，不如直接转RGB Bitmap简单
    return ColorMatrixColorFilter(colorMatrix)
}

使用时：

val alphaBitmap = createAlphaBitmap(grayMatrix, width, height)
imageView.setImageBitmap(alphaBitmap)
imageView.colorFilter = getPaletteColorFilter()

• 最优选择：常规尺寸图像用「手动转RGB Bitmap+ImageView」，简单高效；
• 内存敏感场景：用自定义View实时绘制；
• 原生控件支持：没有直接支持的原生控件，但可以通过上述方案间接实现；
• 是否需要手动转RGB：大部分场景下需要，因为这是最兼容、最直观的方式。

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