OpenCV C++ 图像处理之自动色阶

自动色阶

第一步，分别统计各通道（红/绿/蓝）的直方图。

第二步，分别计算各通道按照给定的参数所确定的上下限值。什么意思呢，比如对于蓝色通道，我们从色阶0开始向上累加统计直方图，当累加值大于LowCut所有像素数时，以此时的色阶值计为BMin。然后从色阶255开始向下累计直方图，如果累加值大于HighCut所有像素时，以此时的色阶值计为BMax。

第三步，按照我们刚刚计算出的MinBlue/MaxBlue构建一个隐射表，隐射表的规则是，对于小于MinBlue的值，则隐射为0（实际上这句话也不对，隐射为多少是和那个自动颜色校正选项对话框中的阴影所设定的颜色有关，默认情况下是黑色，对应的RGB分量都为0，所以我们这里就隐射为0，有兴趣你们也可以指定为其他的参数），对于大于MaxBlue的值，则隐射为255（同理，这个值和高光的颜色设置有关），对于介于MinBlue和MaxBlue之间的值，则进行线性隐射，默认是隐射为0到255之间(当然实际是和我们的暗调和高光的设置有关，并且这里其实也不是线性隐射，是有一个Gamma校正，为了简便，用线性替代效果也没太大的问题）。

最后一步，对各通道图像数据进行隐射。

// AutoLevel.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include<opencv2corecore.hpp>
#include<opencv2highguihighgui.hpp>
#include<opencv2imgprocimgproc.hpp>
#include<iostream>
#include<vector>
#include <algorithm>
using namespace cv;

void AutoLevelsAdjust(cv::Mat& src, cv::Mat& dst)
{
    CV_Assert(!src.empty() && src.channels() == 3);

    //统计灰度直方图
    int BHist[256] = { 0 };    //B分离
    int GHist[256] = { 0 };    //G分量
    int RHist[256] = { 0 };    //R分量
    cv::MatIterator_<Vec3b> its, ends;
    for (its = src.begin<Vec3b>(), ends = src.end<Vec3b>(); its != ends; its++)
    {
        BHist[(*its)[0]]++;
        GHist[(*its)[1]]++;
        RHist[(*its)[2]]++;
    }

    //设置LowCut和HighCut
    float LowCut = 0.5;
    float HighCut = 0.5;

    //根据LowCut和HighCut查找每个通道最大值最小值
    int BMax = 0, BMin = 0;
    int GMax = 0, GMin = 0;
    int RMax = 0, RMin = 0;

    int TotalPixels = src.cols * src.rows;
    float LowTh = LowCut * 0.01 * TotalPixels;
    float HighTh = HighCut * 0.01 * TotalPixels;

    //B通道查找最小最大值
    int sumTempB = 0;
    for (int i = 0; i < 256; i++)
    {
        sumTempB += BHist[i];
        if (sumTempB >= LowTh)
        {
            BMin = i;
            break;
        }
    }
    sumTempB = 0;
    for (int i = 255; i >= 0; i--)
    {
        sumTempB += BHist[i];
        if (sumTempB >= HighTh)
        {
            BMax = i;
            break;
        }
    }

    //G通道查找最小最大值
    int sumTempG = 0;
    for (int i = 0; i < 256; i++)
    {
        sumTempG += GHist[i];
        if (sumTempG >= LowTh)
        {
            GMin = i;
            break;
        }
    }
    sumTempG = 0;
    for (int i = 255; i >= 0; i--)
    {
        sumTempG += GHist[i];
        if (sumTempG >= HighTh)
        {
            GMax = i;
            break;
        }
    }

    //R通道查找最小最大值
    int sumTempR = 0;
    for (int i = 0; i < 256; i++)
    {
        sumTempR += RHist[i];
        if (sumTempR >= LowTh)
        {
            RMin = i;
            break;
        }
    }
    sumTempR = 0;
    for (int i = 255; i >= 0; i--)
    {
        sumTempR += RHist[i];
        if (sumTempR >= HighTh)
        {
            RMax = i;
            break;
        }
    }

    //对每个通道建立分段线性查找表
    //B分量查找表
    int BTable[256] = { 0 };
    for (int i = 0; i < 256; i++)
    {
        if (i <= BMin)
            BTable[i] = 0;
        else if (i > BMin && i < BMax)
            BTable[i] = cvRound((float)(i - BMin) / (BMax - BMin) * 255);
        else
            BTable[i] = 255;
    }

    //G分量查找表
    int GTable[256] = { 0 };
    for (int i = 0; i < 256; i++)
    {
        if (i <= GMin)
            GTable[i] = 0;
        else if (i > GMin && i < GMax)
            GTable[i] = cvRound((float)(i - GMin) / (GMax - GMin) * 255);
        else
            GTable[i] = 255;
    }

    //R分量查找表
    int RTable[256] = { 0 };
    for (int i = 0; i < 256; i++)
    {
        if (i <= RMin)
            RTable[i] = 0;
        else if (i > RMin && i < RMax)
            RTable[i] = cvRound((float)(i - RMin) / (RMax - RMin) * 255);
        else
            RTable[i] = 255;
    }

    //对每个通道用相应的查找表进行分段线性拉伸
    cv::Mat dst_ = src.clone();
    cv::MatIterator_<Vec3b> itd, endd;
    for (itd = dst_.begin<Vec3b>(), endd = dst_.end<Vec3b>(); itd != endd; itd++)
    {
        (*itd)[0] = BTable[(*itd)[0]];
        (*itd)[1] = GTable[(*itd)[1]];
        (*itd)[2] = RTable[(*itd)[2]];
    }
    dst = dst_;
}

int main()
{
    Mat image = imread("E:\picture\wutian.jpg");
    Mat dst = Mat::zeros(image.rows, image.cols, CV_8UC1);
    AutoLevelsAdjust(image, dst);
    imshow("src", image);
    imshow("dst", dst);
    while (char(waitKey(1)) != 'q') {}
}

自动色阶用来做去雾，还是最为稳定的，虽然现在有很多种其他增强方法，例如暗通道去雾，优化对比度去雾，基于Color-Lines的去雾，但是这些算法还不是很稳定，当先验知识失效时，处理失真比较严重。但自动色阶相对就比较稳定。