C++版本OpenCV操作记录

#include   // image文件读取与写入
#include   // 高等级gui
#include   // 图像处理
#include 

using namespace cv;
using namespace std;


void opColorTrans(string image_filepath);  // 颜色模式转换
void opMat(string image_filepath);  // Mat学习
void matVisit(string image_filepath);  // Mat遍历
void matOperate(string image_filepath);  // Mat加减乘除
void colorStyle(string image_filepath);  // 颜色模式
void bitwise(string image_filepath);  // 像素逻辑操作
void channelOp(string image_filepath);  // 通道处理
void inrangOp(string image_filepath);  // color范围提取
void colorStatistic(string image_filepath);  // color统计信息
void drawShape(string image_filepath);  // 形状绘制
void imageNorm(string image_filepath);  // image norm
void resizeFlipRotate(string image_filepath);  // 图像缩放,插值,翻转，旋转
void videoProcess(string video_filepath);  // 视频加载
void videoProcess_2(string video_filepath);  // 处理视频
void cnnOp(string image_filepath);  // 卷积处理



int main(){

    string image_filepath = "../../resources/1.png";
    string image_filepath_4 = "../../resources/4.png";
    string video_filepath = "../../resources/1.mp4";
    string video_filepath_2 = "../../resources/save.mp4";
    
    // 输入image颜色模式的转换
    // opColorTrans(image_filepath);

    // Mat类学习
    // opMat(image_filepath);

    // Mat遍历
    // matVisit(image_filepath);

    // Mat加减乘除
    // matOperate(image_filepath);

    // 颜色模式
    // colorStyle(image_filepath);

    // 像素的逻辑操作
    // bitwise(image_filepath);

    // 通道处理
    // channelOp(image_filepath);

    // color范围提取
    // inrangOp(image_filepath_4);

    // color统计信息
    // colorStatistic(image_filepath);

    // 形状绘制
    // drawShape(image_filepath);

    // image norm
    // imageNorm(image_filepath);

    // 图像缩放,插值,翻转，旋转
    // resizeFlipRotate(image_filepath);

    // 视频加载
    // videoProcess(video_filepath_2);

    // 视频处理
    // videoProcess_2(video_filepath);

    // 卷积处理
    cnnOp(image_filepath);

    return 0;
}

void cnnOp(string image_filepath){
    Mat img = imread(image_filepath);
    imshow("img", img);

    // 均值模糊卷积核
    Mat dst;
    blur(img, dst, Size(13, 13), Point(-1. -1));  // 3x3卷积核的高斯模糊， Point默认的卷积核中心位置
    imshow("dst", dst);

    // 高斯模糊卷积核
    Mat dst2;
    GaussianBlur(img, dst2, Size(5, 5), 15, 15);  // 最后两个是告诉函数的gamma参数， size必须奇数，size为0的时候模糊程度最高(她会自动模糊)
    imshow("dst2", dst2);


    waitKey(0);
}

void videoProcess_2(string video_filepath){
    VideoCapture capture(0);  // 只有0的时候表示打开摄像头

    int frame_width = capture.get(CAP_PROP_FRAME_WIDTH);  // 宽度(同样也有set方法)
    int frame_height = capture.get(CAP_PROP_FRAME_HEIGHT);  // 宽度
    int count = capture.get(CAP_PROP_FRAME_COUNT);  // 总帧数
    int fps = capture.get(CAP_PROP_FPS);  //  fps是1s钟能处理多少张图像的能力，越多实时性越好,15/s肉眼看不出卡顿，30/s相当流畅，在大就是快进了
    cout<< "size: " << frame_width << "x" << frame_height << ", count: " << count << ", fps: " << fps < mv;  // minMaxLoc只能逐通道求最大最小
    split(img, mv);
    for(int i=0; i mv;  // 分离出来的每个通道是存在的vector中
    split(img, mv);  // 分离出3个通道
    imshow("mv[0]", mv[0]);  // 因为这里的可视化都是只有一个通道，所以看着都是灰度图
    imshow("mv[1]", mv[1]);
    imshow("mv[2]", mv[2]);


    // 通道合并
    Mat dst;
    mv[1] = 0;  // 把其他通道弄为0，然后在把3通道合并，就可以生成彩色图了
    mv[2] = 0;
    merge(mv, dst);
    imshow("dst", dst);


    // 通道混合
    int from_to[] = {0, 2, 1, 1, 2, 0};  // 0通道->2通道， 1->1, 2->0
    mixChannels(&img, 1, &dst, 1, from_to, 3);  // 将输入数组的指定通道复制到输出数组的指定通道。
    // 从img，到dst，的转换规则是from_to;  1个img, 1个dst， 3个通道
    imshow("dst", dst);

    waitKey(0); 
}

void bitwise(string image_filepath){
    // 空白图像
    Mat m1 = Mat::zeros(Size(256, 256), CV_8UC3);
    Mat m2 = Mat::zeros(Size(256, 256), CV_8UC3);

    // 底板图像， 矩形起点与宽高， 颜色， 线宽(-1是填充), 处理锯齿的规则，
    rectangle(m1, Rect(100, 100, 80, 80), Scalar(255, 255, 0), -1, LINE_8, 0);
    rectangle(m2, Rect(150, 150, 80, 80), Scalar(0, 255, 255), -1, LINE_8, 0);

    imshow("m1", m1);
    imshow("m2", m2);

    // 逻辑操作
    Mat dst1, dst2, dst3;
    bitwise_and(m1, m2, dst1);  // and
    bitwise_or(m1, m2, dst2);  // or
    bitwise_not(m1, dst3);  // not
    imshow("dst1", dst1);
    imshow("dst2", dst2);
    imshow("dst3", dst3);

    waitKey(0); 
}

void colorStyle(string image_filepath){
    Mat img = imread(image_filepath);
    imshow("img", img);
    waitKey(1000); 

    // 自带颜色表操作代码19个
    int colormap[] = {
        COLORMAP_AUTUMN,
        COLORMAP_BONE,
        COLORMAP_JET,
        COLORMAP_WINTER,
        COLORMAP_RAINBOW,
        COLORMAP_OCEAN,
        COLORMAP_SUMMER,
        COLORMAP_SPRING,
        COLORMAP_COOL,
        COLORMAP_PINK,
        COLORMAP_HOT,
        COLORMAP_PARULA,
        COLORMAP_MAGMA,
        COLORMAP_INFERNO,
        COLORMAP_PLASMA,
        COLORMAP_VIRIDIS,
        COLORMAP_CIVIDIS,
        COLORMAP_TWILIGHT,
        COLORMAP_TWILIGHT_SHIFTED
    };

    Mat dst;
    int index = 0;

    while(true){
        int c = waitKey(2000);
        // 退出
        if(c == 27){
            break;
        }
        applyColorMap(img, dst, colormap[index%19]);
        index++;
        imshow("dst", dst);
    }
}

void matOperate(string image_filepath){
    Mat img = imread(image_filepath);
    imshow("img", img);
    waitKey(0); 

    Mat dst;
    dst = img + Scalar(50, 50, 50);  // 加法操作

    imshow("img", dst);
    waitKey(0); 
}

void matVisit(string image_filepath){

    Mat img = imread(image_filepath);
    imshow("img", img);
    waitKey(0); 

    // 操作像素点
    int w = img.cols;  // 列
    int h = img.rows;  // 行 
    int channel = img.channels();  // 通道

    /** 
     for(int row = 0; row < h; row++){
        for(int col = 0; col < w; col++){
            // 灰度图
            if(channel == 1){
                // uchar取值是8位的 0～255
                int pv = img.at(row, col);  // 获取像素值
                img.at(row, col) = 255 - pv;  // 修改像素值
            }
            // 彩色图
            if(channel == 3){
                // Vec3b一次性就存放了3个值，其实是一个数组
                Vec3b bgr = img.at(row, col);  // 获取像素值，这里一次性获取3个数据值
                img.at(row, col)[0] = 255 - bgr[0];  // 改写每一个像素值
                img.at(row, col)[1] = 255 - bgr[1];
                img.at(row, col)[2] = 255 - bgr[2];
            }
        }
    }
    */

    // 修改到指针版本
    for(int row = 0; row < h; row++){
        uchar* current_row = img.ptr(row);
        for(int col = 0; col < w; col++){
            // 灰度图
            if(channel == 1){
                int pv = *current_row;
                *current_row++ = 255 - pv;  // ++ 就是向下取值
            }
            // 彩色图
            if(channel == 3){
                *current_row++ = 255 - *current_row;  // 修改像素值
                *current_row++ = 255 - *current_row;
                *current_row++ = 255 - *current_row;
            }
        }
    }
    

    imshow("img", img);
    waitKey(0); 
}

void opMat(string image_filepath){
    Mat img = imread(image_filepath);
    // imshow("img", img);

    // 创建
    Mat m1, m2, m3, m4;
    m1 = img.clone();  // 深拷贝
    img.copyTo(m2);  // 深拷贝
    m3 = Mat::zeros(Size(128, 128), CV_8UC3);  // 创建空白的数据， CV_8UC1 8位的无符号字符 3通道
    // ones的时候，如果有3通道，他只会给一通道赋值1
    // m3 = 127;  // 这个也是只会给1通道赋值127，其他两个都是0
    m3 = Scalar(121, 121, 121);  // 这样才会给3通道全部赋值
    // cout << m3 << endl;  // 直接输出二维矩阵
    // imshow("image", m3);

    int col = m3.cols;  // 列=列*通道（因为三通道的时候，连续的三个数据表示一个像素点）
    int row = m3.rows;  // 行 
    int channel = m3.channels();  // 通道
    // cout << "col: " << col << ", row: " << row << ", channel: " << channel << endl;

    // 浅拷贝
    m4 = m3;
    m4 = Scalar(0, 255, 255);
    // imshow("image", m3);


    waitKey(0); 

}

void opColorTrans(string image_filepath){

    Mat img = imread(image_filepath);
    // img： B（0～255），G（0～255），R（0～255）, 

    Mat gray, hsv;

    cvtColor(img, hsv, COLOR_BGR2HSV);
    // hsv: H（0～180），S（0～255，饱和度），V（0～255） ， HS用于表示color，V用于表示亮度
    cvtColor(img, gray, COLOR_BGR2GRAY);

    // imshow可视化的内容一定要是8位的
    imshow("img", img);
    imshow("hsv", hsv);
    imshow("gray", gray);
    waitKey(0); 
}