OpenCv Mat -类成员函数

女爷i 2022-09-01 07:54 356阅读 0赞

先从最简单的学起来

# 1.mat.cols() #

mat 矩阵的列数，和矩阵的通道数无关

new Mat(10,20,CvType.CV\_8UC2)      mat.cols==20

# 2.mat.rows() #

mat 矩阵的行数 和矩阵的通道数据无关

new Mat(10,20,CvType.CV\_8UC2)      mat.rows==10

# 3.mat.channels() #

mat 矩阵的通道数，常用的是1，2，3，4

灰度图 单通道

RGB   3通道

new Mat(10,20,CvType.CV\_8UC2)      mat.channels()==2

# 4.mat.depth() #

mat 矩阵的深度 和一开始定义mat的时候指定的类型有关系，深度的值为 0-8  深度值是描述一个图片在一个像素点的精度，当然精度越大，图片越清晰

CV_8U = 0,
                CV_8S = 1,
                CV_16U = 2,
                CV_16S = 3,
                CV_32S = 4,
                CV_32F = 5,
                CV_64F = 6,
                CV_16F = 7;

new Mat(10,20,CvType.CV\_8UC2)      mat.depth()==0

# 5.mat.elemSize()  #

在Java中：Byte.SIZE，Double.SIZE  对应的单位是bit    一个字节等于8个bit

mat.elemSize  矩阵中每个元素（这个地方的元素是一个数组，int\[\],double\[\]  通道数是数组的长度）的大小 单位字节

new Mat(10,20,CvType.CV\_8UC2) 对于这个mat  CV\_8U ====>8U 是8位 无符号整数，取值范围位 0-255  是一个通道中的元素所占字节    mat.elemSize =8bit \*  channels\_num =Byte.SIZE/8 \* 2=2 byte

new Mat(10,20,CvType.CV\_32FC2) 对于这个mat CV\_32F====>标识每个通道的中元素所占字bit （比特）位32位 就是 32/8=4个字节 因为有两个通道所以mat.elemSize()=4\*2=8

# 6.mat.elemSize1()  #

矩阵中每个通道元素所占大小，单位字节

这个函数和mat.elemSize() 很类似，但是确实有区别的，如果是单通道的矩阵，两者的值是相等的，但是对于多通道的mat.elemSize1()\*channels=mat.elemSize()

# 7.mat.clone() #

矩阵克隆，获取到一个新的矩阵

mat ：Mat \[ 20\*20\*CV\_8UC2, isCont=true, isSubmat=false, nativeObj=0xeb7b10, dataAddr=0x1d48c180 \]

mat2=mat.clone();

ma2:Mat \[ 20\*20\*CV\_8UC2, isCont=true, isSubmat=false, nativeObj=0xeb8650, dataAddr=0x1d48c540 \]

克隆之后两个矩阵没有关联

# 8.mat.copyTo(mat2) #

Mat mat2=new Mat();
    	mat.copyTo(mat2);

copyTo 之后的两个矩阵只是元素像相同，也是对应不同的矩阵

mat：Mat \[ 20\*20\*CV\_8UC2, isCont=true, isSubmat=false, nativeObj=0xdba600, dataAddr=0x1d37c180 \]

mat2：Mat \[ 20\*20\*CV\_8UC2, isCont=true, isSubmat=false, nativeObj=0xdba740, dataAddr=0x1d37c540 \]

复制之后的两个矩阵也是毫无关联

# 8.1  mat.copyTo(mat2,mask) #

mat2 结果矩阵

mask 标识的是掩膜  作用是对mat 进行与非计算，最终得到mat2

Mat mat = new Mat(10, 10, CvType.CV_8UC1) {
    			{
    				put(0, 0, 1, 12, 13, 14, 15, 16, 17, 18, 19, 10);
    				put(1, 0, 21, 22, 23, 24, 25, 26, 27, 28, 29, 20);
    				put(2, 0, 31, 32, 33, 34, 35, 36, 37, 38, 39, 30);
    				put(3, 0, 41, 42, 43, 44, 45, 46, 47, 48, 49, 40);
    				put(4, 0, 51, 52, 53, 54, 55, 56, 57, 58, 59, 50);
    				put(5, 0, 61, 62, 63, 64, 65, 66, 67, 68, 69, 60);
    				put(6, 0, 71, 72, 73, 74, 75, 76, 77, 78, 79, 70);
    				put(7, 0, 81, 82, 83, 84, 85, 86, 87, 88, 89, 80);
    				put(8, 0, 91, 92, 93, 94, 95, 96, 97, 98, 99, 90);
    				put(9, 0, 01, 02, 03, 04, 05, 06, 07, 8, 9,   0);
    			}
    		};
    	    System.out.println(mat.dump());
    	    Mat mask=new Mat(mat.size(),CvType.CV_8UC1,new Scalar(1));
    	    mask.submat(new Rect(0,0,4,8)).setTo(new Scalar(0));
    	    System.out.println(mask.dump());
    	    Mat dst=new Mat();
    	    mat.copyTo(dst, mask);
    	    System.out.println(dst.dump());

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70][]

# 9.mat.submat(Rect rect) #

rect  是一个矩形，new Rect(x,y,width,height)

其中x,y 位截取的开始坐标，width 截取的宽度，height 截取的高度

比如：

Rect rect=new Rect();
    	    rect.set(new double[]{0,1,4,5});
    	    Mat submat=mat.submat(rect);

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 1][]

#  10.mat.col(col\_index) #

获取到第col\_index 列，从 0开始

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 2][]

# 11.mat.row(row\_index)  #

获取到矩阵的第 row\_index 行

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 3][]

# 12. mat.colRange(range) #

获取到range范围的行

public class Range {
    
        public int start, end;
    
        public Range(int s, int e) {
            this.start = s;
            this.end = e;
        }
    
        public Range() {
            this(0, 0);
        }
    
        public Range(double[] vals) {
            set(vals);
        }
    
        public void set(double[] vals) {
            if (vals != null) {
                start = vals.length > 0 ? (int) vals[0] : 0;
                end = vals.length > 1 ? (int) vals[1] : 0;
            } else {
                start = 0;
                end = 0;
            }
    
        }
    }

range 有一个起始，一个结束。可以通过构造函数初始化，也可以通过set函数进行初始化

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 4][]

# 13.mat.rowRange(range) #

类似 mat.colRange(range) 截取range范围的行获取到新矩阵

# 14.mat.convertTo(dst, cvType); #

实现的功能是不同类型之间矩阵的转换

Mat mat = new Mat(10, 10, CvType.CV_8UC1) {
    			{
    				put(0, 0, 1, 12, 13, 14, 15, 16, 17, 18, 19, 10);
    				put(1, 0, 21, 22, 23, 24, 25, 26, 27, 28, 29, 20);
    				put(2, 0, 31, 32, 33, 34, 35, 36, 37, 38, 39, 30);
    				put(3, 0, 41, 42, 43, 44, 45, 46, 47, 48, 49, 40);
    				put(4, 0, 51, 52, 53, 54, 55, 56, 57, 58, 59, 50);
    				put(5, 0, 61, 62, 63, 64, 65, 66, 67, 68, 69, 60);
    				put(6, 0, 71, 72, 73, 74, 75, 76, 77, 78, 79, 70);
    				put(7, 0, 81, 82, 83, 84, 85, 86, 87, 88, 89, 80);
    				put(8, 0, 91, 92, 93, 94, 95, 96, 97, 98, 99, 90);
    				put(9, 0, 01, 02, 03, 04, 05, 06, 07, 8, 9, 0,11);
    			}
    		};
    		Mat dst=new Mat();
    	    mat.convertTo(dst, CvType.CV_16F);

# 15. Mat.convertTo(Mat m, int rtype, double alpha) #

alpha 标识放大倍数

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 5][]

对应的元素扩大 alpha 倍

# 16.Mat.convertTo(Mat m, int rtype, double alpha, double beta) #

矩阵放大alpha 倍之后，每个元素加上beta 获取到新的矩阵

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 6][]

# 17.mat.empty() #

判断矩阵是否元素为空

Mat mat = new Mat(10, 10, CvType.CV_8UC1) {
    			{
    				put(0, 0, 1, 12, 13, 14, 15, 16, 17, 18, 19, 10);
    				put(1, 0, 21, 22, 23, 24, 25, 26, 27, 28, 29, 20);
    				put(2, 0, 31, 32, 33, 34, 35, 36, 37, 38, 39, 30);
    				put(3, 0, 41, 42, 43, 44, 45, 46, 47, 48, 49, 40);
    				put(4, 0, 51, 52, 53, 54, 55, 56, 57, 58, 59, 50);
    				put(5, 0, 61, 62, 63, 64, 65, 66, 67, 68, 69, 60);
    				put(6, 0, 71, 72, 73, 74, 75, 76, 77, 78, 79, 70);
    				put(7, 0, 81, 82, 83, 84, 85, 86, 87, 88, 89, 80);
    				put(8, 0, 91, 92, 93, 94, 95, 96, 97, 98, 99, 90);
    				put(9, 0, 01, 02, 03, 04, 05, 06, 07, 8, 9,   0);
    			}
    		};
    	    System.out.println(mat.empty());   //  false
    	    Mat dst=new Mat();
    	    System.out.println(dst.empty());   //true

# 18.mat.CheckVector() #

检查mat 是否为向量

之前写过一个专门介绍的博客： [https://blog.csdn.net/datouniao1/article/details/119027662][https_blog.csdn.net_datouniao1_article_details_119027662]

# 19.mat.diag() #

diag 函数用于构造一个对角矩阵，以向量的形式返回对角线上的元素

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 7][]

#  20  mat.diag(int a) #

构建一个对角矩阵，按照向量的形式返回主对角线 右上方偏移 a 或者左下方偏移 -a 位置的矩阵

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 8][]

# 21. mat.diag(diagVector)   ||  Mat.diag(diagVector) #

diagVector 是一个向量  ，什么是向量  1\*N 或者N\*1的矩阵，所以在创建diagVector的时候，矩阵的行数或者是列数要有一个为1的

diag(diagVector) 是构建一个N\*N 对角方阵 不是对角线上的元素全部为0

Mat diagVector = new Mat(1, 11, CvType.CV_8UC1, new Scalar(2));
    System.out.println(diagVector.dump());
    System.out.println(mat.diag(diagVector).dump());

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 9][]

该矩阵也可以通过这种方式来获取：

Mat diagVector = new Mat(1, 11, CvType.CV_8UC1, new Scalar(2));
    	    Mat diag=Mat.diag(diagVector);

#  22. mat1.dot(mat2) #

两个矩阵做点乘运算

![\\begin\{pmatrix\} a\_\{11\} & a\_\{12\} \\\\ a\_\{21\}& a\_\{22\} \\end\{pmatrix\}\\cdot][begin_pmatrix_ a_11_ _ a_12_ _ a_21_ a_22_ _end_pmatrix_cdot]   ![\\begin\{pmatrix\} b\_\{11\} &b\_\{12\} \\\\ b\_\{21\} & b\_\{22\} \\end\{pmatrix\}=a\_\{11\}b\_\{11\}+a\_\{12\}b\_\{12\}+a\_\{21\}b\_\{21\}+a\_\{22\}b\_\{22\}][begin_pmatrix_ b_11_ _b_12_ _ b_21_ _ b_22_ _end_pmatrix_a_11_b_11_a_12_b_12_a_21_b_21_a_22_b_22]

那么我们用最为简单的矩阵，二维矩阵来看一下mat1.dot(mat2)

Mat mat1 = new Mat(2, 2, CvType.CV_8UC1) {
    			{
    				put(0, 0, 1, 2);
    				put(1, 0, 2, 3);
    	
    			}
    		};
    		Mat mat2 = new Mat(2, 2, CvType.CV_8UC1) {
    			{
    				put(0, 0, 2, 1);
    				put(1, 0, 3, 4);
    	
    			}
    		};
    		double result=mat1.dot(mat2);  //1*2+2*1+2*3+3*4=22

#  23.Mat.eye() #

获取到一个单位矩阵:在[矩阵][Link 1]的乘法中，有一种矩阵起着特殊的作用，如同数的乘法中的1，这种矩阵被称为单位矩阵。它是个[方阵][Link 2]，从左上角到右下角的[对角线][Link 3]（称为[主对角线][Link 4]）上的元素均为1。除此以外全都为0。

Mat eye = Mat.eye(3, 3, CvType.CV_32FC1);

![\\begin\{pmatrix\} 1 & 0 & 0\\\\ 0 & 1 &0 \\\\ 0& 0& 1 \\end\{pmatrix\}][begin_pmatrix_ 1 _ 0 _ 0_ 0 _ 1 _0 _ 0_ 0_ 1 _end_pmatrix]

# 24.mat.inv() #

求解mat 的逆矩阵 在opencv4.5中这个函数有点问题（单位矩阵求解逆矩阵可以，但是普通的矩阵会报错）

我们来复习一下逆矩阵

假设： A  的逆矩阵 为B   则：AB=BA=E

逆矩阵的求法一般为 1.求解伴随矩阵 2.对元矩阵进行初等变换

单位矩阵的逆矩阵还是它本身

# 25.Mat.zeros() #

零矩阵

Mat dst = Mat.zeros(new Size(2, 2), CvType.CV\_16S);

![\\begin\{pmatrix\} 0 &0 \\\\ 0 & 0 \\end\{pmatrix\}][begin_pmatrix_ 0 _0 _ 0 _ 0 _end_pmatrix]

.......

为什么那么多方法啊

还有很多

先不写了，以后再说

希望对你有所帮助！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70]: /images/20220829/5d6d3e5f7c014245a2f2880187a560d5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 1]: /images/20220829/56a60567cb8447b592483cd255175f6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 2]: /images/20220829/e2f32825d16949c1917215e5dd34e4ad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 3]: /images/20220829/0aa555aed00f4dda80b428b029d14bdf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 4]: /images/20220829/41c18200a93141b392c83087d4fd9829.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 5]: /images/20220829/8fb2d27f487b44628a9383b207b372f3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 6]: /images/20220829/585d5d8010664ccd926cd3ab6e2d8c5f.png
[https_blog.csdn.net_datouniao1_article_details_119027662]: https://blog.csdn.net/datouniao1/article/details/119027662
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 7]: /images/20220829/6dfaab00bbaa4a8aaf28d1e6fca400b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 8]: /images/20220829/f170a8b987324a7c88e42df4615bf777.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RhdG91bmlhbzE_size_16_color_FFFFFF_t_70 9]: /images/20220829/4a756a7ceaa5439481229b835c06a38d.png
[begin_pmatrix_ a_11_ _ a_12_ _ a_21_ a_22_ _end_pmatrix_cdot]: https://latex.codecogs.com/gif.latex?%5Cbegin%7Bpmatrix%7D%20a_%7B11%7D%20%26%20a_%7B12%7D%20%5C%5C%20a_%7B21%7D%26%20a_%7B22%7D%20%5Cend%7Bpmatrix%7D%5Ccdot
[begin_pmatrix_ b_11_ _b_12_ _ b_21_ _ b_22_ _end_pmatrix_a_11_b_11_a_12_b_12_a_21_b_21_a_22_b_22]: https://latex.codecogs.com/gif.latex?%5Cbegin%7Bpmatrix%7D%20b_%7B11%7D%20%26b_%7B12%7D%20%5C%5C%20b_%7B21%7D%20%26%20b_%7B22%7D%20%5Cend%7Bpmatrix%7D%3Da_%7B11%7Db_%7B11%7D&plus;a_%7B12%7Db_%7B12%7D&plus;a_%7B21%7Db_%7B21%7D&plus;a_%7B22%7Db_%7B22%7D
[Link 1]: https://baike.baidu.com/item/%E7%9F%A9%E9%98%B5/18069
[Link 2]: https://baike.baidu.com/item/%E6%96%B9%E9%98%B5/7362108
[Link 3]: https://baike.baidu.com/item/%E5%AF%B9%E8%A7%92%E7%BA%BF/9706033
[Link 4]: https://baike.baidu.com/item/%E4%B8%BB%E5%AF%B9%E8%A7%92%E7%BA%BF/4269887
[begin_pmatrix_ 1 _ 0 _ 0_ 0 _ 1 _0 _ 0_ 0_ 1 _end_pmatrix]: https://latex.codecogs.com/gif.latex?%5Cbegin%7Bpmatrix%7D%201%20%26%200%20%26%200%5C%5C%200%20%26%201%20%260%20%5C%5C%200%26%200%26%201%20%5Cend%7Bpmatrix%7D
[begin_pmatrix_ 0 _0 _ 0 _ 0 _end_pmatrix]: https://latex.codecogs.com/gif.latex?%5Cbegin%7Bpmatrix%7D%200%20%260%20%5C%5C%200%20%26%200%20%5Cend%7Bpmatrix%7D