Bayer 模式图像(bggr ,grbg, gbrg)转rgb888

1.Bayer 模式图像

Bayer 模式是一种用于数字图像捕捉的常见模式，特别是在单个传感器摄像头中广泛使用。Bayer 模式是一种通过排列红、绿、蓝滤色阵列以及插值算法来捕捉彩色图像的技术。

Bayer 模式图像是由一个仅包含红、绿、蓝三种颜色中的一种的滤色阵列构成的，其中每个像素只能感知其中一种颜色的光。这种滤色阵列的排列方式通常遵循一种固定的模式，比如 BGGR、RGGB 或者类似的方式。

对于一个 Bayer 模式的图像，每个像素只有一种颜色的信息，而其他两种颜色的信息需要通过插值算法来估算得到。插值算法会利用附近像素的颜色信息来推测缺失的颜色信息，从而生成完整的彩色图像。

要将 Bayer 模式图像转换为完整的彩色图像，需要进行一系列的处理步骤，如色彩插值、白平衡校正、色彩校正等。这些处理步骤根据每个像素的原始数据和相邻像素的信息来计算出最终的彩色值。最终的图像会包含完整的 RGB 信息，使我们能够看到真实的彩色图像。

2.bayer模式下的排列方式说明

Bayer 模式图像的排列方式通常用四个字母的缩写来表示，其中每个字母代表一个颜色通道（红、绿、蓝）。

以下是一些常见的 Bayer 模式排列方式的说明：

1. RGGB：在 RGGB Bayer 模式中，第一行的第一个像素是红色（R），第一行的第二个像素是绿色（G），第二行的第一个像素是绿色（G），第二行的第二个像素是蓝色（B）。这种排列方式在许多传感器中被广泛使用。

2. GRBG：在 GRBG Bayer 模式中，第一行的第一个像素是绿色（G），第一行的第二个像素是红色（R），第二行的第一个像素是蓝色（B），第二行的第二个像素是绿色（G）。这种排列方式也常见于许多传感器中。

3. BGGR：在 BGGR Bayer 模式中，第一行的第一个像素是蓝色（B），第一行的第二个像素是绿色（G），第二行的第一个像素是绿色（G），第二行的第二个像素是红色（R）。这种排列方式也是常见的。

 3.Bayer 模式图像转换rgb888的常用方式

将 Bayer 模式图像转换为 RGB888 图像的常用方式是色彩插值。这种方法使用插值算法来完成缺失的颜色通道的估算。

常见的色彩插值算法有两种：

1. 线性插值：在这种插值算法中，缺失的颜色像素将使用其邻近像素的值进行插值。例如，对于 BGGR Bayer 模式图像，缺失的绿色像素可以通过其周围的四个相邻像素的平均值来得到。对于缺失的红色或蓝色像素，可以使用相邻行或相邻列的值计算。

2. 修正的 bilinear 插值：这是一种更精确的插值算法，它对线性插值进行了改进。在这种算法中，缺失的颜色像素将使用邻近像素和它们的邻近像素来进行插值。这种算法在处理高畸变图像时可以提供更好的效果。

4.线性插值方法详细介绍

线性插值是一种简单的插值算法，它通常用于将 Bayer 模式图像转换为 RGB 图像。它通过使用邻近像素的值来计算缺失的值。

具体来说，在 BGGR Bayer 模式中，绿色通道的缺失值可以通过使用周围的绿色像素值（左侧、右侧、上方和下方）的平均值进行线性插值。同样的方法也适用于红色和蓝色通道的情况，但需要使用相邻列或相邻行的值进行插值。

下面是一个简单的示意图，说明在绿色通道的情况下如何进行线性插值。假设绿色像素（绿点）的周围只有四个相邻像素（蓝点），则可以使用这些像素的平均值来计算该像素的值（黄点）：

B G B G B G
G * G * G *     *（待计算的像素）
B G B G B G
G * G * G *
B G B G B G

在红色和蓝色通道的情况下也是类似的，在确定相邻像素方向之后，使用这些像素的值进行插值计算即可。

 5.实现

这里用了两种方法的结合，即 “101 方法” 和 “RGB 插值方法” 来处理图像数据。

首先，根据输入图像的宽度和高度，计算出源图像的宽度和高度，并创建一个新的数组 src_data，其大小为源图像的宽度乘以高度。

接下来，在 “101 方法” 中，使用双层循环将原始图像的像素数据复制到 src_data 数组中，使用一定的偏移位置来确保每个像素的正确位置。

然后，根据 “RGB 插值方法” 对 src_data 数组进行边界的填充。具体的操作是：将第二行的像素复制到第一行，将倒数第二行的像素复制到倒数第一行；将第二列的像素复制到第一列，将倒数第二列的像素复制到倒数第一列。这样做可以确保边界的像素也可以参与后续的插值计算。

最后，通过两层嵌套的循环遍历源图像的每个像素。对于每个像素，根据其在源图像中的位置和相邻像素的值，使用 “RGB 插值方法” 来计算出 R、G、B 三个分量的值。具体的计算方式取决于源图像中像素的位置和颜色排列方式。

最终，将计算得到的 R、G、B 分量的值写入到目标图像的 image_rgb_data_888 数组中，并更新 dataIndex 的值，以便下一次写入。

根据不同的颜色排列方式（例如 “BGGR”、“GRBG”、“GBRG”），计算 R、G、B 分量的顺序不完全相同。每个分量的值是根据源图像中相邻像素的值进行插值计算得到的。这样处理后，最终得到的 image_rgb_data_888 数组即为转换后的 RGB 图像数据。

    int src_width = width + 2;
    int src_height = height + 2;
 
    unsigned char *src_data = new unsigned char [src_width * src_height];
    /*  101填充法(例子)
         R  G  R  G  R G
         G *B *G *B *G B
         R *G *R *G *R G
         G *B *G *B *G B
         R *G *R *G *R G
         G  B  G  B  G B
    */
 
    for(int i = 0; i < height; i++)
    {
        for(int j = 0; j < width; j++)
        {
            src_data[src_width*(i + 1) + 1 + j] = data[width*i + j];
        }
    }
 
    /* 填充2行 */
    for(int i = 0; i < width; i++)
    {
        /*第1行*/
        src_data[1 + i] = src_data[src_width*2 + 1 + i];
 
        /*倒数第1行*/
        src_data[src_width*(src_height - 1) + 1 + i] = src_data[src_width*(src_height - 3) + 1 + i];
    }
 
    /* 填充2列 */
    for(int i = 0; i < src_height; i++)
    {
        /*第1列*/
        src_data[i * src_width + 0] = src_data[i * src_width + 2];
 
        /*倒数第1列*/
        src_data[i * src_width + src_width - 1] = src_data[i * src_width + src_width - 3];
    }
 
    int dataIndex = 0;  // 记录数据索引
    for(int i = 0; i < height; i++)
    {
        for(int j = 0; j < width; j++)
        {
            int index_1 = src_data[i*src_width + j];
            int index_2 = src_data[i*src_width + j + 1];
            int index_3 = src_data[i*src_width + j + 2];
            int index_4 = src_data[(i + 1)*src_width + j];
            int index_5 = src_data[(i + 1)*src_width + j + 1];
            int index_6 = src_data[(i + 1)*src_width + j + 2];
            int index_7 = src_data[(i + 2)*src_width + j];
            int index_8 = src_data[(i + 2)*src_width + j + 1];
            int index_9 = src_data[(i + 2)*src_width + j + 2];
 
            unsigned char index_r = 0;
            unsigned char index_g = 0;
            unsigned char index_b = 0;
/*bggr*/
            if((i % 2 == 0) && (j % 2 == 0)) //B
            {
                 //r
                 index_r = (index_1 + index_3 + index_7 + index_9)/4;
                 //g
                 index_g = (index_2 + index_4 + index_6 + index_8)/4;
                 //b
                 index_b = index_5;
            }
            if((i % 2 == 0) && (j % 2 != 0)) //g
           {
                //r
                index_r = (index_2 + index_8)/2;
                //g
                index_g = (index_1 + index_3 + index_5 + index_7 + index_9)/5;
                //b
                index_b = (index_4 + index_6)/2;
            }
           if((i % 2 != 0) && (j % 2 == 0)) //g
            {
                //r
                index_r = (index_4 + index_6)/2;
                //g
                index_g = (index_1 + index_3 + index_5 + index_7 + index_9)/5;
                //b
                index_b = (index_2 + index_8)/2;
           }
            if((i % 2 != 0) && (j % 2 != 0)) //r
          {
                //r
                index_r = index_5;
                //g
                index_g = (index_2 + index_4 + index_6 + index_8)/4;
                //b
                index_b = (index_1 + index_3 + index_7 + index_9)/4;
            }
/*grbg*/
            if((i % 2 == 0) && (j % 2 == 0)) //g
            {
                 //r
                 index_r = (index_4 + index_6)/2;
                 //g
                 index_g = (index_1 + index_3 + index_5 + index_7 + index_9)/5;
                 //b
                 index_b = (index_2+ index_8)/2;
            }
            if((i % 2 == 0) && (j % 2 != 0)) //r
            {
                //r
                index_r = index_5;
                //g
                index_g = (index_2 + index_4 + index_6 + index_8)/4;
                //b
                index_b = (index_1 + index_3 + index_5 + index_7)/4;
            }
            if((i % 2 != 0) && (j % 2 == 0)) //b
            {
                //r
                index_r = (index_1 + index_3 + index_5 + index_7)/4;
                //g
                index_g = (index_2 + index_4 + index_6 + index_8)/4;
                //b
                index_b = index_5;
            }
            if((i % 2 != 0) && (j % 2 != 0)) //g
            {
                //r
                index_r = (index_2 + index_8)/2;
                //g
                index_g = (index_1 + index_3 + index_5 + index_7 + index_9)/5;
                //b
                index_b = (index_4 + index_6)/2;
            }
 /*gbrg*/
            if((i % 2 == 0) && (j % 2 == 0)) //g
            {
                 //r
                 index_r = (index_2 + index_8)/2;
                 //g
                 index_g = (index_1 + index_3 + index_5 + index_7 + index_9)/5;
                 //b
                index_b = (index_4+ index_6)/2;
            }
            if((i % 2 == 0) && (j % 2 != 0)) //b
           {
               //r
                index_r = (index_1 + index_3 + index_7 + index_9)/4;
                //g
                index_g = (index_2 + index_4 + index_6 + index_8)/4;
                //b
                index_b = index_5;
            }
           if((i % 2 != 0) && (j % 2 == 0)) //r
            {
                //r
                index_r = index_5;
               //g
                index_g = (index_2 + index_4 + index_6 + index_8)/4;
                //b
                index_b = (index_1 + index_3 + index_7 + index_9)/4;
            }
            if((i % 2 != 0) && (j % 2 != 0)) //g
            {
               //r
               index_r = (index_4 + index_6)/2;
               //g
               index_g = (index_1 + index_3 + index_5 + index_7 + index_9)/5;
               //b
                index_b = (index_2 + index_8)/2;
           }
            image_rgb_data_888[dataIndex] = index_r;
            image_rgb_data_888[dataIndex + 1] = index_g;
            image_rgb_data_888[dataIndex + 2] = index_b;
 
 
            dataIndex += 3;  // 数据索引递增3，因为 RGB888 数据每个像素占用3个字节
 
        }