LINUX下简单实现ISP图像处理从RAW到RGB，BMP算法、RGB到JPEG库的使用（二）

呱呱青蛙呱呱

已于 2023-05-18 10:43:58 修改

阅读量901

点赞数 3

文章标签：图像处理 linux c语言

于 2023-05-18 10:39:07 首次发布

本文链接：https://blog.csdn.net/zzzzzz_9/article/details/130732196

版权

接上期图片处理后，还有图像进行色彩空间矩阵变换，伽马矫正，白平衡没讲。本期就来说说这三个操作对图片的处理作用以及效果。

白平衡：

白平衡是指相机或摄像机为了使图像中的白色看起来是真正的白色，需要对相机的感光元件进行调节的过程。白平衡的主要作用是消除光源色温对图像色彩的影响，确保图像中的白色看起来是真正的白色，从而使整个图像的色彩更加准确和自然。如果白平衡设置不正确，图像中的颜色就会偏色，影响图像的色彩还原效果。

白平衡有多种算法，可以在RAW域算白平衡系数，也可以在RGB域算白平衡系数，白平衡有两个系数GainA,GainB。白平衡的GainA和GainB是指在进行白平衡调节时，调整红色和蓝色通道的增益值。GainA代表红色通道的增益值，GainB代表蓝色通道的增益值。通过调整这两个通道的增益值，可以使得白色看起来更加真实自然，从而达到更好的色彩还原效果。在进行白平衡调节时，相机会根据所拍摄的场景的光源色温来自动调整GainA和GainB的值。对于不同的光源，需要进行不同的白平衡调节来达到最佳的色彩还原效果。

例如，在拍摄日落时，为了强调日落的暖色调，可以将色温调低，使图像呈现出比较暖的色调；在拍摄蓝天白云的风景时，为了突出蓝色的色调，可以将色温调高，使图像呈现出比较冷的色调。

下面我们就来说说白平衡系数的计算，这里采用的方法是在RGB域计算，然后再返回RAW域，对RAW域图像进行白平衡处理。下面请看白平衡的计算方法。

第一步：求出每个点的亮度Y

第二步：对Y进行分类求权重，不同亮度所占的百分比可以自己调整

第三步：判断它是否接近灰色

第四步：统计灰色的点求 GainR GainB

由下面代码可以看出是西安调到RGB域去算出白平衡系数，然后再次跳回到RAW域算白平衡。下面是主函数的部分代码：

#if 1
    image = thread_read_raw(RAW_FILE_NAME,5600,5600);//读取一张图片
    seek_bad_Pixel(image);//去坏点
    Black_Level_Correction_respective(image);//四通道黑电平
    Shadow_Correction(image, 0.2);//阴影矫正
    vector<vector<Pixel>> RGB = color_interpolation(image);//跳转到RGB域
    Return_GainR_GrainB RB = calculate_white_balance_nums(RGB);//获取白平衡系数
    white_balance(RB,image);//用拿到的系数做白平衡
    RGB = color_interpolation(image);//重新跳转到RGB域
    //matmul3x3_3x1(RGB); //色彩空间矩阵校正
    //reduce_red(RGB);//去过曝光过度产生的红斑
    //Gamma_correction(RGB,1.1); //伽马矫正
    //cruculation_R_G_B(RGB);
    //cout << RB.GainB << "  " << RB.GainR <<endl;
#endif
#if 1
    Raw_to_Bmp_Pixel16_Enablelow10(RGB,timer(BMP_FILE_NAME,(const char *)"bmp"));
#endif

白平衡参数计算函数：

Return_GainR_GrainB calculate_white_balance_nums(vector<vector<Pixel>> &image)
{
    // 开辟返回值结构体
    Return_GainR_GrainB return_GB;
    // 算出传入RGB数组的大小
    int width = image.size(), height = image[0].size();
    // 返回一个八位的值
    uint8_t balance_num = 0;
    double GainR = 0, GainB = 0;
    // 64位累加x像素值防止溢出 开辟三个结构体 存三组数据总和
    RGB_total rgb_total[3];
    rgb_total[0].total = 0, rgb_total[1].total = 0, rgb_total[2].total = 0;
    rgb_total[0].R_total = 0, rgb_total[1].R_total = 0, rgb_total[2].R_total = 0;
    rgb_total[0].G_total = 0, rgb_total[1].G_total = 0, rgb_total[2].G_total = 0;
    rgb_total[0].B_total = 0, rgb_total[1].B_total = 0, rgb_total[2].B_total = 0;
    // memset(&rgb_total, 0, sizeof(rgb_total)*3);
    //  创建VUV分量数组
    vector<vector<YUV_float>> yuvImage(width, vector<YUV_float>(height));
    // 循环遍历所有像素
    // 横轴
    int count = 0;
    for (int i = 0; i < width; i++)
    {
        // 竖轴
        for (int j = 0; j < height; j++)
        {
            // 对每个像素利用矩阵算出它的 Y 值并且存入YUV_float

            yuvImage[i][j].YUV_y = (double)Y((double)image[i][j].r, (double)image[i][j].g, (double)image[i][j].b);
            // cout << yuvImage[i][j].YUV_y << "  " <<(double)image[i][j].r << "  " <<(double)image[i][j].g << " "<<(double)image[i][j].b<< endl;
            // cout << (double)image[i][j].r /(double)image[i][j].g  <<" " <<(double)image[i][j].b /(double)image[i][j].g<<endl;
            // cout << (double)((double)image[i][j].r / yuvImage[i][j].YUV_y) <<" " <<(double)((double)image[i][j].b / yuvImage[i][j].YUV_y)<<endl;
            // 判断灰度范围
            // 改成大于0.6左右 R/G约等于0.6
            if (yuvImage[i][j].YUV_y != 0)
            {
                // cout << ((double)image[i][j].r / (double)image[i][j].g) << endl;
                // if (((double)((double)image[i][j].r / (double)image[i][j].g) > R_Y) && ((double)((double)image[i][j].b / (double)image[i][j].g) > B_Y))
                if (((yuvImage[i][j].YUV_u < 30) && (yuvImage[i][j].YUV_u > -30)) && ((yuvImage[i][j].YUV_v > -30) && (yuvImage[i][j].YUV_v < 30)))
                {
                    // 判断亮度范围

                    if ((yuvImage[i][j].YUV_y >= 0x40) && (yuvImage[i][j].YUV_y < 0xc0)) // 128±64
                    {
                        yuvImage[i][j].type = 64;
                        if ((yuvImage[i][j].YUV_y >= 0x58) && (yuvImage[i][j].YUV_y < 0xa8)) // 128±40
                        {
                            yuvImage[i][j].type = 40;
                            if ((yuvImage[i][j].YUV_y >= 0x6c) && (yuvImage[i][j].YUV_y < 0x94)) // 128±20
                            {
                                yuvImage[i][j].type = 20;
                            }
                        }
                    }
                }
            }
            // 判断类型并且累计
            if (yuvImage[i][j].type == 64)
            {
                rgb_total[0].R_total += image[i][j].r;
                rgb_total[0].G_total += image[i][j].g;
                rgb_total[0].B_total += image[i][j].b;
                rgb_total[0].total++;
                count++;
            }
            if (yuvImage[i][j].type == 40)
            {
                rgb_total[1].R_total += image[i][j].r;
                rgb_total[1].G_total += image[i][j].g;
                rgb_total[1].B_total += image[i][j].b;
                rgb_total[1].total++;
            }
            if (yuvImage[i][j].type == 20)
            {
                rgb_total[2].R_total += image[i][j].r;
                rgb_total[2].G_total += image[i][j].g;
                rgb_total[2].B_total += image[i][j].b;
                rgb_total[2].total++;
            }
        }
    }
    // cout << rgb_total[0].total <<endl;
    // cout << rgb_total[1].total <<endl;
    // cout << rgb_total[2].total <<endl;
    // cout << rgb_total[0].R_total << " " << rgb_total[0].G_total << " " << rgb_total[0].B_total << " " << rgb_total[0].total << endl;
    // cout << rgb_total[1].R_total << " " << rgb_total[1].G_total << " " << rgb_total[1].B_total << " " << rgb_total[1].total << endl;
    // cout << rgb_total[2].R_total << " " << rgb_total[2].G_total << " " << rgb_total[2].B_total << " " << rgb_total[2].total << endl;

    // 求平均值 128±64
    rgb_total[0].avg_R = (double)rgb_total[0].R_total / (double)rgb_total[0].total;
    rgb_total[0].avg_G = (double)rgb_total[0].G_total / (double)rgb_total[0].total;
    rgb_total[0].avg_B = (double)rgb_total[0].B_total / (double)rgb_total[0].total;
    // // 128±40
    rgb_total[1].avg_R = (double)rgb_total[1].R_total / (double)rgb_total[1].total;
    rgb_total[1].avg_G = (double)rgb_total[1].G_total / (double)rgb_total[1].total;
    rgb_total[1].avg_B = (double)rgb_total[1].B_total / (double)rgb_total[1].total;
    // // 128±20
    rgb_total[2].avg_R = (double)rgb_total[2].R_total / (double)rgb_total[2].total;
    rgb_total[2].avg_G = (double)rgb_total[2].G_total / (double)rgb_total[2].total;
    rgb_total[2].avg_B = (double)rgb_total[2].B_total / (double)rgb_total[2].total;
    // // // 配置权重 对64配置
    rgb_total[0].avg_R = rgb_total[0].avg_R * 0.2;
    rgb_total[0].avg_G = rgb_total[0].avg_G * 0.2;
    rgb_total[0].avg_B = rgb_total[0].avg_B * 0.2;
    // 对40配置
    rgb_total[1].avg_R = rgb_total[1].avg_R * 0.5;
    rgb_total[1].avg_G = rgb_total[1].avg_G * 0.5;
    rgb_total[1].avg_B = rgb_total[1].avg_B * 0.5;
    // 求平均
    GainR = (rgb_total[0].avg_G + rgb_total[1].avg_G + rgb_total[2].avg_G) / (rgb_total[0].avg_R + rgb_total[1].avg_R + rgb_total[2].avg_R);
    GainB = (rgb_total[0].avg_G + rgb_total[1].avg_G + rgb_total[2].avg_G) / (rgb_total[0].avg_B + rgb_total[1].avg_B + rgb_total[2].avg_B);
    //  返回值
    return_GB.GainR = GainR;
    return_GB.GainB = GainB;
    return return_GB;
}

白平衡操作：

void white_balance(Return_GainR_GrainB RB, vector<vector<uint16_t>> &image)
{
    int height = image.size(), width = image[0].size(), i = 0, j = 0;
    for (i = 0; i < height; i++)
    {
        for (j = 0; j < width; j++)
        {
            bool Red = (i % 2 == 1) && (j % 2 == 0);
            bool Blue = (i % 2 == 0) && (j % 2 == 1);
            if (Red)
            {
                image.at(i).at(j) = image.at(i).at(j) * RB.GainB;
            }
            if (Blue)
            {
                image.at(i).at(j) = image.at(i).at(j) * RB.GainR;
            }
            if (image.at(i).at(j) > 0x3ff)
            {
                image.at(i).at(j) = 0x3ff;
            }
        }
    }
}

头文件：

/**
 * @author. zhl 2023-4-11
 * @brief RGB_YUV_H 头文件
 * @note 以下这个头文件存放RAM——RGB变幻的一些需要的参数
 */

#ifndef RGB_YUV_H
#define RGB_YUV_H
#include <iostream>
#include <stdint.h>
#include <stdlib.h>
#include <vector>
#include <cmath>
using namespace std;
// 定义RGB图像的像素结构体
struct Pixel
{
    uint8_t r;
    uint8_t g;
    uint8_t b;
};

struct YUV_float
{
    double YUV_y;
    double YUV_u;
    double YUV_v;
    int type;
};

//JPEG的亮度量化和色度量化函数 传入
struct  Ycrcb
{
    uint8_t y;
    uint8_t cr;
    uint8_t cb;
};


struct RGB_total
{
    uint64_t R_total;
    uint64_t G_total;
    uint64_t B_total;
    double avg_R;
    double avg_G;
    double avg_B;
    int total;
};

struct Return_GainR_GrainB
{
    double GainR;
    double GainB;
};

struct YUYV
{
    uint8_t Y;
    uint8_t U;
    uint8_t Y_;
    uint8_t V;
};


const vector<vector<int>> LuminanceQuantizationTable = {
    { 16, 11, 10, 16, 24, 40, 51, 61 },
    { 12, 12, 14, 19, 26, 58, 60, 55 },
    { 14, 13, 16, 24, 40, 57, 69, 56 },
    { 14, 17, 22, 29, 51, 87, 80, 62 },
    { 18, 22, 37, 56, 68, 109, 103, 77 },
    { 24, 35, 55, 64, 81, 104, 113, 92 },
    { 49, 64, 78, 87, 103, 121, 120, 101 },
    { 72, 92, 95, 98, 112, 100, 103, 99 }
};
const vector<vector<int>> ChrominanceQuantizationTable = {
    { 17, 18, 24, 47, 99, 99, 99, 99 },
    { 18, 21, 26, 66, 99, 99, 99, 99 },
    { 24, 26, 56, 99, 99, 99, 99, 99 },
    { 47, 66, 99, 99, 99, 99, 99, 99 },
    { 99, 99, 99, 99, 99, 99, 99, 99 },
    { 99, 99, 99, 99, 99, 99, 99, 99 },
    { 99, 99, 99, 99, 99, 99, 99, 99 },
    { 99, 99, 99, 99, 99, 99, 99, 99 }
};
//DTC 量化啊表
// vector<vector<int>> q = {
//     {16,  11,  10,  16,  24,  40,  51,  61},
//     {12,  12,  14,  19,  26,  58,  60,  55},
//     {14,  13,  16,  24,  40,  57,  69,  56},
//     {14,  17,  22,  29,  51,  87,  80,  62},
//     {18,  22,  37,  56,  68, 109, 103,  77},
//     {24,  35,  55,  64,  81, 104, 113,  92},
//     {49,  64,  78,  87, 103, 121, 120, 101},
//     {72,  92,  95,  98, 112, 100, 103,  99}
// };


/*
1.546875        -0.397460938        -0.149414063
-0.247070313        1.258789063        -0.01171875
-0.102539063        -0.844726563        1.947265625
*/
//颜色矩阵



// 白平衡色度权重
#define Y128_Deviation_20_Weight 1
#define Y128_Deviation_40_Weight 0.5
#define Y128_Deviation_64_Weight 0.2
// RGBtoYUV
#define Y(r, g, b) 0.299 * (r)+0.587 * (g)+0.114 * (b)
#define U(r, g, b) -0.147 * (r)-0.298 * (g)+0.436 * (b)
#define V(r, g, b) 0.615 * (r)-0.515 * (g)-0.100 * (b)
// YUVtoRGB
#define R(y, v) (y) + 1.140 * (v)
#define G(y, u, v) (y) - 0.395 * (u)-0.581 * (v)
#define B(y, u) (y) + 2.032 * (u)
// 白平衡灰度判断标准
#define R_Y 0.60
#define B_Y 0.60
// UV标准判断
#define U_V 0.15

// 大小端转换，写成内联函数效率高
inline uint16_t swap_endian(uint16_t num)
{
    return (num >> 8) | (num << 8);
}

#endif

下面是经过白平衡处理的图片，但是因为又亮度过高，有些地方回出现红斑，这个我们后面来处理，已经接近实际场景了。

色彩空间矩阵矫正：

色彩矫正是一种用于改善图像色彩的处理方法，其主要作用是消除图像中的色彩偏差，使图像的色彩更加准确、自然、真实。色彩偏差通常是由于光源、相机、显示器等硬件设备的差异或者环境因素等引起的。

消除色彩偏差：色彩矫正可以消除相机、显示器等设备造成的色彩偏差，使图像的色彩更加准确和自然。例如，可以通过白平衡矫正消除图像中的色温偏差，使图像中的白色看起来真正的白色。
提高图像质量：色彩矫正可以改善图像的色彩效果，使图像更加清晰、明亮、鲜艳，从而提高图像的质量和视觉效果。
统一色彩风格：对于一些需要保持一致色彩风格的场景，如商业广告、产品摄影等，色彩矫正可以使图像的色彩保持一致，达到统一的色彩风格。
降低色彩误差：色彩矫正可以降低图像中的色彩误差，从而提高图像的色彩还原度和准确性，使得图像更加符合人眼的视觉感受。综上所述，色彩矫正在数字图像处理中具有重要的作用，可以消除图像中的色彩偏差，改善图像的色彩效果，提高图像质量和准确性。

可能保密，所以我删掉了精度，下面是代码：

void matmul3x3_3x1(vector<vector<Pixel>> &mat3x1)
{
    // 检查输入矩阵的形状是否正确
    vector<vector<double>> mat3x3(3, vector<double>(3));
    mat3x3[0][0] = 1.5, mat3x3[0][1] = -0.3, mat3x3[0][2] = -0.1;
    mat3x3[1][0] = -0.2, mat3x3[1][1] = 1.2, mat3x3[1][2] = -0.01;
    mat3x3[2][0] = -0.1, mat3x3[2][1] = -0.8, mat3x3[2][2] = 1.9;
    // 对每一个像素计算矩阵乘积
    for (int i = 0; i < mat3x1.size(); i++)
    {
        for (int j = 0; j < mat3x1[0].size(); j++)
        {
            int number = (10 * (double)mat3x1[i][j].r * mat3x3[0][0]) / 10 + (10 * (double)mat3x1[i][j].g * mat3x3[0][1]) / 10 + (10 * (double)mat3x1[i][j].b * mat3x3[0][2]) / 10;
        }
    }
}

正在图片看起来略微的变得更加透亮。

伽马矫正：

伽马矫正是数字图像处理中常用的一种技术，其主要作用是对图像的亮度进行调整，使其在不同的显示设备上呈现出相同的亮度级别，从而达到更加准确和自然的显示效果。伽马矫正的意义主要有以下几点：

保证图像的亮度一致性：由于不同的显示设备具有不同的亮度响应曲线，同一个图像在不同设备上的亮度表现会有所不同。伽马矫正可以使图像的亮度表现在不同设备上更加一致，确保图像在不同设备上呈现出相同的亮度级别。
提高图像对比度：伽马矫正可以调整图像的亮度，使得图像中的细节更加清晰、明亮，从而提高图像的对比度和视觉效果。
改善图像的色彩鲜艳度：伽马矫正可以使图像中的颜色更加鲜艳、真实，从而提高图像的色彩还原度和准确性。
适应人眼的视觉特性：人眼对亮度的感受是非线性的，伽马矫正可以使图像的亮度响应与人眼的视觉特性相适应，使图像看起来更加自然和舒适。综上所述，伽马矫正在数字图像处理中具有重要的意义，可以提高图像的亮度一致性、对比度和色彩鲜艳度，适应人眼的视觉特性，从而达到更加准确、自然和舒适的显示效果。

下面是代码：

vector<vector<Pixel>> Gamma_correction(vector<vector<Pixel>> &image, float gamma)
{
    for (int i = 0; i < image.size(); i++)
    {
        for (int j = 0; j < image[i].size(); j++)
        {
            /*
            / 255.0f 表示将该像素值除以 255.0，将像素值归一化到 [0, 1] 的范围内。
            这一步是为了将像素值转化为浮点类型，方便进行伽马矫正运算。
            pow(image[i][j].r / 255.0f, gamma) 表示对归一化后的像素值进行伽马矫正运算，其中 pow() 函数表示对指定数值取幂。
            第一个参数是要取幂的数值，第二个参数是幂指数，即伽马值。
            */
            image[i][j].r = pow((double)image[i][j].r / 255.0f, gamma) * 255.0f;
            image[i][j].g = pow((double)image[i][j].g / 255.0f, gamma) * 255.0f;
            image[i][j].b = pow((double)image[i][j].b / 255.0f, gamma) * 255.0f;
        }
    }
    return image;
}

下面是矫正后的图片，可以看见整张图片的对比度变高了。

去红：

可以看出，图片高亮部分存在红色，现在写代码将其去除。

void reduce_red(vector<vector<Pixel>> &RGB)
{
    int height = RGB.size(), width = RGB[0].size(), i = 0, j = 0;
    for (i = 0; i < height; i++)
    {
        for (j = 0; j < width; j++)
        {
            if(Y(RGB[i][j].r,RGB[i][j].g,RGB[i][j].b)>230)
            {
              RGB[i][j].r = RGB[i][j].g; 
              RGB[i][j].b = RGB[i][j].g; 
            }
        }
    }
}