Opencv C++图像处理：亮度+对比度+饱和度+高光+暖色调+阴影+漫画效果+白平衡+浮雕+羽化+锐化+颗粒感

已于 2024-08-19 21:18:41 修改
阅读量189 收藏
点赞数 2
文章标签： opencv c++ 图像处理
于 2024-08-07 09:29:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012294613/article/details/140975761
版权

文章目录
一、多功能色彩调整
1.1、亮度
1.2、对比度
1.3、饱和度
1.4、高光
1.5、暖色调
1.6、阴影
1.7、漫画效果
1.8、白平衡-灰度世界
1.9、白平衡-完美反射
1.10、浮雕
1.11、羽化
1.12、锐化
1.13、颗粒感
二、实战案例
2.1、主函数
2.2、函数定义
更多详细信息请看：OpenCV专栏：翟天保Steven

一、多功能色彩调整
1.1、亮度

//--------------------------------------------------------------------------------
// 亮度与对比度
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::saturate_cast<uchar>(r * alpha + beta);        //修改通道的像素值（red）
            }
            else if (src.channels() == 1)
            {
                float v = src.at<uchar>(row, col);                                            //获取通道的像素值（单）
                dst.at<uchar>(row, col) = cv::saturate_cast<uchar>(v * alpha + beta);        //修改通道的像素值（单）
                //saturate_cast<uchar>：主要是为了防止颜色溢出操作。如果color<0，则color等于0；如果color>255，则color等于255。
            }
        }
    }
    return dst;
}


1.2、对比度

//--------------------------------------------------------------------------------
// 亮度与对比度
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::saturate_cast<uchar>(r * alpha + beta);        //修改通道的像素值（red）
            }
            else if (src.channels() == 1)
            {
                float v = src.at<uchar>(row, col);                                            //获取通道的像素值（单）
                dst.at<uchar>(row, col) = cv::saturate_cast<uchar>(v * alpha + beta);        //修改通道的像素值（单）
                //saturate_cast<uchar>：主要是为了防止颜色溢出操作。如果color<0，则color等于0；如果color>255，则color等于255。
            }
        }
    }
    return dst;
}


1.3、饱和度


//--------------------------------------------------------------------------------
// 饱和度
cv::Mat Saturation(cv::Mat src, int 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;
}


1.4、高光

//--------------------------------------------------------------------------------
// 高光
cv::Mat HighLight(cv::Mat src, int highlight)
{
    // 生成灰度图
    cv::Mat gray = cv::Mat::zeros(src.size(), CV_32FC1);
    cv::Mat f = src.clone();
    f.convertTo(f, CV_32FC3);
    std::vector<cv::Mat> pics;
    split(f, pics);
    gray = 0.299f*pics[2] + 0.587*pics[2] + 0.114*pics[0];
    gray = gray / 255.f;
 
    // 确定高光区
    cv::Mat thresh = cv::Mat::zeros(gray.size(), gray.type());
    thresh = gray.mul(gray);
    // 取平均值作为阈值
    cv::Scalar t = mean(thresh);
    cv::Mat mask = cv::Mat::zeros(gray.size(), CV_8UC1);
    mask.setTo(255, thresh >= t[0]);
 
    // 参数设置
    int max = 4;
    float bright = highlight / 100.0f / max;
    float mid = 1.0f + max * bright;
 
    // 边缘平滑过渡
    cv::Mat midrate = cv::Mat::zeros(src.size(), CV_32FC1);
    cv::Mat brightrate = cv::Mat::zeros(src.size(), CV_32FC1);
    for (int i = 0; i < src.rows; ++i)
    {
        uchar *m = mask.ptr<uchar>(i);
        float *th = thresh.ptr<float>(i);
        float *mi = midrate.ptr<float>(i);
        float *br = brightrate.ptr<float>(i);
        for (int j = 0; j < src.cols; ++j)
        {
            if (m[j] == 255)
            {
                mi[j] = mid;
                br[j] = bright;
            }
            else {
                mi[j] = (mid - 1.0f) / t[0] * th[j] + 1.0f;
                br[j] = (1.0f / t[0] * th[j])*bright;
            }
        }
    }
 
    // 高光提亮，获取结果图
    cv::Mat result = cv::Mat::zeros(src.size(), src.type());
    for (int i = 0; i < src.rows; ++i)
    {
        float *mi = midrate.ptr<float>(i);
        float *br = brightrate.ptr<float>(i);
        uchar *in = src.ptr<uchar>(i);
        uchar *r = result.ptr<uchar>(i);
        for (int j = 0; j < src.cols; ++j)
        {
            for (int k = 0; k < 3; ++k)
            {
                float temp = pow(float(in[3 * j + k]) / 255.f, 1.0f / mi[j])*(1.0 / (1 - br[j]));
                if (temp > 1.0f)
                    temp = 1.0f;
                if (temp < 0.0f)
                    temp = 0.0f;
                uchar utemp = uchar(255*temp);
                r[3 * j + k] = utemp;
            }
 
        }
    }
    return result;
}

1.5、暖色调

//--------------------------------------------------------------------------------
// 暖色调
cv::Mat ColorTemperature(cv::Mat src, int warm)
{
    cv::Mat result = src.clone();
    int row = src.rows;
    int col = src.cols;
    int level = warm/2;
    for (int i = 0; i < row; ++i)
    {
        uchar* a = src.ptr<uchar>(i);
        uchar* r = result.ptr<uchar>(i);
        for (int j = 0; j < col; ++j)
        {
            int R,G,B;
            // R通道
            R = a[j * 3 + 2];
            R = R + level;
            if (R > 255) {
                r[j * 3 + 2] = 255;
            }
            else if (R < 0) {
                r[j * 3 + 2] = 0;
            }
            else {
                r[j * 3 + 2] = R;
            }
            // G通道
            G = a[j * 3 + 1];
            G = G + level;
            if (G > 255) {
                r[j * 3 + 1] = 255;
            }
            else if (G < 0) {
                r[j * 3 + 1] = 0;
            }
            else {
                r[j * 3 + 1] = G;
            }
            // B通道
            B = a[j * 3];
            B = B - level;
            if (B > 255) {
                r[j * 3] = 255;
            }
            else if (B < 0) {
                r[j * 3] = 0;
            }
            else {
                r[j * 3] = B;
            }
        }
    }
    return result;
}


1.6、阴影


//--------------------------------------------------------------------------------
// 阴影
cv::Mat Shadow(cv::Mat src, int shadow)
{
    // 生成灰度图
    cv::Mat gray = cv::Mat::zeros(src.size(), CV_32FC1);
    cv::Mat f = src.clone();
    f.convertTo(f, CV_32FC3);
    std::vector<cv::Mat> pics;
    split(f, pics);
    gray = 0.299f*pics[2] + 0.587*pics[2] + 0.114*pics[0];
    gray = gray / 255.f;
 
    // 确定阴影区
    cv::Mat thresh = cv::Mat::zeros(gray.size(), gray.type());    
    thresh = (1.0f - gray).mul(1.0f - gray);
    // 取平均值作为阈值
    cv::Scalar t = mean(thresh);
    cv::Mat mask = cv::Mat::zeros(gray.size(), CV_8UC1);
    mask.setTo(255, thresh >= t[0]);
 
    // 参数设置
    int max = 4;
    float bright = shadow / 100.0f / max;
    float mid = 1.0f + max * bright;
 
    // 边缘平滑过渡
    cv::Mat midrate = cv::Mat::zeros(src.size(), CV_32FC1);
    cv::Mat brightrate = cv::Mat::zeros(src.size(), CV_32FC1);
    for (int i = 0; i < src.rows; ++i)
    {
        uchar *m = mask.ptr<uchar>(i);
        float *th = thresh.ptr<float>(i);
        float *mi = midrate.ptr<float>(i);
        float *br = brightrate.ptr<float>(i);
        for (int j = 0; j < src.cols; ++j)
        {
            if (m[j] == 255)
            {
                mi[j] = mid;
                br[j] = bright;
            }
            else {
                mi[j] = (mid - 1.0f) / t[0] * th[j]+ 1.0f;   
                br[j] = (1.0f / t[0] * th[j])*bright;               
            }
        }
    }
 
    // 阴影提亮，获取结果图
    cv::Mat result = cv::Mat::zeros(src.size(), src.type());
    for (int i = 0; i < src.rows; ++i)
    {
        float *mi = midrate.ptr<float>(i);
        float *br = brightrate.ptr<float>(i);
        uchar *in = src.ptr<uchar>(i);
        uchar *r = result.ptr<uchar>(i);
        for (int j = 0; j < src.cols; ++j)
        {
            for (int k = 0; k < 3; ++k)
            {
                float temp = pow(float(in[3 * j + k]) / 255.f, 1.0f / mi[j])*(1.0 / (1 - br[j]));
                if (temp > 1.0f)
                    temp = 1.0f;
                if (temp < 0.0f)
                    temp = 0.0f;
                uchar utemp = uchar(255*temp);
                r[3 * j + k] = utemp;
            }
 
        }
    }
    return result;
}


1.7、漫画效果

//--------------------------------------------------------------------------------
// 漫画效果
cv::Mat Cartoon(cv::Mat src, double clevel, int d, double sigma, int size)
{
    // 中值滤波
    cv::Mat m;
    cv::medianBlur(src, m, 7);
    // 提取轮廓
    cv::Mat c;
    clevel = cv::max(40., cv::min(80., clevel));
    cv::Canny(m, c, clevel, clevel *3);
    // 轮廓膨胀加深
    cv::Mat k = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(2, 2));
    cv::dilate(c, c, k);
    // 反转
    c = c / 255;
    c = 1 - c;
    // 类型转化
    cv::Mat cf;
    c.convertTo(cf, CV_32FC1);
    // 均值滤波
    cv::blur(cf, cf, cv::Size(5, 5));
    // 双边滤波
    cv::Mat srcb;
    d = cv::max(0, cv::min(10, d));
    sigma = cv::max(10., cv::min(250., sigma));
    cv::bilateralFilter(src, srcb, d, sigma, sigma);
    size = cv::max(10, cv::min(25, size));
    cv::Mat temp = srcb / size;
    temp = temp * size;
    // 通道合并
    cv::Mat c3;
    cv::Mat cannyChannels[] = { cf, cf, cf };
    cv::merge(cannyChannels, 3, c3);
    // 类型转化
    cv::Mat tempf;
    temp.convertTo(tempf, CV_32FC3);
    // 图像相乘
    cv::multiply(tempf, c3, tempf);
    // 类型转化
    tempf.convertTo(temp, CV_8UC3);
    return temp;
}


1.8、白平衡-灰度世界

//--------------------------------------------------------------------------------
// 白平衡-灰度世界
cv::Mat WhiteBalcane_Gray(cv::Mat src)
{
    cv::Mat result = src.clone();
    if (src.channels() != 3)
    {
        std::cout << "The number of image channels is not 3." << std::endl;
        return result;
    }
 
    // 通道分离
    std::vector<cv::Mat> Channel;
    cv::split(src, Channel);
 
    // 计算通道灰度值均值
    double Bm = cv::mean(Channel[0])[0];
    double Gm = cv::mean(Channel[1])[0];
    double Rm = cv::mean(Channel[2])[0];
    double Km = (Bm + Gm + Rm) / 3;
 
    // 通道灰度值调整
    Channel[0] *= Km / Bm;
    Channel[1] *= Km / Gm;
    Channel[2] *= Km / Rm;
 
    // 合并通道
    cv::merge(Channel, result);
 
    return result;
}


1.9、白平衡-完美反射

//--------------------------------------------------------------------------------
// 白平衡-完美反射
cv::Mat WhiteBalcane_PRA(cv::Mat src)
{
    cv::Mat result = src.clone();
    if (src.channels() != 3)
    {
        std::cout << "The number of image channels is not 3." << std::endl;
        return result;
    }
 
    // 通道分离
    std::vector<cv::Mat> Channel;
    cv::split(src, Channel);
 
    // 定义参数
    int row = src.rows;
    int col = src.cols;
    int RGBSum[766] = { 0 };
    uchar maxR, maxG, maxB;
 
    // 计算单通道最大值
    for (int i = 0; i < row; ++i)
    {
        uchar *b = Channel[0].ptr<uchar>(i);
        uchar *g = Channel[1].ptr<uchar>(i);
        uchar *r = Channel[2].ptr<uchar>(i);
        for (int j = 0; j < col; ++j)
        {
            int sum = b[j] + g[j] + r[j];
            RGBSum[sum]++;
            maxB = cv::max(maxB, b[j]);
            maxG = cv::max(maxG, g[j]);
            maxR = cv::max(maxR, r[j]);
        }
    }
 
    // 计算最亮区间下限T
    int T = 0;
    int num = 0;
    int K = static_cast<int>(row * col * 0.1);
    for (int i = 765; i >= 0; --i)
    {
        num += RGBSum[i];
        if (num > K)
        {
            T = i;
            break;
        }
    }
    
    // 计算单通道亮区平均值
    double Bm = 0.0, Gm = 0.0, Rm = 0.0;
    int count = 0;
    for (int i = 0; i < row; ++i)
    {
        uchar *b = Channel[0].ptr<uchar>(i);
        uchar *g = Channel[1].ptr<uchar>(i);
        uchar *r = Channel[2].ptr<uchar>(i);
        for (int j = 0; j < col; ++j)
        {
            int sum = b[j] + g[j] + r[j];
            if (sum > T)
            {
                Bm += b[j];
                Gm += g[j];
                Rm += r[j];
                count++;
            }
        }
    }
    Bm /= count;
    Gm /= count;
    Rm /= count;
 
    // 通道调整
    Channel[0] *= maxB / Bm;
    Channel[1] *= maxG / Gm;
    Channel[2] *= maxR / Rm;
 
    // 合并通道
    cv::merge(Channel, result);
 
    return result;
}


1.10、浮雕

//--------------------------------------------------------------------------------
// 浮雕
cv::Mat Relief(cv::Mat src)
{
    CV_Assert(src.channels() == 3);
    int row = src.rows;
    int col = src.cols;
    cv::Mat temp = src.clone();
    for (int i = 1; i < row-1; ++i)
    {
        uchar *s1 = src.ptr<uchar>(i - 1);
        uchar *s2 = src.ptr<uchar>(i + 1);
        uchar *t = temp.ptr<uchar>(i);
        for (int j = 1; j < col-1; ++j)
        {
            for (int k = 0; k < 3; ++k)
            {
                int RGB = s1[3 * (j - 1) + k] - s2[3 * (j + 1) + k] + 128;
                if (RGB < 0)RGB = 0;
                if (RGB > 255)RGB = 255;
                t[3*j+k] =(uchar)RGB;
            }
        }
    }
    return temp;
}


1.11、羽化

//--------------------------------------------------------------------------------
// 羽化
cv::Mat Eclosion(cv::Mat src, cv::Point center, float level)
{
    if (level > 0.9)
        level = 0.9f;
    float diff = (1-level) * (src.rows / 2 * src.rows / 2 + src.cols / 2 * src.cols / 2);
    cv::Mat result = src.clone();
    for (int i = 0; i < result.rows; ++i)
    {
        for (int j = 0; j < result.cols; ++j)
        {
            float dx = float(center.x - j);
            float dy = float(center.y - i);
            float ra = dx * dx + dy * dy;
            float m = ((ra-diff) / diff * 255)>0? ((ra - diff) / diff * 255):0;
            int b = result.at<cv::Vec3b>(i, j)[0];
            int g = result.at<cv::Vec3b>(i, j)[1];
            int r = result.at<cv::Vec3b>(i, j)[2];
            b = (int)(b+ m);
            g = (int)(g + m);
            r = (int)(r + m);
            result.at<cv::Vec3b>(i, j)[0] = (b > 255 ? 255 : (b < 0 ? 0 : b));
            result.at<cv::Vec3b>(i, j)[1] = (g > 255 ? 255 : (g < 0 ? 0 : g));
            result.at<cv::Vec3b>(i, j)[2] = (r > 255 ? 255 : (r < 0 ? 0 : r));
        }
    }
    return result;
}


1.12、锐化

//--------------------------------------------------------------------------------
// 锐化
cv::Mat Sharpen(cv::Mat input, int percent, int type)
{
    cv::Mat result;
    cv::Mat s = input.clone();
    cv::Mat kernel;
    switch (type)
    {
    case 0:
        kernel = (cv::Mat_<int>(3, 3) <<
            0, -1, 0,
            -1, 4, -1,
            0, -1, 0
            );
    case 1:
        kernel = (cv::Mat_<int>(3, 3) <<
            -1, -1, -1,
            -1, 8, -1,
            -1, -1, -1
            );
    default:
        kernel = (cv::Mat_<int>(3, 3) <<
            0, -1, 0,
            -1, 4, -1,
            0, -1, 0
            );
    }
    cv::filter2D(s, s, s.depth(), kernel);
    result = input + s * 0.01 * percent;
    return result;
}


1.13、颗粒感

//--------------------------------------------------------------------------------
// 颗粒感
cv::Mat Grainy(cv::Mat src, int level)
{
    int row = src.rows;
    int col = src.cols;
    if (level > 100)
        level = 100;
    if (level < 0)
        level = 0;
    cv::Mat result = src.clone();
    for (int i = 0; i < row; ++i)
    {
        uchar *t = result.ptr<uchar>(i);
        for (int j = 0; j < col; ++j)
        {
            for (int k = 0; k < 3; ++k)
            {
                int temp = t[3 * j + k];
                temp += ((rand() % (2 * level)) - level);
                if (temp < 0)temp = 0;
                if (temp > 255)temp = 255;
                t[3 * j + k] = temp;
            }
        }
    }
    return result;
}


二、实战案例
2.1、主函数

#include<opencv2\opencv.hpp>
//using namespace cv;
//using namespace std;

#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))

//函数申明
cv::Mat Brightness(cv::Mat src, float brightness, int contrast);                //亮度+对比度。
cv::Mat Saturation(cv::Mat src, int saturation);                                //饱和度
cv::Mat HighLight(cv::Mat src, int highlight);                                    //高光
cv::Mat ColorTemperature(cv::Mat src, int warm);                                //暖色调
cv::Mat Shadow(cv::Mat src, int shadow);                                        //阴影

cv::Mat Sharpen(cv::Mat input, int percent, int type);                            //图像锐化
cv::Mat Grainy(cv::Mat src, int level);                                            //颗粒感
cv::Mat Cartoon(cv::Mat src, double clevel, int d, double sigma, int size);        //漫画效果
cv::Mat WhiteBalcane_PRA(cv::Mat src);                                            //白平衡-完美反射算法（效果偏白）
cv::Mat WhiteBalcane_Gray(cv::Mat src);                                            //白平衡-灰度世界算法（效果偏蓝）
cv::Mat Relief(cv::Mat src);                                                    //浮雕
cv::Mat Eclosion(cv::Mat src, cv::Point center, float level);                    //羽化


int main(int argc, char* argv[])
{
    //（1）读取图像
    std::string img_path = "test.jpg";
    cv::Mat src = cv::imread(img_path, 1);

    //（2）判断图像是否读取成功
    if (!src.data)
    {
        std::cout << "can't read image!" << std::endl;
        return -1;
    }

    float brightness_value = 1;        //[0, 10]            亮度。暗~亮：[0, 1] ~ [1, 10]
    int contrast_value = 0;            //[-100, 100]        对比度。
    int saturation_value = 0;        //[-100, 100]        饱和度。
    int highlight_value = 0;        //[-100, 100]        高光。
    int warm_value = 0;                //[-100, 100]        暖色调。
    int shadow_value = 0;            //[-100, 100]        阴影。
    int sharpen_value = 0;            //[-100, 100]        锐化。[-1000000, 1000000]
    int grainy_value = 0;            //[0, 100]            颗粒感。

    int eclosion_flag = 0;            //[0, 1]            羽化。
    int cartoon_flag = 0;            //[0, 1]            漫画效果。clevel阈值40-80，d阈值0-10，sigma阈值10-250，size阈值10-25
    int reflect_flag = 0;            //[0, 1]            白平衡-完美反射。
    int world_flag = 0;                //[0, 1]            白平衡-灰度世界。
    int relief_flag = 0;            //[0, 1]            浮雕。


    cv::Mat dst = src.clone();
    if (brightness_value != 1)
        dst = Brightness(dst, brightness_value, 0);
    if (contrast_value != 0)
        dst = Brightness(dst, 1, contrast_value);
    if (saturation_value != 0)
        dst = Saturation(dst, saturation_value);
    if (highlight_value != 0)
        dst = HighLight(dst, highlight_value);
    if (warm_value != 0)
        dst = ColorTemperature(dst, warm_value);
    if (shadow_value != 0)
        dst = Shadow(dst, shadow_value);
    if (sharpen_value != 0)
        dst = Sharpen(dst, sharpen_value, 0);
    if (grainy_value != 0)
        dst = Grainy(dst, grainy_value);

    if (cartoon_flag != 0)
        dst = Cartoon(dst, 80, 5, 150, 20);        //clevel阈值40-80，d阈值0-10，sigma阈值10-250，size阈值10-25说
    if (reflect_flag != 0)
        dst = WhiteBalcane_PRA(dst);
    if (world_flag != 0)
        dst = WhiteBalcane_Gray(dst);
    if (relief_flag != 0)
        dst = Relief(dst);
    if (eclosion_flag != 0)
        dst = Eclosion(dst, cv::Point(src.cols / 2, src.rows / 2), 0.8f);


    //（4）显示图像
    cv::imshow("src", src);
    cv::imshow("锐化", dst);
    cv::waitKey(0);        //等待用户任意按键后结束暂停功能
    return 0;
}


2.2、函数定义

//--------------------------------------------------------------------------------
//调整对比度与亮度
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::saturate_cast<uchar>(r * alpha + beta);        //修改通道的像素值（red）
            }
            else if (src.channels() == 1)
            {
                float v = src.at<uchar>(row, col);                                            //获取通道的像素值（单）
                dst.at<uchar>(row, col) = cv::saturate_cast<uchar>(v * alpha + beta);        //修改通道的像素值（单）
                //saturate_cast<uchar>：主要是为了防止颜色溢出操作。如果color<0，则color等于0；如果color>255，则color等于255。
            }
        }
    }
    return dst;
}

//--------------------------------------------------------------------------------
// 饱和度
cv::Mat Saturation(cv::Mat src, int 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;
}

//--------------------------------------------------------------------------------
// 高光
cv::Mat HighLight(cv::Mat src, int highlight)
{
    // 生成灰度图
    cv::Mat gray = cv::Mat::zeros(src.size(), CV_32FC1);
    cv::Mat f = src.clone();
    f.convertTo(f, CV_32FC3);
    std::vector<cv::Mat> pics;
    split(f, pics);
    gray = 0.299f*pics[2] + 0.587*pics[2] + 0.114*pics[0];
    gray = gray / 255.f;
 
    // 确定高光区
    cv::Mat thresh = cv::Mat::zeros(gray.size(), gray.type());
    thresh = gray.mul(gray);
    // 取平均值作为阈值
    cv::Scalar t = mean(thresh);
    cv::Mat mask = cv::Mat::zeros(gray.size(), CV_8UC1);
    mask.setTo(255, thresh >= t[0]);
 
    // 参数设置
    int max = 4;
    float bright = highlight / 100.0f / max;
    float mid = 1.0f + max * bright;
 
    // 边缘平滑过渡
    cv::Mat midrate = cv::Mat::zeros(src.size(), CV_32FC1);
    cv::Mat brightrate = cv::Mat::zeros(src.size(), CV_32FC1);
    for (int i = 0; i < src.rows; ++i)
    {
        uchar *m = mask.ptr<uchar>(i);
        float *th = thresh.ptr<float>(i);
        float *mi = midrate.ptr<float>(i);
        float *br = brightrate.ptr<float>(i);
        for (int j = 0; j < src.cols; ++j)
        {
            if (m[j] == 255)
            {
                mi[j] = mid;
                br[j] = bright;
            }
            else {
                mi[j] = (mid - 1.0f) / t[0] * th[j] + 1.0f;
                br[j] = (1.0f / t[0] * th[j])*bright;
            }
        }
    }
 
    // 高光提亮，获取结果图
    cv::Mat result = cv::Mat::zeros(src.size(), src.type());
    for (int i = 0; i < src.rows; ++i)
    {
        float *mi = midrate.ptr<float>(i);
        float *br = brightrate.ptr<float>(i);
        uchar *in = src.ptr<uchar>(i);
        uchar *r = result.ptr<uchar>(i);
        for (int j = 0; j < src.cols; ++j)
        {
            for (int k = 0; k < 3; ++k)
            {
                float temp = pow(float(in[3 * j + k]) / 255.f, 1.0f / mi[j])*(1.0 / (1 - br[j]));
                if (temp > 1.0f)
                    temp = 1.0f;
                if (temp < 0.0f)
                    temp = 0.0f;
                uchar utemp = uchar(255*temp);
                r[3 * j + k] = utemp;
            }
 
        }
    }
    return result;
}

//--------------------------------------------------------------------------------
// 暖色调
cv::Mat ColorTemperature(cv::Mat src, int warm)
{
    cv::Mat result = src.clone();
    int row = src.rows;
    int col = src.cols;
    int level = warm/2;
    for (int i = 0; i < row; ++i)
    {
        uchar* a = src.ptr<uchar>(i);
        uchar* r = result.ptr<uchar>(i);
        for (int j = 0; j < col; ++j)
        {
            int R,G,B;
            // R通道
            R = a[j * 3 + 2];
            R = R + level;
            if (R > 255) 
            {
                r[j * 3 + 2] = 255;
            }
            else if (R < 0) 
            {
                r[j * 3 + 2] = 0;
            }
            else 
            {
                r[j * 3 + 2] = R;
            }
            // G通道
            G = a[j * 3 + 1];
            G = G + level;
            if (G > 255) 
            {
                r[j * 3 + 1] = 255;
            }
            else if (G < 0) 
            {
                r[j * 3 + 1] = 0;
            }
            else 
            {
                r[j * 3 + 1] = G;
            }
            // B通道
            B = a[j * 3];
            B = B - level;
            if (B > 255) 
            {
                r[j * 3] = 255;
            }
            else if (B < 0) 
            {
                r[j * 3] = 0;
            }
            else {
                r[j * 3] = B;
            }
        }
    }
    return result;
}

//--------------------------------------------------------------------------------
// 阴影
cv::Mat Shadow(cv::Mat src, int shadow)
{
    // 生成灰度图
    cv::Mat gray = cv::Mat::zeros(src.size(), CV_32FC1);
    cv::Mat f = src.clone();
    f.convertTo(f, CV_32FC3);
    std::vector<cv::Mat> pics;
    split(f, pics);
    gray = 0.299f*pics[2] + 0.587*pics[2] + 0.114*pics[0];
    gray = gray / 255.f;
 
    // 确定阴影区
    cv::Mat thresh = cv::Mat::zeros(gray.size(), gray.type());    
    thresh = (1.0f - gray).mul(1.0f - gray);
    // 取平均值作为阈值
    cv::Scalar t = mean(thresh);
    cv::Mat mask = cv::Mat::zeros(gray.size(), CV_8UC1);
    mask.setTo(255, thresh >= t[0]);
 
    // 参数设置
    int max = 4;
    float bright = shadow / 100.0f / max;
    float mid = 1.0f + max * bright;
 
    // 边缘平滑过渡
    cv::Mat midrate = cv::Mat::zeros(src.size(), CV_32FC1);
    cv::Mat brightrate = cv::Mat::zeros(src.size(), CV_32FC1);
    for (int i = 0; i < src.rows; ++i)
    {
        uchar *m = mask.ptr<uchar>(i);
        float *th = thresh.ptr<float>(i);
        float *mi = midrate.ptr<float>(i);
        float *br = brightrate.ptr<float>(i);
        for (int j = 0; j < src.cols; ++j)
        {
            if (m[j] == 255)
            {
                mi[j] = mid;
                br[j] = bright;
            }
            else 
            {
                mi[j] = (mid - 1.0f) / t[0] * th[j]+ 1.0f;   
                br[j] = (1.0f / t[0] * th[j])*bright;               
            }
        }
    }
 
    // 阴影提亮，获取结果图
    cv::Mat result = cv::Mat::zeros(src.size(), src.type());
    for (int i = 0; i < src.rows; ++i)
    {
        float *mi = midrate.ptr<float>(i);
        float *br = brightrate.ptr<float>(i);
        uchar *in = src.ptr<uchar>(i);
        uchar *r = result.ptr<uchar>(i);
        for (int j = 0; j < src.cols; ++j)
        {
            for (int k = 0; k < 3; ++k)
            {
                float temp = pow(float(in[3 * j + k]) / 255.f, 1.0f / mi[j])*(1.0 / (1 - br[j]));
                if (temp > 1.0f)
                    temp = 1.0f;
                if (temp < 0.0f)
                    temp = 0.0f;
                uchar utemp = uchar(255*temp);
                r[3 * j + k] = utemp;
            }
 
        }
    }
    return result;
}

//--------------------------------------------------------------------------------
// 漫画效果
cv::Mat Cartoon(cv::Mat src, double clevel, int d, double sigma, int size)
{
    //（1）中值滤波
    cv::Mat m;
    cv::medianBlur(src, m, 7);
    //（2）提取轮廓
    cv::Mat c;
    clevel = cv::max(40., cv::min(80., clevel));
    cv::Canny(m, c, clevel, clevel *3);
    //（3）轮廓膨胀
    cv::Mat k = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(2, 2));
    cv::dilate(c, c, k);
    //（4）图像反转
    c = c / 255;
    c = 1 - c;
    //（5）均值滤波
    cv::Mat cf;
    c.convertTo(cf, CV_32FC1);                // 类型转换        
    cv::blur(cf, cf, cv::Size(5, 5));        
    //（6）双边滤波
    cv::Mat srcb;
    d = cv::max(0, cv::min(10, d));
    sigma = cv::max(10., cv::min(250., sigma));
    cv::bilateralFilter(src, srcb, d, sigma, sigma);
    size = cv::max(10, cv::min(25, size));
    cv::Mat temp = srcb / size;
    temp = temp * size;
    //（7）通道合并
    cv::Mat c3;
    cv::Mat cannyChannels[] = { cf, cf, cf };
    cv::merge(cannyChannels, 3, c3);
    //（8）图像相乘
    cv::Mat tempf;
    temp.convertTo(tempf, CV_32FC3);        // 类型转换
    cv::multiply(tempf, c3, tempf);            
    tempf.convertTo(temp, CV_8UC3);            // 类型转换
    return temp;
}

//--------------------------------------------------------------------------------
// 白平衡-灰度世界
cv::Mat WhiteBalcane_Gray(cv::Mat src)
{
    //（1）3通道处理
    cv::Mat result = src.clone();
    if (src.channels() != 3)
    {
        std::cout << "The number of image channels is not 3." << std::endl;
        return result;
    }
     //（2）通道分离
    std::vector<cv::Mat> Channel;
    cv::split(src, Channel);
     //（3）计算通道灰度值均值
    double Bm = cv::mean(Channel[0])[0];
    double Gm = cv::mean(Channel[1])[0];
    double Rm = cv::mean(Channel[2])[0];
    double Km = (Bm + Gm + Rm) / 3;
     //（4）通道灰度值调整
    Channel[0] *= Km / Bm;
    Channel[1] *= Km / Gm;
    Channel[2] *= Km / Rm;
    //（5）通道合并
    cv::merge(Channel, result);
     return result;
}

//--------------------------------------------------------------------------------
// 白平衡-完美反射
cv::Mat WhiteBalcane_PRA(cv::Mat src)
{
    //（1）3通道处理
    cv::Mat result = src.clone();
    if (src.channels() != 3)
    {
        std::cout << "The number of image channels is not 3." << std::endl;
        return result;
    }
     //（2）通道分离
    std::vector<cv::Mat> Channel;
    cv::split(src, Channel);
     //（3）计算单通道最大值
    int row = src.rows;
    int col = src.cols;
    int RGBSum[766] = { 0 };
    uchar maxR, maxG, maxB;
     for (int i = 0; i < row; ++i)
    {
        uchar *b = Channel[0].ptr<uchar>(i);
        uchar *g = Channel[1].ptr<uchar>(i);
        uchar *r = Channel[2].ptr<uchar>(i);
        for (int j = 0; j < col; ++j)
        {
            int sum = b[j] + g[j] + r[j];
            RGBSum[sum]++;
            maxB = cv::max(maxB, b[j]);
            maxG = cv::max(maxG, g[j]);
            maxR = cv::max(maxR, r[j]);
        }
    }
     //（4）计算最亮区间下限T
    int T = 0;
    int num = 0;
    int K = static_cast<int>(row * col * 0.1);
    for (int i = 765; i >= 0; --i)
    {
        num += RGBSum[i];
        if (num > K)
        {
            T = i;
            break;
        }
    }
    //（5）计算单通道亮区平均值
    double Bm = 0.0, Gm = 0.0, Rm = 0.0;
    int count = 0;
    for (int i = 0; i < row; ++i)
    {
        uchar *b = Channel[0].ptr<uchar>(i);
        uchar *g = Channel[1].ptr<uchar>(i);
        uchar *r = Channel[2].ptr<uchar>(i);
        for (int j = 0; j < col; ++j)
        {
            int sum = b[j] + g[j] + r[j];
            if (sum > T)
            {
                Bm += b[j];
                Gm += g[j];
                Rm += r[j];
                count++;
            }
        }
    }
    Bm /= count;
    Gm /= count;
    Rm /= count;
     //（6）通道调整
    Channel[0] *= maxB / Bm;
    Channel[1] *= maxG / Gm;
    Channel[2] *= maxR / Rm;
     //（7）通道合并
    cv::merge(Channel, result);
     return result;
}

//--------------------------------------------------------------------------------
// 浮雕
cv::Mat Relief(cv::Mat src)
{
    CV_Assert(src.channels() == 3);
    int row = src.rows;
    int col = src.cols;
    cv::Mat temp = src.clone();
    for (int i = 1; i < row-1; ++i)
    {
        uchar *s1 = src.ptr<uchar>(i - 1);
        uchar *s2 = src.ptr<uchar>(i + 1);
        uchar *t = temp.ptr<uchar>(i);
        for (int j = 1; j < col-1; ++j)
        {
            for (int k = 0; k < 3; ++k)
            {
                int RGB = s1[3 * (j - 1) + k] - s2[3 * (j + 1) + k] + 128;
                if (RGB < 0)RGB = 0;
                if (RGB > 255)RGB = 255;
                t[3*j+k] =(uchar)RGB;
            }
        }
    }
    return temp;
}

//--------------------------------------------------------------------------------
// 羽化
cv::Mat Eclosion(cv::Mat src, cv::Point center, float level)
{
    if (level > 0.9)
        level = 0.9f;
    float diff = (1-level) * (src.rows / 2 * src.rows / 2 + src.cols / 2 * src.cols / 2);
    cv::Mat result = src.clone();
    for (int i = 0; i < result.rows; ++i)
    {
        for (int j = 0; j < result.cols; ++j)
        {
            float dx = float(center.x - j);
            float dy = float(center.y - i);
            float ra = dx * dx + dy * dy;
            float m = ((ra-diff) / diff * 255)>0? ((ra - diff) / diff * 255):0;
            int b = result.at<cv::Vec3b>(i, j)[0];
            int g = result.at<cv::Vec3b>(i, j)[1];
            int r = result.at<cv::Vec3b>(i, j)[2];
            b = (int)(b+ m);
            g = (int)(g + m);
            r = (int)(r + m);
            result.at<cv::Vec3b>(i, j)[0] = (b > 255 ? 255 : (b < 0 ? 0 : b));
            result.at<cv::Vec3b>(i, j)[1] = (g > 255 ? 255 : (g < 0 ? 0 : g));
            result.at<cv::Vec3b>(i, j)[2] = (r > 255 ? 255 : (r < 0 ? 0 : r));
        }
    }
    return result;
}

//--------------------------------------------------------------------------------
// 锐化
cv::Mat Sharpen(cv::Mat input, int percent, int type)
{
    cv::Mat result;
    cv::Mat s = input.clone();
    cv::Mat kernel;
    switch (type)
    {
    case 0:
        kernel = (cv::Mat_<int>(3, 3) <<
            0, -1, 0,
            -1, 4, -1,
            0, -1, 0
            );
    case 1:
        kernel = (cv::Mat_<int>(3, 3) <<
            -1, -1, -1,
            -1, 8, -1,
            -1, -1, -1
            );
    default:
        kernel = (cv::Mat_<int>(3, 3) <<
            0, -1, 0,
            -1, 4, -1,
            0, -1, 0
            );
    }
    cv::filter2D(s, s, s.depth(), kernel);
    result = input + s * 0.01 * percent;
    return result;
}

//--------------------------------------------------------------------------------
// 颗粒感
cv::Mat Grainy(cv::Mat src, int level)
{
    int row = src.rows;
    int col = src.cols;
    if (level > 100)
        level = 100;
    if (level < 0)
        level = 0;
    cv::Mat result = src.clone();
    for (int i = 0; i < row; ++i)
    {
        uchar *t = result.ptr<uchar>(i);
        for (int j = 0; j < col; ++j)
        {
            for (int k = 0; k < 3; ++k)
            {
                int temp = t[3 * j + k];
                temp += ((rand() % (2 * level)) - level);
                if (temp < 0)temp = 0;
                if (temp > 255)temp = 255;
                t[3 * j + k] = temp;
            }
        }
    }
    return result;
}


————————————————

                            版权声明：本文为博主原创文章，未经作者允许不得转载，且不得用于商业目的，否则将追究法律责任。
                        
原文链接：https://blog.csdn.net/shinuone/article/details/130614629

生活需要深度
关注
专栏目录
C++--图像处理
CSTGlisan的博客
11-18 1031
给定n行m列的图像各像素点的灰度值，要求用如下方法对其进行模糊化处理：
C++ 图像处理
最新发布
wy749929317的博客
06-20 835
OpenCV提供了丰富的图片处理功能。
C++图像处理程序
03-07
C++图像处理程序，开发环境为Microsoft Visual C++,可直接运行，带有实验图片，可实现的功能有伪彩色、灰度化、灰度变换、直方图均衡、均值滤波、中值滤波、一阶微分锐化、镜像、平移等众多功能。
C++图像处理系统(源码)
12-10
图像处理系统是一个典型的图像处理软件，它由图像显示、图像转换、图像处理、字符识别、其他和帮助等几部分组成。  图像显示模块 该模块主要包括显示位图、显示JPEG、显示GIF 3个部分。  图像转换模块 该模块主要包括位图转换为JPEG、JPEG转换为位图、位图转换为GIF，GIF转换为位图4个部分。  图像处理模块 该模块主要包括图像旋转、图像锐化处理、图像反色处理、灰度化处理、线性变换5个部分。  字符识别模块 该模块主要包含手写数字识别。  其他 该模块主要包括设置菜单的固定颜色和随机颜色两个部分。  帮助模块 该模块主要包括软件的版本、开发单位等信息。
使用OpenCV处理图片的亮度、对比度、曝光、高光、阴影、饱和度、
05-22
本文将深入探讨如何在iOS平台上集成OpenCV，并利用它来调整图片的各种视觉属性，包括亮度、对比度、曝光、高光、阴影、饱和度以及色温、色相。我们将结合源代码来理解这些概念及其实现。 首先，要在iOS项目中集成...
基于QT5+Opencv完成简单的图像处理及视频处理软件
02-25
图像处理包括：灰度化、均值滤波、边缘检测、伽马变换、旋转镜像、亮度调节、二值化、对比度，饱和度调节、色彩调节、图片保存、水印等。 视频处理包括：二值化、边缘检测、灰度化、平滑、局部马赛克、缩放等。 此外...
VisualC++数字图像处理技术详解 PDF电子书+源代码.part1
07-08
VisualC++数字图像处理技术详解 PDF电子书+源代码 第一部分 ...同时，《Visual C++数字图像处理技术详解》还介绍了Visual C++与VTK、OpenCV和MATLAB等开发平台相结合进行数字图像处理的程序设计技术。
VisualC++数字图像处理技术详解 PDF电子书+源代码.part3
07-08
VisualC++数字图像处理技术详解 PDF电子书+源代码.part3 ...同时，《Visual C++数字图像处理技术详解》还介绍了Visual C++与VTK、OpenCV和MATLAB等开发平台相结合进行数字图像处理的程序设计技术。
Python+OpenCV实现AI人脸识别身份认证系统(4)—人脸识别
热门推荐
不脱发的程序猿
07-16 7万+
本篇博文是Python+OpenCV实现AI人脸识别身份认证系统的收官之作，在人脸识别原理到数据采集、存储和训练识别模型基础上，实现人脸识别，废话少说，上效果图： 案例引入 在Python+OpenCV实现AI人脸识别身份认证系统(3)——训练人脸识别模型中主要讲述神经网络模型的训练过程，使用OpenCV模块中的LBPH（LOCAL BINARY PATTERNS HISTOGRAMS）...
c++ 图像处理
07-03
本代码详细描述了c++图像处理，以mfc为框架，代码量较为详细，是深入学习图像处理的好例子。
C++图像处理算法
11-03
《Visual C++数字图像处理技术详解》.(刘海波,沈晶).[PDF]完整目录版
C++图像处理
06-06
C++语言编写的图像处理，完整工程文件，包括灰度、二值、平滑、锐化、轮廓提取、浮雕等功能，接近于MFC的简单WINDOWs程序界面。应付一般的程序设计实践足够。
数字图像处理，c++
08-23
本书是数字图像处理 c++版，对图像处理一些基础算法原理讲解，并用c++实现。
[C++] 图像处理
qq_53530146的博客
05-12 1676
额 打算用FreeType获取字体像素，然后贴在一张图上 然后这个就是图像处理工具，只有复制和镜像，但足够了 （旋转缩放难倒我了） 使用完成后需要手动释放资源（干脆用智能指针它不香吗） 代码 #ifndef __IMAGE_PROCESSING_HPP__ #define __IMAGE_PROCESSING_HPP__ #include <string> typedef unsigned int uint; typedef unsigned char uchar; typedef std:
C++图像处理与计算机视觉：实现智能图像识别与处理
程序员光剑
01-26 1356
1. 背景介绍 随着计算机技术的飞速发展，图像处理与计算机视觉领域取得了显著的进步。在这个过程中，C++作为一种高效、灵活且功能强大的编程语言，成为了许多研究人员和工程师的首选。本文将深入探讨C++在图像处理与计算机视觉领域的应用，包括核心概念、算法原理、实际应用场景以及工具和资源推荐等内容。 1.1 图像处理与计算机视觉的区别与联系 图像处理和计算机视觉虽然有很多相似之处，但它们之间还是存...
C++进行简单的图像处理
p_mouren的博客
09-30 5395
本文中介绍了用opencv处理图像的一些简单方法，并给出了代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值