1.卡尔曼滤波(Kalman Filter)概述
卡尔曼滤波(Kalman filtering)一种利用线性系统状态方程,通过系统输入输出观测数据,对系统状态进行最优估计的算法。由于观测数据中包括系统中的噪声和干扰的影响,所以最优估计也可看作是滤波过程。
斯坦利·施密特(Stanley Schmidt)首次实现了卡尔曼滤波器。卡尔曼在NASA埃姆斯研究中心访问时,发现他的方法对于解决阿波罗计划的轨道预测很有用,后来阿波罗飞船的导航电脑使用了这种滤波器。 关于这种滤波器的论文由Swerling (1958), Kalman (1960)与 Kalman and Bucy (1961)发表。
数据滤波是去除噪声还原真实数据的一种数据处理技术, Kalman滤波在测量方差已知的情况下能够从一系列存在测量噪声的数据中,估计动态系统的状态. 由于, 它便于计算机编程实现, 并能够对现场采集的数据进行实时的更新和处理, Kalman滤波是目前应用最为广泛的滤波方法, 在通信, 导航, 制导与控制等多领域得到了较好的应用,常用于目标跟踪系统。
卡尔曼滤波的一个典型实例是从一组有限的,对物体位置的,包含噪声的观察序列中预测出物体的坐标位置及速度。在很多工程应用(雷达、计算机视觉)中都可以找到它的身影。同时,卡尔曼滤波也是控制理论以及控制系统工程中的一个重要话题。
比如,在雷达中,人们感兴趣的是跟踪目标,但目标的位置、速度、加速度的测量值往往在任何时候都有噪声。卡尔曼滤波利用目标的动态信息,设法去掉噪声的影响,得到一个关于目标位置的好的估计。这个估计可以是对当前目标位置的估计(滤波),也可以是对于将来位置的估计(预测),也可以是对过去位置的估计(插值或平滑)。
2.卡尔曼滤波的五个核心公式
(1)NO.1 预测现在的状态,更新系统结果
x(k|k-1) = A*x(k-1|k-1) + B*U(k)
x(k|k-1):利用上一状态预测的结果
x(k-1|k-1):上一时刻的最优预测值
U(k):现在状态的控制量,如果没有,可以为0
(2)NO.2 更新x(k|k-1)的covariance,P表示covariance
p(k|k-1)=A*p(k-1|k-1)*AT+Q
p_mid=p(k|k-1),p_last=p(k-1|k-1)
NO.1 NO.2是对系统的预测
(3)NO.3 参考测量值进行估计
x(k|k)=x(k|k-1)+kg*(Z(k)-H*x(k|k-1))
为了实现递归,每次的kg都是实时更新的
(4)NO.4
kg=p(k|k-1)*HT/(H*p(k|k-1)*HT+R)
(5)NO.5
p(k|k)=(1-kg*H)*p(k|k-1)
这样每次 p(k|k)和kg 都需要前一时刻的值来更新,递归的估计下去
3.举例说明卡尔曼滤波器
为了可以更加容易的理解卡尔曼滤波器,这里会应用形象的描述方法来讲解,而不是像大多数参考书那样罗列一大堆的数学公式和数学符号。但是,他的5条公式是其核心内容。结合现代的计算机,其实卡尔曼的程序相当的简单,只要你理解了他的那5条公式。
在介绍他的5条公式之前,先让我们来根据下面的例子一步一步的探索。
假设我们要研究的对象是一个房间的温度。根据你的经验判断,这个房间的温度是恒定的,也就是下一分钟的温度等于现在这一分钟的温度(假设我们用一分钟来做时间单位)。假设你对你的经验不是100%的相信,可能会有上下偏差几度。我们把这些偏差看成是高斯白噪声(White Gaussian Noise),也就是这些偏差跟前后时间是没有关系的而且符合高斯分配(Gaussian Distribution)。另外,我们在房间里放一个温度计,但是这个温度计也不准确的,测量值会比实际值偏差。我们也把这些偏差看成是高斯白噪声。
好了,现在对于某一分钟我们有两个有关于该房间的温度值:你根据经验的预测值(系统的预测值)和温度计的值(测量值)。下面我们要用这两个值结合他们各自的噪声来估算出房间的实际温度值。
假如我们要估算k时刻的是实际温度值。首先你要根据k-1时刻的温度值,来预测k时刻的温度。因为你相信温度是恒定的,所以你会得到k时刻的温度预测值是跟 k-1时刻一样的,假设是23度,同时该值的高斯噪声的偏差是5度(5是这样得到的:如果k-1时刻估算出的最优温度值的偏差是3,你对自己预测的不确定度是4度,他们平方相加再开方,就是5)。然后,你从温度计那里得到了k时刻的温度值,假设是25度,同时该值的偏差是4度。
由于我们用于估算k时刻的实际温度有两个温度值,分别是23度和25度。究竟实际温度是多少呢?相信自己还是相信温度计呢?究竟相信谁多一点,我们可以用他们的 covariance来判断。因为Kg^2=5^2/(5^2+4^2),所以Kg=0.78,我们可以估算出k时刻的实际温度值是:23+0.78* (25-23)=24.56度。可以看出,因为温度计的covariance比较小(比较相信温度计),所以估算出的最优温度值偏向温度计的值。
现在我们已经得到k时刻的最优温度值了,下一步就是要进入k+1时刻,进行新的最优估算。到现在为止,好像还没看到什么自回归的东西出现。对了,在进入 k+1时刻之前,我们还要算出k时刻那个最优值(24.56度)的偏差。算法如下:((1-Kg)*5^2)^0.5=2.35。这里的5就是上面的k时刻你预测的那个23度温度值的偏差,得出的2.35就是进入k+1时刻以后k时刻估算出的最优温度值的偏差(对应于上面的3)。
就是这样,卡尔曼滤波器就不断的把covariance递归,从而估算出最优的温度值。他运行的很快,而且它只保留了上一时刻的covariance。上面的Kg,就是卡尔曼增益(Kalman Gain)。他可以随不同的时刻而改变他自己的值,是不是很神奇!
下面就要言归正传,讨论真正工程系统上的卡尔曼。
4.卡尔曼滤波公式推导
在这一部分,我们就来描述源于Dr Kalman 的卡尔曼滤波器。下面的描述,会涉及一些基本的概念知识,包括概率(Probability),随即变量(Random Variable),高斯或正态分配(Gaussian Distribution)还有State-space Model等等。但对于卡尔曼滤波器的详细证明,这里不能一一描述。
首先,我们先要引入一个离散控制过程的系统。该系统可用一个线性随机微分方程(Linear Stochastic Difference equation)来描述:
X(k)=A X(k-1)+B U(k)+W(k)
再加上系统的测量值:
Z(k)=H X(k)+V(k)
上两式子中,X(k)是k时刻的系统状态,U(k)是k时刻对系统的控制量。A和B是系统参数,对于多模型系统,他们为矩阵。Z(k)是k时刻的测量值,H 是测量系统的参数,对于多测量系统,H为矩阵。W(k)和V(k)分别表示过程和测量的噪声。他们被假设成高斯白噪声(White Gaussian Noise),他们的covariance 分别是Q,R(这里我们假设他们不随系统状态变化而变化)。
对于满足上面的条件(线性随机微分系统,过程和测量都是高斯白噪声),卡尔曼滤波器是最优的信息处理器。下面我们来用他们结合他们的covariances 来估算系统的最优化输出(类似上一节那个温度的例子)。
首先我们要利用系统的过程模型,来预测下一状态的系统。假设现在的系统状态是k,根据系统的模型,可以基于系统的上一状态而预测出现在状态:
X(k|k-1)=A X(k-1|k-1)+B U(k) ……….. (1)
式(1)中,X(k|k-1)是利用上一状态预测的结果,X(k-1|k-1)是上一状态最优的结果,U(k)为现在状态的控制量,如果没有控制量,它可以为0。
到现在为止,我们的系统结果已经更新了,可是,对应于X(k|k-1)的covariance还没更新。我们用P表示covariance:
P(k|k-1)=A P(k-1|k-1) A’+Q ……… (2)
式 (2)中,P(k|k-1)是X(k|k-1)对应的covariance,P(k-1|k-1)是X(k-1|k-1)对应的 covariance,A’表示A的转置矩阵,Q是系统过程的covariance。式子1,2就是卡尔曼滤波器5个公式当中的前两个,也就是对系统的预测。
现在我们有了现在状态的预测结果,然后我们再收集现在状态的测量值。结合预测值和测量值,我们可以得到现在状态(k)的最优化估算值X(k|k):
X(k|k)= X(k|k-1)+Kg(k) (Z(k)-H X(k|k-1)) ……… (3)
其中Kg为卡尔曼增益(Kalman Gain):
Kg(k)= P(k|k-1) H’ / (H P(k|k-1) H’ + R) ……… (4)
到现在为止,我们已经得到了k状态下最优的估算值X(k|k)。但是为了要另卡尔曼滤波器不断的运行下去直到系统过程结束,我们还要更新k状态下X(k|k)的covariance:
P(k|k)=(I-Kg(k) H)P(k|k-1) ……… (5)
其中I 为1的矩阵,对于单模型单测量,I=1。当系统进入k+1状态时,P(k|k)就是式子(2)的P(k-1|k-1)。这样,算法就可以自回归的运算下去。
卡尔曼滤波器的原理基本描述了,式子1,2,3,4和5就是他的5 个基本公式。根据这5个公式,可以很容易的实现计算机的程序。
5.卡尔曼滤波案例
这里我们结合第二第三节,举一个非常简单的例子来说明卡尔曼滤波器的工作过程。所举的例子是进一步描述第二节的例子,而且还会配以程序模拟结果。
根据第二节的描述,把房间看成一个系统,然后对这个系统建模。当然,我们见的模型不需要非常地精确。我们所知道的这个房间的温度是跟前一时刻的温度相同的,所以A=1。没有控制量,所以U(k)=0。因此得出:
X(k|k-1)=X(k-1|k-1) ……….. (6)
式子(2)可以改成:
P(k|k-1)=P(k-1|k-1) +Q ……… (7)
因为测量的值是温度计的,跟温度直接对应,所以H=1。式子3,4,5可以改成以下:
X(k|k)= X(k|k-1)+Kg(k) (Z(k)-X(k|k-1)) ……… (8)
Kg(k)= P(k|k-1) / (P(k|k-1) + R) ……… (9)
P(k|k)=(1-Kg(k))P(k|k-1) ……… (10)
现在我们模拟一组测量值作为输入。假设房间的真实温度为25度,我模拟了200个测量值,这些测量值的平均值为25度,但是加入了标准偏差为几度的高斯白噪声(在图中为蓝线)。
为了令卡尔曼滤波器开始工作,我们需要告诉卡尔曼两个零时刻的初始值,是X(0|0)和P(0|0)。他们的值不用太在意,随便给一个就可以了,因为随着卡尔曼的工作,X会逐渐的收敛。但是对于P,一般不要取0,因为这样可能会令卡尔曼完全相信你给定的X(0|0)是系统最优的,从而使算法不能收敛。
6.最佳线性滤波理论与卡尔曼滤波
最佳线性滤波理论起源于 40 年代美国科学家 Wiener 和前苏联科学家K олмогоров 等人的研究工作,后人统称为维纳滤波理论。从理论上说,维纳滤波的最大缺点是必须用到无限过去的数据,不适用于实时处理。为了克服这一缺点, 60 年代 Kalman 把状态空间模型引入滤波理论,并导出了一套递推估计算法,后人称之为卡尔曼滤波理论。卡尔曼滤波是以最小均方误差为估计的最佳准则,来寻求一套递推估计的算法,其基本思想是:采用信号与噪声的状态空间模型,利用前一时刻地估计值和现时刻的观测值来更新对状态变量的估计,求出现时刻的估计值。它适合于实时处理和计算机运算。
7.卡尔曼滤波流程
现设线性时变系统的离散状态防城和观测方程为:
X(k) = F(k,k-1)*X(k-1)+T(k,k-1)*X(k-1)
Y(k) = H(k)*X(k)+N(k)
其中,X(k)和Y(k)分别是k时刻的状态矢量和观测矢量
F(k,k-1)为状态转移矩阵
U(k)为k时刻动态噪声
T(k,k-1)为系统控制矩阵
H(k)为k时刻观测矩阵
N(k)为k时刻观测噪声
则卡尔曼滤波的算法流程为:
预估计:X(k)^= F(k,k-1)*X(k-1)
(1)计算预估计协方差矩阵
C(k)^=F(k,k-1)×C(k)×F(k,k-1)'+T(k,k-1)×Q(k)×T(k,k-1)'
Q(k) = U(k)×U(k)'
(2)计算卡尔曼增益矩阵
K(k) = C(k)^×H(k)'×[H(k)×C(k)^×H(k)'+R(k)]^(-1)
R(k) = N(k)×N(k)'
(3)更新估计
X(k)~=X(k)^+K(k)×[Y(k)-H(k)×X(k)^]
(4)计算更新后估计协防差矩阵
C(k)~ = [I-K(k)×H(k)]×C(k)^×[I-K(k)×H(k)]'+K(k)×R(k)×K(k)'
(5)X(k+1) = X(k)~ , C(k+1) = C(k)~
重复以上步骤
8.Kalman Filter卡尔曼滤波算法C语言源代码
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 | /** * 算法君:一个专业的算法学习分享网站 * 算法君:专业分享--数据剖析--算法精解 * 算法君:http://www.suanfajun.com */ /*卡尔曼滤波(Kalman Filter)算法--C语言代码*/ #include "stdlib.h" #include "math.h" #include "stdio.h" /** * 求逆函数 * @param n [数组a长度] * @param a [数组] * @return [0--失败 1--成功] */ int rinv(n,a) int n; double a[]; { int *is,*js,i,j,k,l,u,v; double d,p; is=malloc(n*sizeof(int)); js=malloc(n*sizeof(int)); for (k=0; k=n-1; k++) { d=0.0; for (i=k; i=n-1; i++) { for (j=k; j=n-1; j++) { l=i*n+j; p=fabs(a[l]); if (p>d) { d=p; is[k]=i; js[k]=j; } } } if (d+1.0==1.0) { free(is); free(js); printf("err**not inv\n"); return(0); } if (is[k]!=k) { for (j=0; j=n-1; j++) { u=k*n+j; v=is[k]*n+j; p=a[u]; a[u]=a[v]; a[v]=p; } } if (js[k]!=k) { for (i=0; i=n-1; i++) { u=i*n+k; v=i*n+js[k]; p=a[u]; a[u]=a[v]; a[v]=p; } } l=k*n+k; a[l]=1.0/a[l]; for (j=0; j=n-1; j++) { if (j!=k) { u=k*n+j; a[u]=a[u]*a[l]; } } for (i=0; i=n-1; i++) { if (i!=k) { for (j=0; j=n-1; j++) { if (j!=k) { u=i*n+j; a[u]=a[u]-a[i*n+k]*a[k*n+j]; } } } } for (i=0; i=n-1; i++) { if (i!=k) { u=i*n+k; a[u]=-a[u]*a[l]; } } } for (k=n-1; k>=0; k--) { if (js[k]!=k) { for (j=0; j=n-1; j++) { u=k*n+j; v=js[k]*n+j; p=a[u]; a[u]=a[v]; a[v]=p; } } if (is[k]!=k) { for (i=0; i=n-1; i++) { u=i*n+k; v=i*n+is[k]; p=a[u]; a[u]=a[v]; a[v]=p; } } } free(is); free(js); return(1); } /** * 卡尔曼滤波算法 * [Kalman 卡尔曼滤波算法函数] * @param q [过程噪声,Q增大,动态响应变快,收敛稳定性变坏,系统噪声] * @param r [测量噪声,R增大,动态响应变慢,收敛稳定性变好] */ int Kalman(n,m,k,f,q,r,h,y,x,p,g) int n,m,k; double f[],q[],r[],h[],y[],x[],p[],g[]; { int i,j,kk,ii,l,jj,js; double *e,*a,*b; e=malloc(m*m*sizeof(double)); l=m; if (l<n) l=n; a=malloc(l*l*sizeof(double)); b=malloc(l*l*sizeof(double)); for (i=0; i<=n-1; i++) for (j=0; j<=n-1; j++) { ii=i*l+j; a[ii]=0.0; for (kk=0; kk<=n-1; kk++) a[ii]=a[ii]+p[i*n+kk]*f[j*n+kk]; } for (i=0; i<=n-1; i++) for (j=0; j<=n-1; j++) { ii=i*n+j; p[ii]=q[ii]; for (kk=0; kk<=n-1; kk++) p[ii]=p[ii]+f[i*n+kk]*a[kk*l+j]; } for (ii=2; ii<=k; ii++) { for (i=0; i<=n-1; i++) for (j=0; j<=m-1; j++) { jj=i*l+j; a[jj]=0.0; for (kk=0; kk<=n-1; kk++) a[jj]=a[jj]+p[i*n+kk]*h[j*n+kk]; } for (i=0; i<=m-1; i++) for (j=0; j<=m-1; j++) { jj=i*m+j; e[jj]=r[jj]; for (kk=0; kk<=n-1; kk++) e[jj]=e[jj]+h[i*n+kk]*a[kk*l+j]; } js=rinv(e,m); if (js==0) { free(e); free(a); free(b); return(js);} for (i=0; i<=n-1; i++) for (j=0; j<=m-1; j++) { jj=i*m+j; g[jj]=0.0; for (kk=0; kk<=m-1; kk++) g[jj]=g[jj]+a[i*l+kk]*e[j*m+kk]; } for (i=0; i<=n-1; i++) { jj=(ii-1)*n+i; x[jj]=0.0; for (j=0; j<=n-1; j++) x[jj]=x[jj]+f[i*n+j]*x[(ii-2)*n+j]; } for (i=0; i<=m-1; i++) { jj=i*l; b[jj]=y[(ii-1)*m+i]; for (j=0; j<=n-1; j++) b[jj]=b[jj]-h[i*n+j]*x[(ii-1)*n+j]; } for (i=0; i<=n-1; i++) { jj=(ii-1)*n+i; for (j=0; j<=m-1; j++) x[jj]=x[jj]+g[i*m+j]*b[j*l]; } if (ii<k) { for (i=0; i<=n-1; i++) for (j=0; j<=n-1; j++) { jj=i*l+j; a[jj]=0.0; for (kk=0; kk<=m-1; kk++) a[jj]=a[jj]-g[i*m+kk]*h[kk*n+j]; if (i==j) a[jj]=1.0+a[jj]; } for (i=0; i<=n-1; i++) for (j=0; j<=n-1; j++) { jj=i*l+j; b[jj]=0.0; for (kk=0; kk<=n-1; kk++) b[jj]=b[jj]+a[i*l+kk]*p[kk*n+j]; } for (i=0; i<=n-1; i++) for (j=0; j<=n-1; j++) { jj=i*l+j; a[jj]=0.0; for (kk=0; kk<=n-1; kk++) a[jj]=a[jj]+b[i*l+kk]*f[j*n+kk]; } for (i=0; i<=n-1; i++) for (j=0; j<=n-1; j++) { jj=i*n+j; p[jj]=q[jj]; for (kk=0; kk<=n-1; kk++) p[jj]=p[jj]+f[i*n+kk]*a[j*l+kk]; } } } free(e); free(a); free(b); return(js); } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 | /** * 算法君:一个专业的算法学习分享网站 * 算法君:专业分享--数据剖析--算法精解 * 算法君:http://www.suanfajun.com */ /*卡尔曼滤波(Kalman Filter)函数--C语言代码*/ /********************************************************************** 卡尔曼滤波的五个核心公式解释 NO.1 预测现在的状态,更新系统结果 x(k|k-1) = A*x(k-1|k-1) + B*U(k) x(k|k-1):利用上一状态预测的结果 x(k-1|k-1):上一时刻的最优预测值 U(k):现在状态的控制量,如果没有,可以为0 NO.2 更新x(k|k-1)的covariance,P表示covariance p(k|k-1)=A*p(k-1|k-1)*AT+Q p_mid=p(k|k-1),p_last=p(k-1|k-1) NO.1 NO.2是对系统的预测 NO.3 参考测量值进行估计 x(k|k)=x(k|k-1)+kg*(Z(k)-H*x(k|k-1)) 为了实现递归,每次的kg都是实时更新的 NO.4 kg=p(k|k-1)*HT/(H*p(k|k-1)*HT+R) NO.5 p(k|k)=(1-kg*H)*p(k|k-1) 这样每次 p(k|k)和kg 都需要前一时刻的值来更新,递归的估计下去 ***********************************************************************/ /******************************************************************************* * Function Name : Kalman_Filter * Description : 卡尔曼滤波 * Input : None * Output : None * Return : None Q:过程噪声,Q增大,动态响应变快,收敛稳定性变坏,系统噪声 R:测量噪声,R增大,动态响应变慢,收敛稳定性变好 ResrcData: ADC采集的数据 注:1 A=1; 控制量:U(k)=0; 2 个人感觉float足够用了,double太浪费了! 如果用户感觉精度不够,可以改为double *******************************************************************************/ float Kalman_Filter(const float ResrcData,float ProcessNiose_Q,float MeasureNoise_R) { float R = MeasureNoise_R; float Q = ProcessNiose_Q; static float x_last; float x_mid = x_last; float x_now; static float p_last; float p_mid ; float p_now; float kg; x_mid=x_last; //x_last=x(k-1|k-1),x_mid=x(k|k-1) p_mid=p_last+Q; //p_mid=p(k|k-1),p_last=p(k-1|k-1),Q=噪声 kg=p_mid/(p_mid+R); //kg为kalman filter,R为噪声 x_now=x_mid+kg*(ResrcData-x_mid);//估计出的最优值 p_now=(1-kg)*p_mid;//最优值对应的covariance p_last = p_now; //更新covariance值 x_last = x_now; //更新系统状态值 return x_now; } |
9.Kalman Filter卡尔曼滤波算法C++源代码
(1)头文件 kalman.h
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | /** * 算法君:一个专业的算法学习分享网站 * 算法君:专业分享--数据剖析--算法精解 * 算法君:http://www.suanfajun.com */ /*头文件:kalman.h*/ /*卡尔曼滤波(Kalman Filter)算法--C++语言代码*/ #pragma once #include <math.h> #include "cv.h" /** * cv.h 是 OpenCV函数,可以通过以下网址获取 * https://sourceforge.net/projects/opencvlibrary/files/?source=navbar */ class kalman { public: void init_kalman(int x,int xv,int y,int yv); CvKalman* cvkalman; CvMat* state; CvMat* process_noise; CvMat* measurement; const CvMat* prediction; CvPoint2D32f get_predict(float x, float y); kalman(int x=0,int xv=0,int y=0,int yv=0); //virtual ~kalman(); }; |
(2)实现文件 kalman.cpp
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 | /** * 算法君:一个专业的算法学习分享网站 * 算法君:专业分享--数据剖析--算法精解 * 算法君:http://www.suanfajun.com */ /*实现文件:kalman.cpp*/ /*卡尔曼滤波(Kalman Filter)算法--C++语言代码*/ #include "kalman.h" #include <stdio.h> CvRandState rng; const double T = 0.1; kalman::kalman(int x,int xv,int y,int yv) { cvkalman = cvCreateKalman( 4, 4, 0 ); state = cvCreateMat( 4, 1, CV_32FC1 ); process_noise = cvCreateMat( 4, 1, CV_32FC1 ); measurement = cvCreateMat( 4, 1, CV_32FC1 ); int code = -1; /* create matrix data */ const float A[] = { 1, T, 0, 0, 0, 1, 0, 0, 0, 0, 1, T, 0, 0, 0, 1 }; const float H[] = { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 }; const float P[] = { pow(320,2), pow(320,2)/T, 0, 0, pow(320,2)/T, pow(320,2)/pow(T,2), 0, 0, 0, 0, pow(240,2), pow(240,2)/T, 0, 0, pow(240,2)/T, pow(240,2)/pow(T,2) }; const float Q[] = { pow(T,3)/3, pow(T,2)/2, 0, 0, pow(T,2)/2, T, 0, 0, 0, 0, pow(T,3)/3, pow(T,2)/2, 0, 0, pow(T,2)/2, T }; const float R[] = { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 }; cvRandInit( &rng, 0, 1, -1, CV_RAND_UNI ); cvZero( measurement ); cvRandSetRange( &rng, 0, 0.1, 0 ); rng.disttype = CV_RAND_NORMAL; cvRand( &rng, state ); memcpy( cvkalman->transition_matrix->data.fl, A, sizeof(A)); memcpy( cvkalman->measurement_matrix->data.fl, H, sizeof(H)); memcpy( cvkalman->process_noise_cov->data.fl, Q, sizeof(Q)); memcpy( cvkalman->error_cov_post->data.fl, P, sizeof(P)); memcpy( cvkalman->measurement_noise_cov->data.fl, R, sizeof(R)); //cvSetIdentity( cvkalman->process_noise_cov, cvRealScalar(1e-5) ); //cvSetIdentity( cvkalman->error_cov_post, cvRealScalar(1)); //cvSetIdentity( cvkalman->measurement_noise_cov, cvRealScalar(1e-1) ); /* choose initial state */ state->data.fl[0]=x; state->data.fl[1]=xv; state->data.fl[2]=y; state->data.fl[3]=yv; cvkalman->state_post->data.fl[0]=x; cvkalman->state_post->data.fl[1]=xv; cvkalman->state_post->data.fl[2]=y; cvkalman->state_post->data.fl[3]=yv; cvRandSetRange( &rng, 0, sqrt(cvkalman->process_noise_cov->data.fl[0]), 0 ); cvRand( &rng, process_noise ); } CvPoint2D32f kalman::get_predict(float x, float y) { /* update state with current position */ state->data.fl[0]=x; state->data.fl[2]=y; /* predict point position */ /* x'k=A鈥 k+B鈥 k P'k=A鈥 k-1*AT + Q */ cvRandSetRange( &rng, 0, sqrt(cvkalman->measurement_noise_cov->data.fl[0]), 0 ); cvRand( &rng, measurement ); /* xk=A?xk-1+B?uk+wk */ cvMatMulAdd( cvkalman->transition_matrix, state, process_noise, cvkalman->state_post ); /* zk=H?xk+vk */ cvMatMulAdd( cvkalman->measurement_matrix, cvkalman->state_post, measurement, measurement ); /* adjust Kalman filter state */ /* Kk=P'k鈥 T鈥?H鈥 'k鈥 T+R)-1 xk=x'k+Kk鈥?zk-H鈥 'k) Pk=(I-Kk鈥 )鈥 'k */ cvKalmanCorrect( cvkalman, measurement ); float measured_value_x = measurement->data.fl[0]; float measured_value_y = measurement->data.fl[2]; const CvMat* prediction = cvKalmanPredict( cvkalman, 0 ); float predict_value_x = prediction->data.fl[0]; float predict_value_y = prediction->data.fl[2]; return(cvPoint2D32f(predict_value_x,predict_value_y)); } void kalman::init_kalman(int x,int xv,int y,int yv) { state->data.fl[0]=x; state->data.fl[1]=xv; state->data.fl[2]=y; state->data.fl[3]=yv; cvkalman->state_post->data.fl[0]=x; cvkalman->state_post->data.fl[1]=xv; cvkalman->state_post->data.fl[2]=y; cvkalman->state_post->data.fl[3]=yv; } |
10.Kalman Filter卡尔曼滤波算法Matlab源代码
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 | % 算法君:一个专业的算法学习分享网站 % 算法君:专业分享--数据剖析--算法精解 % 算法君:http://www.suanfajun.com % 尔曼滤波(Kalman Filter)算法--Matlab代码 %%==================================== clear all; close all; clc; %% Initial condition ts = 1; % Sampling time t = [0:ts:100]; T = length(t); %% Initial state x = [0 40 0 20]'; x_hat = [0 0 0 0]'; %% Process noise covariance q = 5 Q = q*eye(2); %% Measurement noise covariance r = 5 R = r*eye(2); %% Process and measurement noise w = sqrt(Q)*randn(2,T); % Process noise v = sqrt(R)*randn(2,T); % Measurement noise %% Estimate error covariance initialization p = 5; P(:,:,1) = p*eye(4); %%==================================== %% Continuous-time state space model %{ x_dot(t) = Ax(t)+Bu(t) z(t) = Cx(t)+Dn(t) %} A = [0 1 0 0; 0 0 0 0; 0 0 0 1; 0 0 0 0]; B = [0 0; 1 0; 0 0; 0 1]; C = [1 0 0 0; 0 0 1 0]; D = [1 0; 0 1]; %% Discrete-time state space model %{ x(k+1) = Fx(k)+Gw(k) z(k) = Hx(k)+Iv(k) Continuous to discrete form by zoh %} sysc = ss(A,B,C,D); sysd = c2d(sysc, ts, 'zoh'); [F G H I] = ssdata(sysd); %% Practice state of target for i = 1:T-1 x(:,i+1) = F*x(:,i); end x = x+G*w; % State variable with noise z = H*x+I*v; % Measurement value with noise %%==================================== %%% Kalman Filter for i = 1:T-1 %% Prediction phase x_hat(:,i+1) = F*x_hat(:,i); % State estimate predict P(:,:,i+1) = F*P(:,:,i)*F'+G*Q*G'; % Tracking error covariance predict P_predicted(:,:,i+1) = P(:,:,i+1); %% Kalman gain K = P(:,:,i+1)*H'*inv(H*P(:,:,i+1)*H'+R); %% Updata step x_hat(:,i+1) = x_hat(:,i+1)+K*(z(:,i+1)-H*x_hat(:,i+1)); % State estimate update P(:,:,i+1) = P(:,:,i+1)-K*H*P(:,:,i+1); % Tracking error covariance update P_updated(:,:,i+1) = P(:,:,i+1); end %%==================================== %% Estimate error x_error = x-x_hat; %% Graph 1 practical and tracking position figure(1) plot(x(1,:),x(3,:),'r'); hold on; plot(x_hat(1,:),x_hat(3,:),'g.'); title('2D Target Position') legend('Practical Position','Tracking Position') xlabel('X axis [m]') ylabel('Y axis [m]') hold off; %% Graph 2 figure(2) plot(t,x(1,:)),grid on; hold on; plot(t,x_hat(1,:),'r'),grid on; title('Practical and Tracking Position on X axis') legend('Practical Position','Tracking Position') xlabel('Time [sec]') ylabel('Position [m]') hold off; %% Graph 3 figure(3) plot(t,x_error(1,:)),grid on; title('Position Error on X axis') xlabel('Time [sec]') ylabel('Position RMSE [m]') hold off; %% Graph 4 figure(4) plot(t,x(2,:)),grid on; hold on; plot(t,x_hat(2,:),'r'),grid on; hold on; plot(t,x_error(2,:), 'g'),grid on; title('Practical and Tracking Velocity on X axis') legend('Practical Velocity','Tracking Velocity', 'Velocity Error') xlabel('Time [sec]') ylabel('Velocity [m/sec]') hold off; %% Graph 5 figure(5) plot(t,x_error(2,:)),grid on; title('Velocity Error on X axis') xlabel('Time [sec]') ylabel('Velocity RMSE [m/sec]') hold off; %%==================================== |