OpenCV（二）：认识Mat容器

绝地灬酷狼 2024-03-24 22:50 49阅读 0赞

**目录**

1.什么是Mat类

2.Mat类能存储的数据

整数类型（有符号和无符号）：

浮点数类型：

布尔类型：

3.Mat类的创建

1.利用矩阵宽、高和类型参数创建Mat类

2.利用矩陈Size(结构和数据类型参数创建Mat类

3.利用已有Mat类创建新的Mat类

4.Mat类的赋值

1.创建时赋值

2.类方法赋值

3.枚举法赋值

5. Android jni demo

--------------------

#### 1.什么是Mat类 ####

Mat类是OpenCV中的一个类，用于存储矩阵数据的类型，与int、double等相同。

![e6f550148cd54c9cb349d7c526ad6b60.png][]

#### 2.Mat类能存储的数据 ####

Mat类可以存储各种类型的数据，包括但不限于以下几种常见的数据类型：

1.  ###### 整数类型（有符号和无符号）： ######
    
     *  CV\_8U：8位无符号整数（范围从0到255）
     *  CV\_8S：8位有符号整数（范围从-128到127）
     *  CV\_16U：16位无符号整数（范围从0到65535）
     *  CV\_16S：16位有符号整数（范围从-32768到32767）
     *  CV\_32S：32位有符号整数
     *  CV\_64S：64位有符号整数
2.  ###### 浮点数类型： ######
    
     *  CV\_32F：32位浮点数（单精度浮点数）
     *  CV\_64F：64位浮点数（双精度浮点数）
3.  ###### 布尔类型： ######
    
     *  CV\_8UC1：8位无符号整数，表示二值图像（黑白图像）
     *  CV\_8UC3：8位无符号整数，表示彩色图像（三通道RGB图像）

#### 3.Mat类的创建 ####

###### 1.利用矩阵宽、高和类型参数创建Mat类 ######

> cv::Mat mat( int rows,int cols,int type）

*  构造矩阵的行数rows:
 *  cols:矩阵的列数
 *  type: 矩阵中存储的数据类型。此处除了CV 8UC1、CV 64FC4等从1到4通道以外，还提供了更多通道的参数，通过CV 8UC(n)中的n来构建多通道矩阵，其中n最大可以取到512。

###### 2.利用矩陈Size(结构和数据类型参数创建Mat类 ######

> cv::Mat mat( Size size,int type）

*  size: 2D数组变量尺寸，通过Size(cols,rows)进行赋值
 *  type:与前面一致

###### 3.利用已有Mat类创建新的Mat类 ######

> cv::Mat mat( const Mat &m,
> 
> const Range & rowRange,
> 
> const Range & colRange = Range: :al1()
> 
> ）

*  m:已经构建完成的Mat类矩阵数据。
 *  rowRange:在已有矩阵中需要截取的行数范围，是个Range变量，例如从第2行到第5行可以表示为Range(2,5)。
 *  colRange: 在已有矩阵中需要截取的列数范围，是一个Range变量，例如从第2列到第5列可以表示为
 *  Range(2,5)，当不输入任何值时表示所有列都会被截取。

#### 4.Mat类的赋值 ####

###### 1.创建时赋值 ######

> cv::Mat mat( int rows,
> 
> int cols,
> 
> int type,
> 
> const Scalar & s
> 
> ）

*  矩阵的行数rows:
 *  矩阵的列数cols:
 *  type:存储数据的类型
 *  s:给矩阵中每个像素赋值的参数变量，例如Scalar(0,0,255)。

###### 2.类方法赋值 ######

*  eye:单位矩阵
 *  diag:对角矩阵
 *  元素全为1的矩阵ones:
 *  zeros:元素全为0的矩阵

###### 3.枚举法赋值 ######

> cv::Mat a(Mat\_<int>(3，3)<<1,2, 3, 4, 5, 6, 7,8, 9);
> 
> cv::Mat b = (Mat\_<double>(2, 3) << 1.0, 2.1, 3.2, 4.0, 5.1, 6.2);

#### 5. Android jni demo ####

#include <jni.h>
    #include <string>
    #include <android/bitmap.h>
    #include <opencv2/opencv.hpp>
    #include <iostream>
    #include <android/log.h>
    #define LOG_TAG "xxx"
    #define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
    #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
    #define LOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
    #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
    
    using namespace cv;
    using namespace std;
    
    extern "C"
    JNIEXPORT void JNICALL
    Java_com_example_myapplication_MainActivity_test(JNIEnv *env, jclass clazz) {
       Mat a(3,3,CV_8UC1);
       Mat b(Size(3,3),CV_8UC1);
       Mat c0(5,5,CV_8UC1,Scalar(4,5,6));
        Mat c1(5,5,CV_8UC2,Scalar(4,5,6));
        Mat c2(5,5,CV_8UC3,Scalar(4,5,6));
        Mat d = (Mat_<int>(1, 5) << 1, 2, 3, 4, 5);
        Mat e=Mat::diag(d);//类方法赋值，对角矩阵
        Mat f=Mat(e,Range(2,4),Range(2,4));
    
        ostringstream ss;
        ss << "c0 data:" << std::endl;
        // 遍历并输出像素值
        for (int i = 0; i < c0.rows; i++) {
    
            for (int j = 0; j < c0.cols*c0.channels(); j++) {
                // 获取像素值
                uchar value = c0.at<uchar>(i, j);
                // 构建输出字符串
                ss << static_cast<int>(value) << " ";
            }
            ss << std::endl;
        }
        ss << "c1 data:" << std::endl;
        // 遍历并输出像素值
        for (int i = 0; i < c1.rows; i++) {
    
            for (int j = 0; j < c1.cols*c1.channels(); j++) {
                // 获取像素值
                uchar value = c1.at<uchar>(i, j);
                // 构建输出字符串
                ss << static_cast<int>(value) << " ";
            }
            ss << std::endl;
        }
        ss << "c2 data:" << std::endl;
        // 遍历并输出像素值
        for (int i = 0; i < c2.rows; i++) {
    
            for (int j = 0; j < c2.cols*c2.channels(); j++) {
                // 获取像素值
                uchar value = c2.at<uchar>(i, j);
                // 构建输出字符串
                ss << static_cast<int>(value) << " ";
            }
            ss << std::endl;
        }
        ss << "d data:" << std::endl;
        // 遍历并输出像素值
        for (int i = 0; i < d.rows; i++) {
    
            for (int j = 0; j < d.cols; j++) {
                // 获取像素值
                int value = d.at<int>(i, j);
                // 构建输出字符串
                ss <<value << " ";
            }
            ss << std::endl;
        }
        ss << "e data:" << std::endl;
        // 遍历并输出像素值
        for (int i = 0; i < e.rows; i++) {
    
            for (int j = 0; j < e.cols*e.channels(); j++) {
                // 获取像素值
                int value = e.at<int>(i, j);
                // 构建输出字符串
                ss << value << " ";
            }
            ss << std::endl;
        }
        ss << "f data:" << std::endl;
        // 遍历并输出像素值
        for (int i = 0; i < f.rows; i++) {
    
            for (int j = 0; j < f.cols*f.channels(); j++) {
                // 获取像素值
               int value = f.at<int>(i, j);
                // 构建输出字符串
                ss <<value << " ";
            }
            ss << std::endl;
        }
        // 使用LOG输出到Logcat
        LOGD("%s", ss.str().c_str());
    
    
    
    }

输出结果：

![25167ab32eb24491afa9b0d6232775c7.png][]

[e6f550148cd54c9cb349d7c526ad6b60.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/6812251eef4a42cdb73bb0b700ffb39b.png
[25167ab32eb24491afa9b0d6232775c7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/08cee2ea22e3445482a3a0decca7f42a.png