卡尔曼滤波程序

合集下载

卡尔曼滤波 参数

卡尔曼滤波 参数

卡尔曼滤波参数卡尔曼滤波(Kalman Filter)是一种利用系统的动态模型、观测数据和概率统计方法进行状态估计的算法。

它由美国科学家Rudolf E. Kálmán于1960年提出,被广泛应用于航天、航空、导航、机器人等领域。

卡尔曼滤波是一种最优的线性滤波器,它通过考虑系统模型和测量数据的不确定性来估计系统的最优状态。

卡尔曼滤波的基本思想是利用历史数据和本次观测数据,并结合系统模型进行状态估计,并通过不确定性的协方差矩阵来表示估计值的精确度。

卡尔曼滤波的基本公式如下:1. 预测阶段:状态预测:$\hat{x}_{k|k-1} = F\hat{x}_{k-1|k-1} + Bu_{k-1}$协方差预测:$P_{k|k-1} = FP_{k-1|k-1}F^T + Q$2. 更新阶段:测量残差:$y_k = z_k - H\hat{x}_{k|k-1}$协方差残差:$S_k = HP_{k|k-1}H^T + R$卡尔曼增益:$K_k = P_{k|k-1}H^TS_k^{-1}$状态修正:$\hat{x}_{k|k} = \hat{x}_{k|k-1} + K_ky_k$协方差修正:$P_{k|k} = (I - K_kH)P_{k|k-1}$其中,$F$为状态转移矩阵,描述系统状态从上一个时刻到当前时刻的演变关系;$\hat{x}_{k|k-1}$为对状态的先验估计;$B$为控制输入矩阵,描述外部控制对状态的影响;$u_{k-1}$为上一个时刻的控制输入;$P_{k|k-1}$为对状态估计的先验协方差矩阵;$Q$为过程噪声的协方差矩阵,描述系统模型的不确定性;$H$为观测矩阵,描述观测数据和状态之间的关系;$z_k$为当前时刻的观测数据;$R$为观测噪声的协方差矩阵,描述观测数据的不确定性;$S_k$为协方差残差;$K_k$为卡尔曼增益;$y_k$为测量残差,表示观测数据和状态估计之间的差异;$\hat{x}_{k|k}$为对状态的后验估计,是基于观测数据进行修正后的状态估计;$P_{k|k}$为对状态估计的后验协方差矩阵。

卡尔曼滤波python代码

卡尔曼滤波python代码

卡尔曼滤波(Kalman Filter)简介与Python代码实现1. 引言卡尔曼滤波是一种用于估计系统状态的递归滤波算法,广泛应用于信号处理、机器人导航、控制系统等领域。

它通过对测量值和状态变量之间的关系进行建模,并结合过去的测量值和预测值来优化状态估计。

本文将介绍卡尔曼滤波的原理及其在Python中的实现。

首先,我们将详细解释卡尔曼滤波的数学模型,包括状态方程和观测方程。

然后,我们将给出一个简单的例子来演示如何使用Python编写卡尔曼滤波代码。

最后,我们会讨论一些常见的应用场景和改进方法。

2. 卡尔曼滤波原理2.1 系统模型卡尔曼滤波通过建立系统模型来描述状态变量和观测值之间的关系。

假设我们有一个线性动态系统,可以用以下状态方程表示:x(k) = F * x(k-1) + B * u(k-1) + w(k-1)其中,x(k)是在时间步k时刻的状态向量,F是状态转移矩阵,B是控制输入矩阵,u(k-1)是在时间步k-1时刻的控制向量,w(k-1)是过程噪声。

观测方程可以表示为:z(k) = H * x(k) + v(k)其中,z(k)是在时间步k时刻的观测向量,H是观测矩阵,v(k)是观测噪声。

2.2 状态估计卡尔曼滤波的目标是根据过去的测量值和预测值对系统状态进行估计。

它通过最小化预测误差的协方差来实现。

卡尔曼滤波包括两个主要步骤:预测和更新。

2.2.1 预测在预测步骤中,我们使用状态方程来预测下一个时间步的状态:x_hat(k|k-1) = F * x_hat(k-1|k-1) + B * u(k-1)P(k|k-1) = F * P(k-1|k-1) * F^T + Q其中,x_hat(k|k-1)是在时间步k时刻的状态预测值,P(k|k-1)是状态协方差矩阵(描述状态估计误差的不确定性),Q是过程噪声的协方差矩阵。

2.2.2 更新在更新步骤中,我们使用观测方程来校正预测值:K(k) = P(k|k-1) * H^T * (H * P(k|k-1) * H^T + R)^(-1)x_hat(k|k) = x_hat(k|k-1) + K(k) * (z(k) - H * x_hat(k|k-1))P(k|k) = (I - K(k) * H) * P(k|k-1)其中,K(k)是卡尔曼增益(用于校正预测值),R是观测噪声的协方差矩阵,I是单位矩阵。

卡尔曼滤波流程

卡尔曼滤波流程

卡尔曼滤波流程
《卡尔曼滤波流程》
一、定义
卡尔曼滤波(Kalman Filter)是一种统计预测和滤波方法,主要用于处理相关性比较强的信号,如温度、湿度等,以及状态空间和系统误差模型。

它可以通过及时处理采集的各种信息,来实现估算未知变量的值,以及突发变化时,及时调整预测状态。

二、流程
1、确定系统模型:在开始卡尔曼滤波之前,需要了解系统的模型,以及估计参数,并将其应用于卡尔曼滤波模型中,这样可以使滤波效果更加准确。

2、状态估计:在进行滤波时,首先需要进行状态估计,即估计系统的当前状态,并计算出状态估计误差协方差矩阵。

3、状态跟踪:此时,卡尔曼滤波模型将状态估计和观测到的信息进行结合,从而获得更准确的状态跟踪,此时可以计算出滤波误差协方差矩阵。

4、状态更新:当系统状态有改变时,根据新状态更新预测状态,并重新计算状态估计误差协方差矩阵。

三、优点
1、可以有效的提高采样的概率密度函数;
2、具有能够进行自我调整以适应改变环境和数据质量的能力;
3、可以准确预测系统,从而及时处理数据。

四、缺点
1、在系统估计过程中,系统模型变化较快时,容易引起状态漂移,导致估计结果不准确;
2、对滤波器参数要求较高,若参数设置不合理,会影响滤波器的性能;
3、若在观测器或系统模型中存在非线性,则卡尔曼滤波也无法进行优化。

c语言卡尔曼滤波算法

c语言卡尔曼滤波算法

c语言卡尔曼滤波算法卡尔曼滤波算法是一种用于估计系统状态的优秀方法。

它广泛应用于各种领域,如导航、控制系统、信号处理等。

本文将为您介绍卡尔曼滤波算法的基本原理和应用。

一、什么是卡尔曼滤波算法?卡尔曼滤波算法由卡尔曼于1960年提出,是一种递归的状态估计算法。

它基于贝叶斯滤波理论,通过将先验信息和测量信息进行融合,得到对系统状态的最优估计。

二、卡尔曼滤波算法的基本原理卡尔曼滤波算法基于线性系统模型,可以分为两个步骤:预测和更新。

1. 预测步骤:利用系统的动力学模型和上一时刻的状态估计,预测当前时刻的系统状态。

2. 更新步骤:利用测量模型和当前时刻的测量值,结合预测步骤的结果,更新当前时刻的状态估计。

通过不断迭代预测和更新步骤,卡尔曼滤波算法可以逐步优化对系统状态的估计。

三、卡尔曼滤波算法的应用卡尔曼滤波算法在导航系统中有广泛应用。

例如,在无人机导航中,通过融合惯性测量单元(IMU)和全球定位系统(GPS)的信息,可以实现对无人机位置和姿态的精确估计。

在自动驾驶领域,卡尔曼滤波算法也被广泛使用。

通过融合激光雷达、摄像头和雷达等传感器的数据,可以实现对车辆位置、速度和周围环境的准确感知。

卡尔曼滤波算法还可以用于图像处理、信号处理等领域。

例如,通过对图像序列进行卡尔曼滤波,可以实现图像去噪和运动目标跟踪等任务。

四、总结卡尔曼滤波算法是一种强大而有效的状态估计方法。

它通过融合先验信息和测量信息,可以得到对系统状态的最优估计。

卡尔曼滤波算法在导航、控制系统和信号处理等领域有着广泛的应用。

它的优势在于对线性系统模型的适用性和高效的计算性能。

希望通过本文的介绍,您对卡尔曼滤波算法有了更深入的了解。

相信在实际应用中,卡尔曼滤波算法将会为您带来更好的效果。

Kalman滤波原理及算法

Kalman滤波原理及算法

Kalman滤波原理及算法kalman滤波器一(什么是卡尔曼滤波器卡尔曼全名Rudolf Emil Kalman,匈牙利数学家,1930年出生于匈牙利首都布达佩斯, 我们现在要学习的卡尔曼滤波器,正是源于他的博士论文和1960年发表的论文《A New Approach to Linear Filtering and Prediction Problems》(线性滤波与预测问题的新方法)。

二.卡尔曼滤波器算法的介绍以下是卡尔曼滤波器核心的5个式子。

X(k|k-1)=A X(k-1|k-1)+B U(k) (1)P(k|k-1)=A P(k-1|k-1) A’+Q (2)X(k|k)= X(k|k-1)+Kg(k) (Z(k)-H X(k|k-1)) (3)Kg(k)= P(k|k-1) H’ / (H P(k|k-1) H’ + R) (4)P(k|k)=(I-Kg(k) H)P(k|k-1) (5)下面我们详细介绍卡尔曼滤波的过程。

首先,我们要引入一个离散控制过程的系统。

该系统可用一个线性随机微分方程来描述: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来估算系统的最优化输出。

首先我们要利用系统的过程模型,来预测下一状态的系统。

卡尔曼滤波计算举例全

卡尔曼滤波计算举例全

卡尔曼滤波计算举例⏹计算举例⏹卡尔曼滤波器特性假设有一个标量系统,信号与观测模型为[1][][]x k ax k n k +=+[][][]z k x k w k =+其中a 为常数,n [k ]和w [k ]是不相关的零均值白噪声,方差分别为和。

系统的起始变量x [0]为随机变量,其均值为零,方差为。

2nσ2σ[0]x P (1)求估计x [k ]的卡尔曼滤波算法;(2)当时的卡尔曼滤波增益和滤波误差方差。

220.9,1,10,[0]10nx a P =σ=σ==1. 计算举例根据卡尔曼算法,预测方程为:ˆˆ[/1][1/1]xk k ax k k -=--预测误差方差为:22[/1][1/1]x x nP k k a P k k -=--+σ卡尔曼增益为:()1222222[][/1][/1][1/1][1/1]x x x nx n K k P k k P k k a P k k a P k k -=--+σ--+σ=--+σ+σˆˆˆ[/][/1][]([][/1])ˆˆ[1/1][]([][1/1])ˆ(1[])[1/1][][]xk k x k k K k z k x k k axk k K k z k ax k k a K k xk k K k z k =-+--=--+---=---+滤波方程:()()2222222222222[/](1[])[/1][1/1]1[1/1][1/1][1/1][1/1]x x x nx n x n x nx nP k k K k P k k a P k k a P k k a P k k a P k k a P k k =--⎛⎫--+σ=---+σ ⎪--+σ+σ⎝⎭σ--+σ=--+σ+σ滤波误差方差起始:ˆ[0/0]0x=[0/0][0]x x P P =k [/1]x P k k -[/]x P k k []K k 012345689104.76443.27012.67342.27652.21422.18362.16832.16089.104.85923.64883.16542.94752.84402.79352.76870.47360.32700.26730.24040.22770.22140.21840.2168ˆ[0/0]0x=[0/0]10x P =220.9110na =σ=σ=2. 卡尔曼滤波器的特性从以上计算公式和计算结果可以看出卡尔曼滤波器的一些特性:(1)滤波误差方差的上限取决于测量噪声的方差,即()2222222[1/1][/][1/1]x nx x na P k k P k k a P k k σ--+σ=≤σ--+σ+σ2[/]x P k k ≤σ这是因为(2)预测误差方差总是大于等于扰动噪声的方差,即2[/1]x nP k k -≥σ这是因为222[/1][1/1]x x n nP k k a P k k -=--+σ≥σ(3)卡尔曼增益满足,随着k 的增加趋于一个稳定值。

卡尔曼滤波步骤

卡尔曼滤波步骤

卡尔曼滤波步骤
卡尔曼滤波是一种用于估计系统状态的算法,它可以通过观测数据和系统模型来预测未来状态,并根据观测数据进行修正。

下面将介绍卡尔曼滤波的步骤。

1. 系统建模
卡尔曼滤波的第一步是建立系统模型,包括状态方程和观测方程。

状态方程描述系统的状态如何随时间变化,观测方程描述如何从系统状态中得到观测数据。

这些方程需要根据具体问题进行建立。

2. 初始化
卡尔曼滤波需要一个初始状态,通常可以通过观测数据进行估计。

如果没有观测数据,可以使用先验知识或者猜测来初始化。

3. 预测
在卡尔曼滤波中,预测是指根据系统模型和当前状态估计未来状态。

预测的结果是一个状态向量和协方差矩阵,它们描述了状态的不确定性。

4. 更新
更新是指根据观测数据修正预测结果。

更新的结果是一个新的状态向量和协方差矩阵,它们描述了状态的更精确的估计。

5. 迭代
卡尔曼滤波是一个迭代过程,每次迭代都会进行预测和更新。

预测使用上一次的状态向量和协方差矩阵,更新使用当前的观测数据。

迭代次数取决于具体问题和算法的收敛速度。

6. 输出
卡尔曼滤波的输出是一个状态向量和协方差矩阵,它们描述了系统状态的估计和不确定性。

这些结果可以用于控制、决策或者其他应用。

总结
卡尔曼滤波是一种强大的估计算法,它可以用于各种应用,如导航、控制、信号处理等。

卡尔曼滤波的步骤包括系统建模、初始化、预测、更新、迭代和输出。

这些步骤需要根据具体问题进行调整和优化,以获得更好的估计结果。

卡尔曼滤波算法流程

卡尔曼滤波算法流程

卡尔曼滤波算法流程
1.初始化:设定系统的初始状态和协方差矩阵,以及系统模型的初始
参数。

2.预测步骤(时间更新):
-通过系统模型和上一时刻的状态估计值,预测当前时刻的状态,并
计算预测的状态协方差。

-根据预测的状态和测量方差,计算预测的测量值。

3.更新步骤(测量更新):
-通过测量值和测量方差,计算测量的残差(测量残差是测量值与预
测值之间的差异)。

-计算测量残差的协方差。

-计算卡尔曼增益(卡尔曼增益是预测误差和测量残差之间的比例关系)。

-通过卡尔曼增益,对预测值进行修正,得到当前时刻的最优状态估
计值。

-更新状态估计值的协方差。

4.循环迭代:将预测和更新步骤循环进行,逐步逼近真实的系统状态。

整个卡尔曼滤波的核心是通过不断的预测和更新来修正状态估计值,
从而逼近真实的系统状态。

其基本思想是根据测量值和预测值的权重建立
一个最优估计,同时考虑了预测的误差和测量的误差。

通过不断地迭代,
可以实现对系统状态的准确估计。

卡尔曼滤波广泛应用于图像处理、机器人导航、信号处理等领域。


优势在于能够对噪声和不确定性进行有效的处理,同时具有较低的计算复
杂度。

但是,卡尔曼滤波的有效性还取决于系统模型和测量噪声的准确性,因此在实际应用中需要进行参数调整和误差分析。

总之,卡尔曼滤波是一种通过预测和更新来估计系统状态的最优算法,通过结合系统模型和测量方差信息,能够有效处理噪声和不确定性,广泛
应用于估计问题中。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

最佳线性滤波理论起源于40年代美国科学家Wiener和前苏联科学家Kолмогоров等人的研究工作,后人统称为维纳滤波理论。

从理论上说,维纳滤波的最大缺点是必须用到无限过去的数据,不适用于实时处理。

为了克服这一缺点,60年代Kalman把状态空间模型引入滤波理论,并导出了一套递推估计算法,后人称之为卡尔曼滤波理论。

卡尔曼滤波是以最小均方误差为估计的最佳准则,来寻求一套递推估计的算法,其基本思想是:采用信号与噪声的状态空间模型,利用前一时刻地估计值和现时刻的观测值来更新对状态变量的估计,求出现时刻的估计值。

它适合于实时处理和计算机运算。

现设线性时变系统的离散状态防城和观测方程为:X(k) = F(k,k-1)·X(k-1)+T(k,k-1)·U(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时刻观测噪声则卡尔曼滤波的算法流程为:1.预估计X(k)^= F(k,k-1)·X(k-1)2.计算预估计协方差矩阵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)'3.计算卡尔曼增益矩阵K(k) = C(k)^×H(k)'×[H(k)×C(k)^×H(k)'+R(k)]^(-1)R(k) = N(k)×N(k)'4.更新估计X(k)~=X(k)^+K(k)×[Y(k)-H(k)×X(k)^]5.计算更新后估计协防差矩阵C(k)~ = [I-K(k)×H(k)]×C(k)^×[I-K(k)×H(k)]'+K(k)×R(k)×K(k)' 6.X(k+1) = X(k)~C(k+1) = C(k)~重复以上步骤其c语言实现代码如下:#include "stdlib.h"#include "rinv.c"int lman(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++)}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++)}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);}C++实现代码如下:============================kalman.h================= ===============// kalman.h: interface for the kalm an class.////////////////////////////////////////////////////////////////////////#if !defined(AFX_KALMAN_H__ED3D740F_01D2_4616_8B74_8BF57636F2C0__IN CLUDED_)#define AFX_KALMAN_H__ED3D740F_01D2_4616_8B74_8BF57636F2C0__INCLU DED_#if _MSC_VER > 1000#pragma once#endif// _MSC_VER > 1000#include <math.h>#include "cv.h"class kalman{public:void init_kalman(int x,int xv,int y,int yv);CvKalman* cvkalman;CvMat* state;CvMat* process_noise;CvMat* m easurem ent;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();};#endif// !defined(AFX_KALMAN_H__ED3D740F_01D2_4616_8B74_8BF57636F2C 0__INCLUDED_)============================kalman.cpp=============== =================#include "kalman.h"#include <stdio.h>/* tester de printer toutes les valeurs des vecteurs*//* tester de changer les matrices du noises *//* replace state by cvkalman->state_post ??? */CvRandState rng;const double T = 0.1;kalman::kalman(int x,int xv,int y,int yv){cvkalm an = cvCreateKalman( 4, 4, 0 );state = cvCreateMat( 4, 1, CV_32FC1 );process_noise = cvCreateMat( 4, 1, CV_32FC1 );m easurement = cvCreateMat( 4, 1, CV_32FC1 );int code = -1;/* create m atrix 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( m easurement );cvRandSetRange( &rng, 0, 0.1, 0 );rng.disttype = CV_RAND_NORMAL;cvRand( &rng, state );m em cpy( cvkalman->transition_matrix->data.fl, A, sizeof(A));m em cpy( cvkalman->measurement_m atrix->data.fl, H, sizeof(H));m em cpy( cvkalman->process_noise_cov->data.fl, Q, sizeof(Q));m em cpy( cvkalman->error_cov_post->data.fl, P, sizeof(P));m em cpy( 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( cvkalm an->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;cvkalm an->state_post->data.fl[0]=x;cvkalm an->state_post->data.fl[1]=xv;cvkalm an->state_post->data.fl[2]=y;cvkalm an->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鈥 kP'k=A鈥 k-1*AT + Q */cvRandSetRange( &rng, 0, sqrt(cvkalman->measurem ent_noise_cov->data.fl [0]), 0 );cvRand( &rng, m easurement );/* xk=A?xk-1+B?uk+wk */cvMatMulAdd( cvkalman->transition_matrix, state, process_noise, cvkalm an->state_post );/* zk=H?xk+vk */cvMatMulAdd( cvkalman->measurement_matrix, cvkalman->state_post, m eas urement, m easurement );/* adjust Kalman filter state *//* Kk=P'k鈥 T鈥?H鈥 'k鈥 T+R)-1xk=x'k+Kk鈥?zk-H鈥 'k)Pk=(I-Kk鈥 )鈥 'k */cvKalmanCorrect( cvkalman, measurement );float m easured_value_x = m easurem ent->data.fl[0];float m easured_value_y = m easurem ent->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;cvkalm an->state_post->data.fl[0]=x;cvkalm an->state_post->data.fl[1]=xv;cvkalm an->state_post->data.fl[2]=y;cvkalm an->state_post->data.fl[3]=yv;}。

相关文档
最新文档