C++基于opencv制作的图像处理示例

#include<iostream>
#include<opencv2/opencv.hpp>
#include <string>
using namespace cv;
#define max2(a,b) (a>b?a:b)
#define max3(a,b,c) (a>b?max2(a,c):max2(b,c))
#define min2(a,b) (a<b?a:b)
#define min3(a,b,c) (a<b?min2(a,c):min2(b,c))

/*调节饱和度，0－200，是原来的%多少saturation*/
cv::Mat adjustSaturation(cv::Mat& image, int saturation) {
    CV_Assert(image.depth() == CV_8U && (image.channels() == 3 || image.channels() == 1));

    // 对于每个像素，将其转换到HSV色彩空间
    cv::Mat hsvImage;
    cv::cvtColor(image, hsvImage, cv::COLOR_BGR2HSV);

    // 分离色调（Hue）、饱和度（Saturation）和亮度（Value）
    std::vector<cv::Mat> hsvChannels;
    cv::split(hsvImage, hsvChannels);

    // 调整饱和度
    hsvChannels[1] *= saturation / 100.0;

    // 合并色调和亮度通道，并转换回BGR色彩空间
    cv::merge(hsvChannels, hsvImage);
    cv::cvtColor(hsvImage, image, cv::COLOR_HSV2BGR);
    return image;
}
//--------------------------------------------------------------------------------
// 饱和度-100-+100
cv::Mat Saturation(cv::Mat src, float saturation)
{
    float Increment = saturation * 1.0f / 100;
    cv::Mat temp = src.clone();
    int row = src.rows;
    int col = src.cols;
    for (int i = 0; i < row; ++i)
    {
        uchar* t = temp.ptr<uchar>(i);
        uchar* s = src.ptr<uchar>(i);
        for (int j = 0; j < col; ++j)
        {
            uchar b = s[3 * j];
            uchar g = s[3 * j + 1];
            uchar r = s[3 * j + 2];
            float max = max3(r, g, b);
            float min = min3(r,g, b);
            float delta, value;
            float L, S, alpha;
            delta = (max - min) / 255;
            if (delta == 0)
                continue;
            value = (max + min) / 255;
            L = value / 2;
            if (L < 0.5)
                S = delta / value;
            else
                S = delta / (2 - value);
            if (Increment >= 0)
            {
                if ((Increment + S) >= 1)
                    alpha = S;
                else
                    alpha = 1 - Increment;
                alpha = 1 / alpha - 1;
                t[3 * j + 2] = static_cast<uchar>(r + (r - L * 255) * alpha);
                t[3 * j + 1] = static_cast<uchar>(g + (g - L * 255) * alpha);
                t[3 * j] = static_cast<uchar>(b + (b - L * 255) * alpha);
            }
            else
            {
                alpha = Increment;
                t[3 * j + 2] = static_cast<uchar>(L * 255 + (r - L * 255) * (1 + alpha));
                t[3 * j + 1] = static_cast<uchar>(L * 255 + (g - L * 255) * (1 + alpha));
                t[3 * j] = static_cast<uchar>(L * 255 + (b - L * 255) * (1 + alpha));
            }
        }
    }
    return temp;
}
/*字符串长度*/
int mystrlen(const char* str)
{
    int stringlen = 0;
    while (*str++)stringlen++;
    return stringlen;
}
/*字符串比较，相等返回0，不相当返回1*/
int strcomp(char* str1, const char* str2)
{
    if (mystrlen(str1) != mystrlen(str2))return 1;
    while (*str1 != '\0')
    {
        if (*str1 == *str2)
        {
            str1++;
            str2++;
        }
        else return 1;
    }
    return 0;
}
/*求子串出现oice次的位置，从1开始计算*/
int myat(const char* substr, const char* str, int oice)
{
    //123,124jie4
    int i = 0;
    int j = 0;
    int k = 0;
    while (str[i] != '\0') {
        while (substr[j] != '\0' && str[i] == substr[j]) {
            i++; j++;
        }
        if (substr[j] == '\0') {
            k++;
            if (k == oice)return i - j + 1;
            else {
                j = 0;
            }
        }
        else {
            j = 0;
            i = i - j + 1;
        }
    }
    return 0;
}
/*字符串转换成整形*/
int str2int(const char* str)
{
    int temp = 0;
    const char* ptr = str;  //ptr保存str字符串开头
    if (*str == '-' || *str == '+')  //如果第一个字符是正负号，
    {                      //则移到下一个字符
        str++;
    }
    while (*str != 0)
    {
        if ((*str < '0') || (*str > '9'))  //如果当前字符不是数字
        {                       //则退出循环
            break;
        }
        temp = temp * 10 + (*str - '0'); //如果当前字符是数字则计算数值
        str++;      //移到下一个字符
    }
    if (*ptr == '-')     //如果字符串是以“-”开头，则转换成其相反数
    {
        temp = -temp;
    }
    return temp;
}
//--------------------------------------------------------------------------------
// 亮度与对比度
cv::Mat Brightness(cv::Mat src, float brightness, int contrast)
{
    cv::Mat dst;
    dst = cv::Mat::zeros(src.size(), src.type());        //新建空白模板：大小/类型与原图像一致，像素值全0。
    int height = src.rows;                                //获取图像高度
    int width = src.cols;                                //获取图像宽度
    float alpha = brightness;                            //亮度（0~1为暗，1~正无穷为亮）
    float beta = contrast;                                //对比度

    cv::Mat template1;
    src.convertTo(template1, CV_32F);                    //将CV_8UC1转换为CV32F1数据格式。
    for (int row = 0; row < height; row++)
    {
        for (int col = 0; col < width; col++)
        {
            if (src.channels() == 3)
            {
                float b = template1.at<cv::Vec3f>(row, col)[0];        //获取通道的像素值（blue）
                float g = template1.at<cv::Vec3f>(row, col)[1];        //获取通道的像素值（green）
                float r = template1.at<cv::Vec3f>(row, col)[2];        //获取通道的像素值（red）

                //cv::saturate_cast<uchar>(vaule)：需注意，value值范围必须在0~255之间。
                dst.at<cv::Vec3b>(row, col)[0] = cv::saturate_cast<uchar>(b * alpha + beta);        //修改通道的像素值（blue）
                dst.at<cv::Vec3b>(row, col)[1] = cv::saturate_cast<uchar>(g * alpha + beta);        //修改通道的像素值（green）
                dst.at<cv::Vec3b>(row, col)[2] = cv::sa