图像处理雅克比矩阵

2018-10-23 00:50:01 qq_22128781 阅读数 1259
  • (二)矩阵基本运算

    本课程由专业数学系老师讲解,从数学背景和现实应用中讲解线性代数的相关知识,摆脱传统...使听众能够了解矩阵和空间的概念、性质。深刻理解矩阵各类运算、分解的数学意义和应用,为后续的机器学习打下扎实的数学基础。

    825人学习 AI100讲师
    免费试看

标签: 三维图像 海森矩阵 二阶偏导数 高斯函数


海森矩阵(Hessian matrix)


雅可比矩阵

在向量分析中,雅可比矩阵是一阶偏导数以一定方式排列成的矩阵, 其行列式称为雅可比行列式。

海森矩阵

数学中,海森矩阵(Hessian matrix)是一个自变量为向量的实值函数的二阶偏导数组成的方块矩阵(假设其二阶偏导都存在)。
H(f)=[2fx122fx1x22fx1xn2fx2x12fx222fx2xn2fxnx12fxnx22fxn2] H(f)=\left[ \begin{matrix} \frac{\partial^2 f}{\partial x^2_1} & \frac{\partial^2 f}{\partial x_1x_2} & \cdots & \frac{\partial^2 f}{\partial x_1x_n} \\ \frac{\partial^2 f}{\partial x_2x_1} & \frac{\partial^2 f}{\partial x^2_2} & \cdots & \frac{\partial^2 f}{\partial x_2x_n} \\ \vdots & \vdots & \ddots & \vdots \\ \frac{\partial^2 f}{\partial x_nx_1} & \frac{\partial^2 f}{\partial x_n x_2} & \cdots & \frac{\partial^2 f}{\partial x^2_n} \\ \end{matrix} \right]


高斯求导


前言

通过上述公式可知,求海森矩阵的过程实际上就是求二阶偏导的过程。卷积中有一个重要的性质:卷积的微分特性—两个函数相卷积后的导数等于其中一个函数的导数与另一个函数的卷积
ddt[f1(t)f2(t)]=df1(t)dtf2(t)=f1(t)df2(t)dt\frac{d}{dt}[f_1(t)* f_2(t)]=\frac{df_1(t)}{dt}* f_2(t)= f_1(t)*\frac{df_2(t)}{dt}
证明如下:
ddt[f1(t)f2(t)]=ddtf1(τ)f2(tτ)dτ=f1(τ)ddtf2(tτ)dτ=f1(t)df2(t)dt\frac{d}{dt}[f_1(t)* f_2(t)]=\frac{d}{dt}\int ^{\infty}_{-\infty} f_1(\tau)* f_2(t-\tau)d\tau = \int ^{\infty}_{-\infty} f_1(\tau)* \frac{d}{dt}f_2(t-\tau)d\tau =f_1(t)*\frac{df_2(t)}{dt}
同理可证:
ddt[f1(t)f2(t)]=ddtf1(τ)f2(tτ)dτ=ddtf1(τ)f2(tτ)dτ=df1(t)dtf2(t)\frac{d}{dt}[f_1(t)* f_2(t)]=\frac{d}{dt}\int ^{\infty}_{-\infty} f_1(\tau)* f_2(t-\tau)d\tau = \int ^{\infty}_{-\infty} \frac{d}{dt}f_1(\tau)* f_2(t-\tau)d\tau =\frac{df_1(t)}{dt}*f_2(t)
故上述微分特性得证。
推广易得:
2t2[f1(t)f2(t)]=2f1(t)t2f2(t)=f1(t)2f2(t)t2\frac{\partial^2}{\partial t^2}[f_1(t)* f_2(t)]=\frac{\partial^2f_1(t)}{\partial t^2}* f_2(t) = f_1(t)*\frac{\partial^2f_2(t)}{\partial t^2}

推导

根据上式,令f1(t)f_1(t)为高斯函数G(x,y,z)=(12πσ)3ex2+y2+z22σ2G(x,y,z)=(\frac{1}{\sqrt{2\pi}\sigma})^3e^{-\frac{x^2+y^2+z^2}{2\sigma^2}}f2(t)f_2(t)为三维图片I(x,y,z)I(x,y,z),则有:
2x2[G(x,y,z)I(x,y,z)]=2G(x,y,z)x2I(x,y,z)=G(x,y,z)2I(x,y,z)x2\frac{\partial^2}{\partial x^2}[G(x,y,z)* I(x,y,z)]=\frac{\partial^2G(x,y,z)}{\partial x^2}* I(x,y,z) = G(x,y,z)*\frac{\partial^2I(x,y,z)}{\partial x^2}
可知,只要求得了2G(x,y,z)x2\frac{\partial^2G(x,y,z)}{\partial x^2},那么通过上式就可以得到2I(x,y,z)x2\frac{\partial^2I(x,y,z)}{\partial x^2}为图像II(x,y,z)(x,y,z)点的对xx的二阶偏导。其他方向的二阶偏导同理可求。
到这里,求图像的二阶偏导转换成了求高斯函数的二阶偏导。


跳过。。跳过。。一系列的求导过程((٩(//̀Д/́/)۶))


得到以下高斯函数的二阶偏导:
2G(x,y,z)x2=1(2πσ)3x2σ2σ4ex2+y2+z22σ2=x2σ2(2π)3σ7ex2+y2+z22σ2\frac{\partial^2G(x,y,z)}{\partial x^2}=\frac{1}{(\sqrt{2\pi}\sigma)^3}\frac{x^2-\sigma^2}{\sigma^4}e^{-\frac{x^2+y^2+z^2}{2\sigma^2}}=\frac{x^2-\sigma^2}{(\sqrt{2\pi})^3\sigma^7}e^{-\frac{x^2+y^2+z^2}{2\sigma^2}}
2G(x,y,z)xy=1(2πσ)3xyσ4ex2+y2+z22σ2=xy(2π)3σ7ex2+y2+z22σ2\frac{\partial^2G(x,y,z)}{\partial x\partial y}=\frac{1}{(\sqrt{2\pi}\sigma)^3}\frac{xy}{\sigma^4}e^{-\frac{x^2+y^2+z^2}{2\sigma^2}}=\frac{xy}{(\sqrt{2\pi})^3\sigma^7}e^{-\frac{x^2+y^2+z^2}{2\sigma^2}}
同理易得高斯函数G(x,y,z)G(x,y,z)y2,z2,yx,xz,zx,yz,zyy^2,z^2,yx,xz,zx,yz,zy等方向的偏导。
可以发现:
2G(x,y,z)xy=2G(x,y,z)yx\frac{\partial^2G(x,y,z)}{\partial x\partial y}=\frac{\partial^2G(x,y,z)}{\partial y\partial x}
2G(x,y,z)xz=2G(x,y,z)zx\frac{\partial^2G(x,y,z)}{\partial x\partial z}=\frac{\partial^2G(x,y,z)}{\partial z\partial x}
2G(x,y,z)yz=2G(x,y,z)zy\frac{\partial^2G(x,y,z)}{\partial y\partial z}=\frac{\partial^2G(x,y,z)}{\partial z\partial y}
至此,高斯函数所有的二阶偏导已经求得,然后利用matlab中的convn函数进行三维空间内的卷积(参数选择same保证结果和图像一致),这也意味着黑森矩阵已经可以通过上述过程得到。

代码实现

%%  求高斯函数的二阶偏导数
%%  num为高斯核的大小
%%  sigma为高斯函数的方差
function [gau_xx,gau_yy,gau_zz,gau_xy,gau_xz,gau_yz]=gaus_creation_3D(num,sigma)

gau_xx=[];gau_yy=[];gau_zz=[];%初始化矩阵

gau_xy=[];gau_xz=[];gau_yz=[];%初始化矩阵

for i=1:1:2*num+1
    for j=1:1:2*num+1
        for k=1:1:2*num+1
            
            x=i-num-1;y=j-num-1;z=k-num-1;
            
            gau_xx(i,j,k)=1/power(sqrt(2*pi),3)*(-(sigma^2-x^2)/sigma^7)*exp(-(x^2+y^2+z^2)/2/sigma^2);
            gau_yy(i,j,k)=1/power(sqrt(2*pi),3)*(-(sigma^2-y^2)/sigma^7)*exp(-(x^2+y^2+z^2)/2/sigma^2);
            gau_zz(i,j,k)=1/power(sqrt(2*pi),3)*(-(sigma^2-z^2)/sigma^7)*exp(-(x^2+y^2+z^2)/2/sigma^2);
            
            gau_xy(i,j,k)=1/power(sqrt(2*pi),3)*(x*y/sigma^7)*exp(-(x^2+y^2+z^2)/2/sigma^2);
            gau_xz(i,j,k)=1/power(sqrt(2*pi),3)*(x*z/sigma^7)*exp(-(x^2+y^2+z^2)/2/sigma^2);
            gau_yz(i,j,k)=1/power(sqrt(2*pi),3)*(z*y/sigma^7)*exp(-(x^2+y^2+z^2)/2/sigma^2);
        end
    end
end
end

思考

关于最终的结果

2x2[G(x,y,z)I(x,y,z)]=2G(x,y,z)x2I(x,y,z)=G(x,y,z)2I(x,y,z)x2\frac{\partial^2}{\partial x^2}[G(x,y,z)* I(x,y,z)]=\frac{\partial^2G(x,y,z)}{\partial x^2}* I(x,y,z) = G(x,y,z)*\frac{\partial^2I(x,y,z)}{\partial x^2}式中可知最后的结果其实是图像的二阶偏导和高斯函数的卷积,并不只是单纯的图像二阶偏导。高斯函数在图像处理中常用于去除高斯噪声,它具有良好的低通滤波效果,一般在检测边缘之前常用高斯卷积来移除图像一些细节以及噪声。所以事实上,这里的卷积不会影响图像整体的结构,而且一定程度上对图像进行了去噪使图像质量更好(当然不可否认的是损失了一些图像细节),如果是利用海森矩阵进行三维图像的线性结构或是面结构的检测,那么一定程度的去噪以及平滑处理将可能得到更好的结果。


以上。(づ●─●)づ

2017-04-09 14:10:31 qq_33854260 阅读数 3641
  • (二)矩阵基本运算

    本课程由专业数学系老师讲解,从数学背景和现实应用中讲解线性代数的相关知识,摆脱传统...使听众能够了解矩阵和空间的概念、性质。深刻理解矩阵各类运算、分解的数学意义和应用,为后续的机器学习打下扎实的数学基础。

    825人学习 AI100讲师
    免费试看

一般来说, 牛顿法主要应用在两个方面, 

        1, 求方程的根; 2, 最优化。

1,求方程的根

其原理便是使用泰勒展开,然后去线性部分,即:

                (1)

然后令上式等于0,则有:

                                (2)

经过不断迭代:

                             (3)

当精度达到要求的时候停止迭代。

迭代示意图如上所示。


2,最优化

最优化一般是求极大或极小问题,这可以转变为求导数零点,然后转变为求方程的根的情形。

即f' = 0;

把f(x)用泰勒公式展开到二阶,即:

                                          (4)

等号左边和f(x)近似相等,抵消。然后对求导,得到:

                                                                           (5)

更进一步:

                                                                                (6)

然后得到迭代式子:

                                                            (7)

以上只针对单变量进行讨论,如果对多变量就要引入雅克比矩阵和海森矩阵

简单介绍一下二者,雅克比矩阵为函数对各自变量的一阶导数,海森矩阵为函数对自变量的二次微分。形式分别如下:



把两个矩阵代入(7)中


参考文献:

Newton's method -- wikipedia

Jacobian矩阵和Hessian矩阵

2019-04-22 15:10:38 baidu_41931307 阅读数 860
  • (二)矩阵基本运算

    本课程由专业数学系老师讲解,从数学背景和现实应用中讲解线性代数的相关知识,摆脱传统...使听众能够了解矩阵和空间的概念、性质。深刻理解矩阵各类运算、分解的数学意义和应用,为后续的机器学习打下扎实的数学基础。

    825人学习 AI100讲师
    免费试看

在这里插入图片描述

2016-03-24 09:36:18 Wonder233 阅读数 334
  • (二)矩阵基本运算

    本课程由专业数学系老师讲解,从数学背景和现实应用中讲解线性代数的相关知识,摆脱传统...使听众能够了解矩阵和空间的概念、性质。深刻理解矩阵各类运算、分解的数学意义和应用,为后续的机器学习打下扎实的数学基础。

    825人学习 AI100讲师
    免费试看

原链接:http://www.360doc.com/content/16/0324/09/31190201_544801196.shtml


有很多函数有mask,代表掩码,如果某位mask是0,那么对应的src的那一位就不计算,mask要和矩阵/ROI/的大小相等 
大多数函数支持ROI,如果图像ROI被设置,那么只处理ROI部分 
少部分函数支持COI,如果COI设置,只处理感兴趣的通道

矩阵逻辑运算 
void cvAnd(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL);// 
void cvAndS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL);// 
void cvOr(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL);// 
void cvOrS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL);// 
void cvXor(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL);// 
void cvXorS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL);// 
void cvNot(const CvArr* src,CvArr* dst);//矩阵取反

 

矩阵算术运算 
绝对值 
void cvAbs(const CvArr* src,CvArr* dst); 
void cvAbsDiff(const CvArr* src1,const CvArr* src2, CvArr* dst);//两矩阵相减取绝对值 
void cvAbsDiffS(const CvArr* src, CvArr* dst,CvScalar value);//矩阵减去一个数取绝对值 
加减 
void cvAdd(const CvArr* src1,const CvArr* src2,CvArr* dst,const CvArr* mask = NULL);//两数组相加,dst(I)=src1(I)+src2(I) if mask(I)!=0 
void cvAddS(const CvArr* src,CvScalar value,CvArr*dst,const CvArr* mask = NULL);//数组和一个数相加,dst(I)=src(I)+value if mask(I)!=0 
void cvAddWeighted(const CvArr* src1,double alpha,const CvArr* src2,double beta,double gamma,CvArradded to each sum* dst);//带权相加相当于dst(x,y) = α ? src1(x,y) + β ? src2(x,y) + γ 
void cvSub(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL);//矩阵减法,dst(I)=src1(I)-src2(I) if mask(I)!=0 
void cvSubS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL);//矩阵减数,dst(I)=src(I)-value if mask(I)!=0 
void cvSubRS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL);//数减矩阵,dst(I)=value-src(I) if mask(I)!=0 
乘除 
void cvDiv(const CvArr* src1, const CvArr* src2, CvArr* dst, double scale=1);//scale*src1(i)/src2(i),如果src1=NULL,则计算scale/src2(i) 
void cvMul(const CvArr* src1,const CvArr* src2,CvArr* dst,double scale=1);//两矩阵元素之间的简单乘法,一般的矩阵点乘用cvGEMM(); 
次方 
void cvPow(const CvArr* src, CvArr* dst, double power);//为每个src的数求power次方 
指数 
void cvExp(const CvArr* src, CvArr* dst);//dst(I)=EXP(src(I)) 
对数 
void cvLog(const CvArr* src, CvArr* dst);//

 

线性代数计算 
加&乘 
void cvScaleAdd(const CvArr* src1, CvScalar scale, const CvArr* src2, CvArr* dst);//src1和scale的乘积加上src2 
void cvCrossProduct(const CvArr* src1,const CvArr* src2,CvArr* dst);//计算两个3D向量(单通道)的叉乘运算 
double cvDotProduct(const CvArr* src1, const CvArr* src2);//两个向量点乘 
void cvGEMM(const CvArr* src1, const CvArr* src2, double alpha, const CvArr* src3, double beta, CvArr* dst, int tABC=0);//乘加运算的始祖 
    由通用乘加函数参与定义的两个具体宏 
        cvMatMul(const CvArr* src1,const CvArr* src2,CvArr* dst); 
        cvMatMulAdd(const CvArr* src1,const CvArr* src2,const CvArr* src3,CvArr* dst); 
CvScalar cvTrace(const CvArr* mat);//计算对角线上的元素和 
变换 
void cvTransform(const CvArr* src, CvArr* dst, const CvMat* transmat, const CvMat* shiftvec=NULL);//dst=transmat · src + shiftvec 
void cvPerspectiveTransform(const CvArr* src, CvArr* dst, const CvMat* mat);//把矩阵每个元素中三个通道当做一个矩阵,乘mat,mat是一个3×3或者4×4的转换矩阵 
转置 
void cvTranspose(const CvArr* src, CvArr* dst); 
void cvMulTransposed(const CvArr* src, CvArr* dst, int order, const CvArr* delta=NULL, double scale=1.0);//(src-delta)乘以它的转置再乘以scale 
逆矩阵 
double cvInvert(const CvArr* src,CvArr* dst,int method=CV_LU);//求原矩阵的逆矩阵,默认使用高斯消去法 
    方阵可逆的充要条件是|A|!=0 
    method取值为CV_LU高斯消去法(默认)    CV_SVD 奇异值分解SVD    CV_SVD_SYM对称矩阵的SVD 
行列式 
double cvDet(const CvArr* mat);//计算方阵行列式,一定是单通道的 
    小型方阵直接计算,大型方阵用高斯消去法计算 
    如果矩阵正定对称,用奇异值分解的方法解决cvSVD(); 
特征向量特征值 
void cvEigenVV(CvArr* mat, CvArr* evects, CvArr* evals, double eps=0);//计算对称矩阵的特征值和特征向量,evects输出特征向量,evals输出特征值,eps雅可比方法停止参数 
    要求三个矩阵都是浮点类型,10×10以下该方法有效,20×20以上的矩阵不能计算出结果,为节约计算量,eps通常设为DBL_EPSILON(10^-15) 
    如果给定的矩阵是对称正定矩阵,那么考虑使用cvSVD(); 
协方差 
void cvCalcCovarMatrix(const CvArr** vects, int count, CvArr* cov_mat, CvArr* avg, int flags);//给定一组大小和类型相同的向量,向量的个数,计算标记,输出协方差正阵和每个向量的平均值矩阵 
    CV_COVAR_NORMAL    普通计算协方差和平均值,输出的是n×n的协方差阵 
    CV_COVAR_SCRAMBLED    快速PCA“Scrambled”协方差,输出的是m×m的协方差阵 
    CV_COVAR_USE_AVERAGE    平均值是输入的 
    CV_COVAR_SCALE    重新缩放输出的协方差矩阵 
        四个flag通过并运算协同发挥作用,前两个不能并 
CvSize cvMahalonobis(const CvArr* vec1,const CvArr* vec2,CvArr* mat); 
int cvSolve(const CvArr* src1, const CvArr* src2, CvArr* dst, int method=CV_LU);//Solves a linear system or least-squares problem. 
void cvSVD(CvArr* A, CvArr* W, CvArr* U=NULL, CvArr* V=NULL, int flags=0);//Performs singular value decomposition of a real floating-point matrix. 
void cvSVBkSb(const CvArr* W, const CvArr* U, const CvArr* V, const CvArr* B, CvArr* X, int flags);//Performs singular value back substitution.

 

数组比较 
void cvCmp(const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op);//两矩阵比较运算 
    CV_CMP_EQ - src1(I) 是否相等 
    CV_CMP_GT - src1(I) 是否大于 
    CV_CMP_GE - src1(I) 是否大于等于 
    CV_CMP_LT - src1(I) 是否小于 
    CV_CMP_LE - src1(I) 是否小于等于 
    CV_CMP_NE - src1(I) 是否不等 
        如果判断为假,dst设为0,如果判断为真,dst设为0xff 
void cvCmpS(const CvArr* src, double value, CvArr* dst, int cmp_op);//矩阵和一个数字比较运算

 

矩阵内转换 
类型转换 
void cvConvertScale(const CvArr* src,CvArr* dst,double scale,double shift);//矩阵首先乘以scale再加上shift,然后把src中的数据类型转换成dst类型,但是src和dst通道数需要相等 
void cvConvertScaleAbs(const CvArr* src,CvArr* dst,double scale,double shift);//在src到dst类型转换前,先做绝对值 
void cvCvtColor(const CvArr* src,CvArr* dst, int code);//图像 颜色空间转换,src要为8U 16U 32F,dst的数据类型需要和src相同,通道数看code 
    code格式如:CV_原色彩空间2目的色彩空间    色彩空间要考虑RGB的顺序 
    支持的颜色空间包括:RGB    RGB565    RGB555    GRAY RGBA    XYZ    YCrCb    HSV    HLS    Luv    BayerRG 
空间转换 
void cvFlip(const CvArr* src, CvArr* dst=NULL, int flip_mode=0);//图像绕x、y轴旋转。当用在一维数组上时并且flip_mode>0,可以用来颠倒数据排列 
    flip_mode=0:左右对称values of the conversion resul 
    flip_mode>0:上下对称 
    flip_mode<0:中心对称

 

矩阵间操作 
void cvCopy(const CvArr* src,CvArr* dst,const CvArr* mask=NULL); 
void cvMerge(const CvArr* src0,const CvArr* src1,const CvArr* src2,const CvArr* src3,CvArr* dst);//多个数组合并成一个,类型和尺寸都相同,dst有多个通道,src可以赋值NULL 
void cvSplit(cosnt CvArr* src,CvArr* dst0,CvArr* dst1,CvArr* dst2,CvArr* dst3);//一个多通道数组分解成多个数组,类型尺寸都想同,dst可以赋值NULL 
void cvRepeat(const CvArr* src, CvArr* dst);//在dst中重复叠加src,dst(i,j)=src(i mod rows(src), j mod cols(src)) 
CvMat* cvReshape(const CvArr* originalarr, CvMat* headerdata, int new_cn, int new_rows=0);//把一个originalarr(可以是已经有内容的图片),转换为有新的通道数、新的行数的数据(CvMat*只含数据,没有图片头) 
CvArr* cvReshapeMatND(const CvArr* arr, int sizeof_header, CvArr* header, int new_cn, int new_dims, int* new_sizes); 
void cvLUT(const CvArr* src, CvArr* dst, const CvArr* lut);//src是8bit类型的数据,lut是一张一维查找表,拥有256个通道数类型和dst相同的元素,src的某一位置的元素数值n,到lut的n位置查找的内容填入dst的相应src的n元素的位置

 

统计运算 
最大最小 
void cvMax(const CvArr* src1, const CvArr* src2, CvArr* dst); 
void cvMaxS(const CvArr* src, double value, CvArr* dst);//找较大值放到dst中 
void cvMin(const CvArr* src1,const CvArr* src2,CvArr* dst); 
void cvMins(const CvArr* src,double value,CvArr* dst);//找较小值放到dst中 
void cvMinMaxLoc(const CvArr* arr, double* min_val, double* max_val, CvPoint* min_loc=NULL, CvPoint* max_loc=NULL, const CvArr* mask=NULL); 
    找出全局某个通道中最大最小的值,和她们的位置,如果不止一个通道,一定要设置COI 
零的个数 
int cvCountNonZero( const CvArr* arr );//统计非零的个数 
是否落在范围内 
void cvInRange(const CvArr* src,const CvArr* lower,const CvArr* upper,CvArr* dst); 
void cvInRangeS(const CvArr* src,CvScalar lower,CvScalar upper,CvArr* dst);//判断原数组中的每个数大小是否落在对应的lower、upper数组位置数值的中间 
    if( lower(i)<=src(i)<upper(i) ){ dst(i)=0xff; }else{ dst(i)=0; } 
平均值标准差 
CvScalar cvAvg(const CvArr* arr,const CvArr* mask = NULL);//计算mask非零位置的所有元素的平均值,如果是图片,则单独计算每个通道上的平均值,如果COI设置了,只计算该COI通道的平均值 
void cvAvgSdv(const CvArr* arr, CvScalar* mean, CvScalar* std_dev, const CvArr* mask=NULL);//计算各通道的平均值,标准差,支持COI

double cvNorm(const CvArr* arr1,const CvArr* arr2=NULL,int norm_type=CV_L2,const CvArr* mask=NULL);//计算一个数组的各种范数 
    如果arr2为NULL,norm_type为 
        CV_C 求所有数取绝对值后的最大值,CV_L1 求所有数的绝对值的和,CV_L2求所有数的平方和的平方根 
    如果arr2不为NULL,norm_type为 
        CV_C arr1和arr2对应元素差的绝对值中的最大值    CV_L1 arr1和arr2对应元素差的绝对值的和    CV_L2 arr1和arr2的差平方和的平方根 
        CV_RELATIVE_C    CV_RELATIVE_L1    CV_RELATIVE_L2 上面结果除以cvNorm(arr2,NULL,对应的norm_type); 
cvNormalize(const CvArr* src,CvArr* dst,double a=1.0,double b=0.0,int norm_type=CV_L2,const CvArr* mask=NULL); 
    CV_C    CV_L1    CV_L2    CV_MINMAX 
cvReduce(const CvArr* src,CvArr* dst,int dim,int op=CV_REDUCE_SUM);//根据一定规则,把矩阵约简为向量 
    dim    决定约简到行还是列    1:约简到单个列,0:约简到单个行,-1:根据dst的CvSize,决定约简到行还是列 
    op    决定按什么规则约简 
        CV_REDUCE_SUM - 行/列的和 
        CV_REDUCE_AVG  -    行/列平均值 
        CV_REDUCE_MAX - 行/列中最大值 
        CV_REDUCE_MIN  -    行/列中最小值

 

取得设置数组信息 
得到指定行列 
CvMat* cvGetCol(const CvArr* arr,CvMat* submat,int col); 
CvMat* cvGetCols(const CvArr* arr,CvMat* submat,int start_col,int end_col);//取目标矩阵的某列/连续几列,submat和返回值的实际数据还是在原矩阵中,只是修改了头部和数据指针,没有数据拷贝 
CvMat* cvGetRow(const CvArr* arr,CvMat* submat,int row); 
CvMat* cvGetRows(const CvArr* arr,CvMat* submat,int start_row,int end_row); 
得到对角线 
CvMat* cvGetDiag(const CvArr* arr,CvMat* submat,int diag=0);//取矩阵arr的对角线,结果放在向量中,并不要求原矩阵是方阵,diag表示从哪个位置开始取对角线 
维度大小 
int cvGetDims(const CvArr* arr,int* sizes=NULL);//获取数组的维数和每一维的大小,sizes十一个数组的头指针。图像或者矩阵的维数一定是2,先行数后列数 
int cvGetDimSize(const CvArr* arr,int index);//获取某一维的大小 
矩阵大小 
CvSize cvGetSize(const CvArr* arr);//返回矩阵和图像的大小。小的结构体一般都是直接返回值而不是重新分配指针,分配指针的效率可能比直接返回值效率更低 
截取矩形矩阵 
CvMat* cvGetSubRect(const CvArr* arr, CvMat* submat, CvRect rect);//从输入的数组中根据输入的矩形截取一块数组中的矩形,返回的CvMat*就是submat 
得到和设置元素        因为效率原因,实际很少会直接用到这些方法,而是根据实际的应用来决定如何操作每一个数 
uchar* cvPtr1D(CvArr* arr,int idx0,int* type);//得到的是指针,所以可以修改,比下面的效率更高 
uchar* cvPtr2D(CvArr* arr,int idx0,int idx1,int* type); 
uchar* cvPtr3D(CvArr* arr,int idx0,int idx1,int idx2,int* type); 
uchar* cvPtrND(CvArr* arr,int* idx,int* type,int create_node=1,unsigned* precalc_hashval=NULL);//int* idx是一个数组指针,里面保存着索引 
double cvGetReal1D(const CvArr* arr,int idx0);//得到的是具体值 
double cvGetReal2D(const CvArr* arr,int idx0,int idx1); 
double cvGetReal3D(const CvArr* arr,int idx0,int idx1,int idx2); 
double cvGetRealND(const CvArr* arr,int* idx); 
CvScalar cvGet1D(const CvArr* arr,int idx0); 
CvScalar cvGet2D(const CvArr* arr,int idx0,int idx1); 
CvScalar cvGet3D(const CvArr* arr,int idx0,int idx1,int idx2); 
CvScalar cvGetND(const CvArr* arr,int* idx); 
double cvmGet(const CvMat* mat, int row, int col);//仅仅用于矩阵单通道浮点数的获取,由于是inline并且没有类型判断,所以效率比较高 
void cvSetReal1D(CvArr* arr, int idx0, double value); 
void cvSetReal2D(CvArr* arr, int idx0, int idx1, double value); 
void cvSetReal3D(CvArr* arr, int idx0, int idx1, int idx2, double value); 
void cvSetRealND(CvArr* arr, int* idx, double value); 
void cvSet1D(CvArr* arr, int idx0, CvScalar value); 
void cvSet2D(CvArr* arr, int idx0, int idx1, CvScalar value); 
void cvSet3D(CvArr* arr, int idx0, int idx1, int idx2, CvScalar value); 
void cvSetND(CvArr* arr, int* idx, CvScalar value); 
void cvmSet(CvMat* mat, int row, int col, double value);//仅仅用于设置单通道浮点类型的矩阵 
void cvClearND(CvArr* arr, int* idx);//把多维数组的某位置设置为0 
void cvSet(CvArr* arr, CvScalar value, const CvArr* mask=NULL);//把数组每个元素都设为value 
void cvSetZero(CvArr* arr);//对普通矩阵,每位都设为0;对稀疏矩阵,删除所以元素

 

一般算数运算 
int cvRound(double value ); int cvFloor( double value ); int cvCeil( double value);//求和double最(上/下)接近的整数 
float cvSqrt(float value);//求平方根 
float cvInvSqrt(float value);//求平方根倒数 
float cvCbrt(float value);//求立方根 
float cvCbrt(float value);//求两个向量的夹角 
int cvIsNaN(double value);//判断是否是合法数 
int cvIsInf(double value);//判断是否无穷 
void cvCartToPolar(const CvArr* x, const CvArr* y, CvArr* magnitude, CvArr* angle=NULL, int angle_in_degrees=0);// 
void cvPolarToCart(const CvArr* magnitude, const CvArr* angle, CvArr* x, CvArr* y, int angle_in_degrees=0);// 
void cvSolveCubic(const CvArr* coeffs, CvArr* roots);//求三次方方程解,coeffs作为三次方程的系数,可以是三元(三次方系数为1)或者四元

 

随机数生成 
CvRNG cvRNG(int64 seed=-1);//生成随机数生成器 
unsigned cvRandInt(CvRNG* rng); 
double cvRandReal(CvRNG* rng); 
void cvRandArr(CvRNG* rng, CvArr* arr, int dist_type, CvScalar param1, CvScalar param2);//
    dist_type决定生成随机数组中的分布    CV_RAND_UNI均匀分布    CV_RAND_NORMAL正态/高斯分布 
    param1:均匀分布中的下界(包含),正态分布中的平均值 
    param2:均匀分布中的上界(不包含),正态分布中的偏差

 

分布转换 
void cvDFT(const CvArr* src, CvArr* dst, int flags, int nonzero_rows=0); 
int cvGetOptimalDFTSize(int size0); 
void cvMulSpectrums(const CvArr* src1, const CvArr* src2, CvArr* dst, int flags); 
void cvDCT(const CvArr* src, CvArr* dst, int flags);

2018-07-02 09:21:40 HelloZEX 阅读数 194
  • (二)矩阵基本运算

    本课程由专业数学系老师讲解,从数学背景和现实应用中讲解线性代数的相关知识,摆脱传统...使听众能够了解矩阵和空间的概念、性质。深刻理解矩阵各类运算、分解的数学意义和应用,为后续的机器学习打下扎实的数学基础。

    825人学习 AI100讲师
    免费试看

有很多函数有mask,代表掩码,如果某位mask是0,那么对应的src的那一位就不计算,mask要和矩阵/ROI/的大小相等 
大多数函数支持ROI,如果图像ROI被设置,那么只处理ROI部分 
少部分函数支持COI,如果COI设置,只处理感兴趣的通道

矩阵逻辑运算 
void cvAnd(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL);// 
void cvAndS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL);// 
void cvOr(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL);// 
void cvOrS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL);// 
void cvXor(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL);// 
void cvXorS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL);// 
void cvNot(const CvArr* src,CvArr* dst);//矩阵取反

 

矩阵算术运算 
绝对值 
void cvAbs(const CvArr* src,CvArr* dst); 
void cvAbsDiff(const CvArr* src1,const CvArr* src2, CvArr* dst);//两矩阵相减取绝对值 
void cvAbsDiffS(const CvArr* src, CvArr* dst,CvScalar value);//矩阵减去一个数取绝对值 
加减 
void cvAdd(const CvArr* src1,const CvArr* src2,CvArr* dst,const CvArr* mask = NULL);//两数组相加,dst(I)=src1(I)+src2(I) if mask(I)!=0 
void cvAddS(const CvArr* src,CvScalar value,CvArr*dst,const CvArr* mask = NULL);//数组和一个数相加,dst(I)=src(I)+value if mask(I)!=0 
void cvAddWeighted(const CvArr* src1,double alpha,const CvArr* src2,double beta,double gamma,CvArradded to each sum* dst);//带权相加相当于dst(x,y) = α ? src1(x,y) + β ? src2(x,y) + γ 
void cvSub(const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL);//矩阵减法,dst(I)=src1(I)-src2(I) if mask(I)!=0 
void cvSubS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL);//矩阵减数,dst(I)=src(I)-value if mask(I)!=0 
void cvSubRS(const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask=NULL);//数减矩阵,dst(I)=value-src(I) if mask(I)!=0 
乘除 
void cvDiv(const CvArr* src1, const CvArr* src2, CvArr* dst, double scale=1);//scale*src1(i)/src2(i),如果src1=NULL,则计算scale/src2(i) 
void cvMul(const CvArr* src1,const CvArr* src2,CvArr* dst,double scale=1);//两矩阵元素之间的简单乘法,一般的矩阵点乘用cvGEMM(); 
次方 
void cvPow(const CvArr* src, CvArr* dst, double power);//为每个src的数求power次方 
指数 
void cvExp(const CvArr* src, CvArr* dst);//dst(I)=EXP(src(I)) 
对数 
void cvLog(const CvArr* src, CvArr* dst);//

 

线性代数计算 
加&乘 
void cvScaleAdd(const CvArr* src1, CvScalar scale, const CvArr* src2, CvArr* dst);//src1和scale的乘积加上src2 
void cvCrossProduct(const CvArr* src1,const CvArr* src2,CvArr* dst);//计算两个3D向量(单通道)的叉乘运算 
double cvDotProduct(const CvArr* src1, const CvArr* src2);//两个向量点乘 
void cvGEMM(const CvArr* src1, const CvArr* src2, double alpha, const CvArr* src3, double beta, CvArr* dst, int tABC=0);//乘加运算的始祖 
    由通用乘加函数参与定义的两个具体宏 
        cvMatMul(const CvArr* src1,const CvArr* src2,CvArr* dst); 
        cvMatMulAdd(const CvArr* src1,const CvArr* src2,const CvArr* src3,CvArr* dst); 
CvScalar cvTrace(const CvArr* mat);//计算对角线上的元素和 
变换 
void cvTransform(const CvArr* src, CvArr* dst, const CvMat* transmat, const CvMat* shiftvec=NULL);//dst=transmat · src + shiftvec 
void cvPerspectiveTransform(const CvArr* src, CvArr* dst, const CvMat* mat);//把矩阵每个元素中三个通道当做一个矩阵,乘mat,mat是一个3×3或者4×4的转换矩阵 
转置 
void cvTranspose(const CvArr* src, CvArr* dst); 
void cvMulTransposed(const CvArr* src, CvArr* dst, int order, const CvArr* delta=NULL, double scale=1.0);//(src-delta)乘以它的转置再乘以scale 
逆矩阵 
double cvInvert(const CvArr* src,CvArr* dst,int method=CV_LU);//求原矩阵的逆矩阵,默认使用高斯消去法 
    方阵可逆的充要条件是|A|!=0 
    method取值为CV_LU高斯消去法(默认)    CV_SVD 奇异值分解SVD    CV_SVD_SYM对称矩阵的SVD 
行列式 
double cvDet(const CvArr* mat);//计算方阵行列式,一定是单通道的 
    小型方阵直接计算,大型方阵用高斯消去法计算 
    如果矩阵正定对称,用奇异值分解的方法解决cvSVD(); 
特征向量特征值 
void cvEigenVV(CvArr* mat, CvArr* evects, CvArr* evals, double eps=0);//计算对称矩阵的特征值和特征向量,evects输出特征向量,evals输出特征值,eps雅可比方法停止参数 
    要求三个矩阵都是浮点类型,10×10以下该方法有效,20×20以上的矩阵不能计算出结果,为节约计算量,eps通常设为DBL_EPSILON(10^-15) 
    如果给定的矩阵是对称正定矩阵,那么考虑使用cvSVD(); 
协方差 
void cvCalcCovarMatrix(const CvArr** vects, int count, CvArr* cov_mat, CvArr* avg, int flags);//给定一组大小和类型相同的向量,向量的个数,计算标记,输出协方差正阵和每个向量的平均值矩阵 
    CV_COVAR_NORMAL    普通计算协方差和平均值,输出的是n×n的协方差阵 
    CV_COVAR_SCRAMBLED    快速PCA“Scrambled”协方差,输出的是m×m的协方差阵 
    CV_COVAR_USE_AVERAGE    平均值是输入的 
    CV_COVAR_SCALE    重新缩放输出的协方差矩阵 
        四个flag通过并运算协同发挥作用,前两个不能并 
CvSize cvMahalonobis(const CvArr* vec1,const CvArr* vec2,CvArr* mat); 
int cvSolve(const CvArr* src1, const CvArr* src2, CvArr* dst, int method=CV_LU);//Solves a linear system or least-squares problem. 
void cvSVD(CvArr* A, CvArr* W, CvArr* U=NULL, CvArr* V=NULL, int flags=0);//Performs singular value decomposition of a real floating-point matrix. 
void cvSVBkSb(const CvArr* W, const CvArr* U, const CvArr* V, const CvArr* B, CvArr* X, int flags);//Performs singular value back substitution.

 

数组比较 
void cvCmp(const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op);//两矩阵比较运算 
    CV_CMP_EQ - src1(I) 是否相等 
    CV_CMP_GT - src1(I) 是否大于 
    CV_CMP_GE - src1(I) 是否大于等于 
    CV_CMP_LT - src1(I) 是否小于 
    CV_CMP_LE - src1(I) 是否小于等于 
    CV_CMP_NE - src1(I) 是否不等 
        如果判断为假,dst设为0,如果判断为真,dst设为0xff 
void cvCmpS(const CvArr* src, double value, CvArr* dst, int cmp_op);//矩阵和一个数字比较运算

 

矩阵内转换 
类型转换 
void cvConvertScale(const CvArr* src,CvArr* dst,double scale,double shift);//矩阵首先乘以scale再加上shift,然后把src中的数据类型转换成dst类型,但是src和dst通道数需要相等 
void cvConvertScaleAbs(const CvArr* src,CvArr* dst,double scale,double shift);//在src到dst类型转换前,先做绝对值 
void cvCvtColor(const CvArr* src,CvArr* dst, int code);//图像 颜色空间转换,src要为8U 16U 32F,dst的数据类型需要和src相同,通道数看code 
    code格式如:CV_原色彩空间2目的色彩空间    色彩空间要考虑RGB的顺序 
    支持的颜色空间包括:RGB    RGB565    RGB555    GRAY RGBA    XYZ    YCrCb    HSV    HLS    Luv    BayerRG 
空间转换 
void cvFlip(const CvArr* src, CvArr* dst=NULL, int flip_mode=0);//图像绕x、y轴旋转。当用在一维数组上时并且flip_mode>0,可以用来颠倒数据排列 
    flip_mode=0:左右对称values of the conversion resul 
    flip_mode>0:上下对称 

    flip_mode<0:中心对称


转载:点击打开链接

无损卡尔曼滤波

阅读数 4019