3.5 其他常见的灰度变换技术

////////https://blog.csdn.net/uestc_c2_403/article/details/72814206
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/opencv.hpp"
#include "opencv2/core/core.hpp"
#include <iostream>
using namespace std;
using namespace cv;
//图像线性变换操作
cv::Mat linearTransform(cv::Mat srcImage, float a, int b)
{
    if (srcImage.empty())
    {
        std::cout << "No data!" << std::endl;
    }
    const int nRows = srcImage.rows;
    const int nCols = srcImage.cols;
cv:; Mat resultImage =
    cv::Mat::zeros(srcImage.size(), srcImage.type());
   //图像元素遍历
   for (int i = 0; i < nRows; i++)
   {
       for (int j = 0; j < nCols; j++)
       {
           for (int c = 0; c < 3; c++)
           {
               //矩阵at操作，检查下标防止越界
               resultImage.at<Vec3b>(i, j)[c] = saturate_cast<uchar>(a * (srcImage.at<Vec3b>(i, j)[c]) + b);
           }
       }
   }
   return resultImage;
}
int main()
{
    cv::Mat srcImage = cv::imread("D:\大海.jpg");
    if (srcImage.empty())
    {
        return -1;
    }

    cv::imshow("源图像", srcImage);
    //线性变换
    float a = 1.2;
    int b = 50;
    cv::Mat new_image = linearTransform(srcImage, a, b);
    cv::imshow("dst", new_image);
    cv::waitKey(0);
    return 0;
}

3.5.2 对数变换

对数变换的公式为：

其中c为常数,r>=0 

对数变换目前我知道的有两个作用：

①因为对数曲线在像素值较低的区域斜率较大，像素值较高的区域斜率比较低，所以图像经过对数变换之后，在较暗的区域对比度将得到提升，因而能增强图像暗部的细节。

②图像的傅里叶频谱其动态范围可能宽达0~10^6。直接显示频谱的话显示设备的动态范围往往不能满足要求，这个时候就需要使用对数变换，使得傅里叶频谱的动态范围被合理地非线性压缩。

在OpenCV中，图像对数变换的实现可以直接通过对图像中每个元素运算上述公式完成，也可以通过矩阵整体操作来完成。下面的代码中给了三种方法，其中方法一和方法三都是通过矩阵整体操作来完成，第二种方法是对图像中每个元素操作来完成。方法一和方法三的区别是前者是对源图像作对数运算，后者是对目标图像作对数运算！

//////https://blog.csdn.net/gone_huilin/article/details/53223118
//////https://blog.csdn.net/spw_1201/article/details/53482877
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <iostream>
using namespace cv;
using namespace std;
//基于源图像的方法1
Mat logTransform1(Mat srcImage, int c)
{
    if (srcImage.empty())
        cout << "No data" << endl;
    Mat resultImage = Mat::zeros(srcImage.size(), srcImage.type());
    add(srcImage, Scalar(1.0), srcImage);  //计算 r+1
    srcImage.convertTo(srcImage, CV_32F);  //转化为32位浮点型
    log(srcImage, resultImage);            //计算log(1+r)
    resultImage = c*resultImage;
    //归一化处理
    normalize(resultImage, resultImage, 0, 255, NORM_MINMAX);
    convertScaleAbs(resultImage, resultImage);
    return resultImage;

}
//方法2
Mat logTransform2(Mat srcImage, float c)
{
    if (srcImage.empty())
        cout << "No data" << endl;
    Mat resultImage = Mat::zeros(srcImage.size(), srcImage.type());
    double gray = 0;
    for (int i = 0; i < srcImage.rows; i++)
    {
        for (int j = 0; j < srcImage.cols; j++)
        {
            gray = (double)srcImage.at<uchar>(i, j);
            gray = c*log((double)(1 + gray));
            resultImage.at<uchar>(i, j) = saturate_cast<uchar>(gray);
        }
    }
    //归一化处理
    normalize(resultImage, resultImage, 0, 255, NORM_MINMAX);
    convertScaleAbs(resultImage, resultImage);
    return resultImage;
}
//方法3
Mat logTransform3(Mat srcImage, float c)
{
    if (srcImage.empty())
        cout << "No data" << endl;
    Mat resultImage = Mat::zeros(srcImage.size(), srcImage.type());
    srcImage.convertTo(resultImage, CV_32F);  //图像类型转换
    resultImage = resultImage + 1;            //图像矩阵元素加1
    log(resultImage, resultImage);
    resultImage = c*resultImage;
    //归一化处理
    normalize(resultImage, resultImage, 0, 255, NORM_MINMAX);
    convertScaleAbs(resultImage, resultImage);
    return resultImage;
}
int main()
{
    Mat srcImage = imread("D:\大海.jpg");
    if (!srcImage.data)
        return -1;
    cvtColor(srcImage, srcImage, CV_BGR2GRAY);
    imshow("srcImage", srcImage);
    float c = 1.2;
    Mat resultImage;
    double tTime;
    tTime = (double)getTickCount();
    const int nTimes = 100;
    for (int i = 0; i < nTimes; i++)
    {
        resultImage = logTransform3(srcImage, c);
    }
    tTime = 1000 * ((double)getTickCount() - tTime) / getTickFrequency();
    tTime /= nTimes;
    cout << tTime << endl;
    imshow("resultImage", resultImage);
    waitKey(0);
    return 0;
}

 

 

参考：

https://blog.csdn.net/gone_huilin/article/details/53223118

https://blog.csdn.net/spw_1201/article/details/53482877

https://blog.csdn.net/wenhao_ir/article/details/51658086

https://blog.csdn.net/eric_e/article/details/79440089

https://blog.csdn.net/dcrmg/article/details/53677739

3.5.3 对比度拉伸

//////https://blog.csdn.net/spw_1201/article/details/53486594
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>
using namespace cv;
using namespace std;
Mat contrastStretch(Mat srcImage)
{
    Mat resultImage = srcImage.clone();//"=";"clone()";"copyTo"三种拷贝方式，前者是浅拷贝，后两者是深拷贝。
    int nRows = resultImage.rows;
    int nCols = resultImage.cols;
    //判断图像的连续性
    if (resultImage.isContinuous())
    {
        nCols = nCols*nRows;
        nRows = 1;
    }
    //图像指针操作
    uchar *pDataMat;
    int pixMax = 0, pixMin = 255;
    //计算图像的最大最小值
    for (int j = 0; j < nRows; j++)
    {
        pDataMat = resultImage.ptr<uchar>(j);//ptr<>()得到的是一行指针
        for (int i = 0; i < nCols; i++)
        {
            if (pDataMat[i] > pixMax)
                pixMax = pDataMat[i];
            if (pDataMat[i] < pixMin)
                pixMin = pDataMat[i];
        }
    }
    //对比度拉伸映射
    for (int j = 0; j < nRows; j++)
    {
        pDataMat = resultImage.ptr<uchar>(j);
        for (int i = 0; i < nCols; i++)
        {
            pDataMat[i] = (pDataMat[i] - pixMin) * 255 / (pixMax - pixMin);
        }
    }
    return resultImage;
}
int main()
{
    Mat srcImage = imread("D:\小女孩与熊.jpg");
    if (!srcImage.data)
        return -1;
    Mat srcGray;
    cvtColor(srcImage, srcGray, CV_RGB2GRAY);
    imshow("srcGray", srcGray);
    Mat resultImage = contrastStretch(srcGray);
    imshow("resultImage", resultImage);
    waitKey(0);
    return 0;
}

https://blog.csdn.net/spw_1201/article/details/53486594

https://blog.csdn.net/abcd1992719g/article/details/25483395

3.5.4 灰度级分层

//////https://blog.csdn.net/spw_1201/article/details/53487746
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>
using namespace cv;
using namespace std;
Mat grayLayered(Mat srcImage)
{
    Mat resultImage = srcImage.clone();
    int nRows = resultImage.rows;
    int nCols = resultImage.cols;
    if (resultImage.isContinuous())
    {
        nCols = nRows*nCols;
        nRows = 1;
    }
    uchar *pDataMat;
    int controlMin = 150;
    int controlMax = 200;
    for (int j = 0; j < nRows; j++)
    {
        pDataMat = resultImage.ptr<uchar>(j);
        for (int i = 0; i < nCols; i++)
        {
            //第一种方法：二值映射
            if (pDataMat[i] > controlMin)
                pDataMat[i] = 255;
            else
                pDataMat[i] = 0;
            //第二种方法：区域映射
            /*if (pDataMat[i] > controlMin && pDataMat[i] < controlMax)
            pDataMat[i] = controlMax;*/
        }
    }
    return resultImage;
}
int main()
{
    Mat srcImage = imread("D:\大海.jpg");
    if (!srcImage.data)
        return -1;
    Mat srcGray;
    cvtColor(srcImage, srcGray, CV_BGR2GRAY);
    imshow("srcGray", srcGray);
    Mat resultImage = grayLayered(srcGray);
    imshow("resultImage", resultImage);
    waitKey(0);
    return 0;
}

3.5.5 灰度比特平面

//////https://blog.csdn.net/gone_huilin/article/details/53223151
#include <opencv2/imgproc/imgproc.hpp>  
#include <opencv2/core/core.hpp>        
#include <opencv2/highgui/highgui.hpp> 
#include <iostream> 
#include <stdio.h>
using namespace cv;
using namespace std;
void showMBitPlan(cv::Mat srcImage)
{
    int nRows = srcImage.rows;
    int nCols = srcImage.cols;
    // 图像连续性判断
    if (srcImage.isContinuous())
    {
        nCols = nCols  * nRows;
        nRows = 1;
    }
    // 图像指针操作
    uchar *pSrcMat;
    uchar *pResultMat;
    cv::Mat resultImage = srcImage.clone();
    int pixMax = 0, pixMin = 0;
    for (int n = 1; n <= 8; n++)
    {
        // 比特平面分层像素构成
        pixMin = pow(2, n - 1);
        pixMax = pow(2, n);
        for (int j = 0; j < nRows; j++)
        {
            // 获取图像数据指针
            pSrcMat = srcImage.ptr<uchar>(j);
            pResultMat = resultImage.ptr<uchar>(j);
            for (int i = 0; i < nCols; i++)
            {
                // 相应比特平面层二值化
                if (pSrcMat[i] >= pixMin && pSrcMat[i] < pixMax)
                    pResultMat[i] = 255;
                else
                    pResultMat[i] = 0;
            }
        }
        // 比特平面层输出    
        char windowsName[20];
        sprintf_s(windowsName, "BitPlane %d", n);
        imshow(windowsName, resultImage);
    }
}
int main()
{
    cv::Mat srcImage = cv::imread("D:\大海.jpg");
    if (!srcImage.data)
        return 0;
    cv::Mat srcGray;
    cvtColor(srcImage, srcGray, CV_BGR2GRAY);
    imshow("srcGray", srcGray);
    showMBitPlan(srcGray);
    cv::waitKey(0);
    return 0;
}