如何使用OpenCV减少图像中的颜色数量？

Question

我有一组图像文件，我想将它们的颜色数减少到64.如何使用OpenCV来完成这个？

我需要这个，所以我可以使用64大小的图像直方图。 我正在实施CBIR技术

我想要的是将颜色量化为4位调色板。

Answer 1

OpenCV 2 Computer Vision Application Programming Cookbook ：

涵盖了这个主题

第2章显示了一些简化操作，其中一个在C ++中演示过：

#include <iostream>
#include <vector>

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>


void colorReduce(cv::Mat& image, int div=64)
{    
    int nl = image.rows;                    // number of lines
    int nc = image.cols * image.channels(); // number of elements per line

    for (int j = 0; j < nl; j++)
    {
        // get the address of row j
        uchar* data = image.ptr<uchar>(j);

        for (int i = 0; i < nc; i++)
        {
            // process each pixel
            data[i] = data[i] / div * div + div / 2;
        }
    }
}

int main(int argc, char* argv[])
{   
    // Load input image (colored, 3-channel, BGR)
    cv::Mat input = cv::imread(argv[1]);
    if (input.empty())
    {
        std::cout << "!!! Failed imread()" << std::endl;
        return -1;
    } 

    colorReduce(input);

    cv::imshow("Color Reduction", input);   
    cv::imwrite("output.jpg", input);   
    cv::waitKey(0);

    return 0;
}

您可以在下面找到此操作的输入图像（左）和输出（右）：

Answer 2

您可能会考虑使用K-means，但在这种情况下，它很可能会非常慢。更好的方法可能是自己“手动”执行此操作。假设您有CV_8UC3类型的图像，即每个像素由0到255（Vec3b）的3个RGB值表示的图像。您可以将这256个值“映射”为仅4个特定值，这将产生4 x 4 x 4 = 64种可能的颜色。

我有一个数据集，我需要确保暗=黑，亮=白，并减少之间所有颜色的数量。这就是我所做的（C ++）：

inline uchar reduceVal(const uchar val)
{
    if (val < 64) return 0;
    if (val < 128) return 64;
    return 255;
}

void processColors(Mat& img)
{
    uchar* pixelPtr = img.data;
    for (int i = 0; i < img.rows; i++)
    {
        for (int j = 0; j < img.cols; j++)
        {
            const int pi = i*img.cols*3 + j*3;
            pixelPtr[pi + 0] = reduceVal(pixelPtr[pi + 0]); // B
            pixelPtr[pi + 1] = reduceVal(pixelPtr[pi + 1]); // G
            pixelPtr[pi + 2] = reduceVal(pixelPtr[pi + 2]); // R
        }
    }
}

导致[0,64)成为0，[64,128) - ＆gt; 64和[128,255) - ＆gt; 255，产生27种颜色：

对我而言，这似乎比其他答案中提到的任何其他内容更整洁，更清晰，更快。

您也可以考虑将这些值减少到某个数字的倍数之一，比如说：

inline uchar reduceVal(const uchar val)
{
    if (val < 192) return uchar(val / 64.0 + 0.5) * 64;
    return 255;
}

将产生一组5个可能的值：{0, 64, 128, 192, 255}，即125种颜色。

Answer 3

有很多方法可以做到这一点。 jeff7建议的方法没问题，但有些缺点是：

• 方法1具有参数N和M，您必须选择它们，并且还必须将其转换为另一个颜色空间。
• 方法2回答可能非常慢，因为你应该计算一个16.7 Milion的箱形直方图并按频率排序（以获得64个更高的频率值）

我喜欢使用基于最高位的算法来使用RGB颜色并将其转换为64色图像。如果你正在使用C / OpenCV，你可以使用类似下面的功能。

如果您正在使用灰度图像，我建议使用OpenCV 2.3的LUT（）函数，因为它更快。有一个关于如何使用LUT减少颜色数量的教程。请参阅：Tutorial: How to scan images, lookup tables...但是，如果您使用RGB图像，我会发现它更复杂。

void reduceTo64Colors(IplImage *img, IplImage *img_quant) {
    int i,j;
    int height   = img->height;   
    int width    = img->width;    
    int step     = img->widthStep;

    uchar *data = (uchar *)img->imageData;
    int step2 = img_quant->widthStep;
    uchar *data2 = (uchar *)img_quant->imageData;

    for (i = 0; i < height ; i++)  {
        for (j = 0; j < width; j++)  {

          // operator XXXXXXXX & 11000000 equivalent to  XXXXXXXX AND 11000000 (=192)
          // operator 01000000 >> 2 is a 2-bit shift to the right = 00010000 
          uchar C1 = (data[i*step+j*3+0] & 192)>>2;
          uchar C2 = (data[i*step+j*3+1] & 192)>>4;
          uchar C3 = (data[i*step+j*3+2] & 192)>>6;

          data2[i*step2+j] = C1 | C2 | C3; // merges the 2 MSB of each channel
        }     
    }
}

Answer 4

这是使用带有cv2.kmeans的K-Means聚类的颜色量化的Python实现。想法是减少图像中不同颜色的数量，同时尽可能保留图像的颜色外观。结果如下：

输入->输出

代码

import cv2
import numpy as np

def kmeans_color_quantization(image, clusters=8, rounds=1):
    h, w = image.shape[:2]
    samples = np.zeros([h*w,3], dtype=np.float32)
    count = 0

    for x in range(h):
        for y in range(w):
            samples[count] = image[x][y]
            count += 1

    compactness, labels, centers = cv2.kmeans(samples,
            clusters, 
            None,
            (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10000, 0.0001), 
            rounds, 
            cv2.KMEANS_RANDOM_CENTERS)

    centers = np.uint8(centers)
    res = centers[labels.flatten()]
    return res.reshape((image.shape))

image = cv2.imread('1.jpg')
result = kmeans_color_quantization(image, clusters=8)
cv2.imshow('result', result)
cv2.waitKey()     

Answer 5

这里建议的答案非常好。我想我也会添加我的想法。我在这里遵循许多评论的表述，据说64个颜色可以用RGB图像中每个通道的2位表示。

下面的代码中的函数将图像和量化所需的位数作为输入。它使用位操作来降低＆＃39; LSB位并仅保留所需的位数。结果是一种灵活的方法，可以将图像量化为任意数量的位。

#include "include\opencv\cv.h"
#include "include\opencv\highgui.h"

// quantize the image to numBits 
cv::Mat quantizeImage(const cv::Mat& inImage, int numBits)
{
    cv::Mat retImage = inImage.clone();

    uchar maskBit = 0xFF;

    // keep numBits as 1 and (8 - numBits) would be all 0 towards the right
    maskBit = maskBit << (8 - numBits);

    for(int j = 0; j < retImage.rows; j++)
        for(int i = 0; i < retImage.cols; i++)
        {
            cv::Vec3b valVec = retImage.at<cv::Vec3b>(j, i);
            valVec[0] = valVec[0] & maskBit;
            valVec[1] = valVec[1] & maskBit;
            valVec[2] = valVec[2] & maskBit;
            retImage.at<cv::Vec3b>(j, i) = valVec;
        }

        return retImage;
}


int main ()
{
    cv::Mat inImage;
    inImage = cv::imread("testImage.jpg");
    char buffer[30];
    for(int i = 1; i <= 8; i++)
    {
        cv::Mat quantizedImage = quantizeImage(inImage, i);
        sprintf(buffer, "%d Bit Image", i);
        cv::imshow(buffer, quantizedImage);

        sprintf(buffer, "%d Bit Image.png", i);
        cv::imwrite(buffer, quantizedImage);
    }

    cv::waitKey(0);
    return 0;
}

以下是上述函数调用中使用的图像：

每个RGB通道量化为2位的图像（总共64种颜色）：

每个通道3位：

4位......

Answer 6

在OpenCV库中已经有了K-means聚类算法。简而言之，它确定哪个是最好的质心，围绕这些质心聚类数据的用户定义的k值（=无簇）。因此，在您的情况下，您可以找到质心，在该质心周围为给定值k = 64聚类像素值。如果你谷歌周围有详细信息。 Here是k-means的简短介绍。

类似于你可能尝试的东西在SO使用k-means在这里询问，希望它有所帮助。

另一种方法是在OpenCV中使用pyramid mean shift filter函数。它会产生一些“扁平”的图像，即颜色数量较少，因此它可以帮助你。

Answer 7

假设您想对所有图像使用相同的64种颜色（即每个图像未优化的调色板），我至少可以想到几个选择：

1）转换为Lab或YCrCb色彩空间，并使用N位亮度和每个颜色通道的M位进行量化，N应大于M.

2）在所有训练图像上计算颜色值的3D直方图，然后选择具有最大bin值的64种颜色。通过为每个像素分配训练集中最接近的bin的颜色来量化图像。

方法1是最通用且最容易实现的，而方法2可以更好地根据您的特定数据集进行定制。

更新： 例如，32种颜色是5位，因此为亮度通道分配3位，为每个颜色通道分配1位。为了进行这种量化，将亮度通道的整数除以2 ^ 8/2 ^ 3 = 32，每个颜色通道按2 ^ 8/2 ^ 1 = 128进行。现在只有8种不同的亮度值和2种不同的颜色通道每。将这些值重新组合成一个整数进行位移或数学运算（量化颜色值=亮度* 4 + color1 * 2 + color2）;

Answer 8

简单的按位操作并具有适当的位掩码就可以解决问题。

python，用于64种颜色，

img = img & int("11000000", 2)

RGB图像的颜色数量应该是一个完美的立方（在3个通道中相同）。

对于此方法，通道的可能值的数量应为2的幂。（此检查将被代码忽略，并接受下一个较低的2的幂）

import numpy as np
import cv2 as cv


def is_cube(n):
    cbrt = np.cbrt(n)
    return cbrt ** 3 == n, int(cbrt)


def reduce_color_space(img, n_colors=64):
    n_valid, cbrt = is_cube(n_colors)

    if not n_valid:
        print("n_colors should be a perfect cube")
        return

    n_bits = int(np.log2(cbrt))

    if n_bits > 8:
        print("Can't generate more colors")
        return

    bitmask = int(f"{'1' * n_bits}{'0' * (8 - n_bits)}", 2)

    return img & bitmask


img = cv.imread("image.png")

cv.imshow("orig", img)
cv.imshow("reduced", reduce_color_space(img))

cv.waitKey(0)

Answer 9

你为什么不做矩阵乘法/除法？值将自动舍入。

伪代码：

  

将您的频道转换为无符号字符（CV_8UC3），
  被除以   总颜色/所需颜色。 Mat = Mat /（256/64）。小数点   将被截断   乘以相同的数字。 Mat = mat * 4

完成。现在每个频道只包含64种颜色。