1 Source Part

Firstly,we must to get a signal source by creating a uniform random generator.also some other random number,such as normal distribution.

using VC++6.0

In order to solve the reproduce of the first circle of creating uniform,we choice time( include in 'ctime' library) as the seed of rand().

1) srand((unsigned)time(NULL))

2) time_t t; 
   srand((unsigned) time(&t));

3) srand(static_cast<unsigned>(time(static_cast<time_t *>(NULL))));

typical application:

include the follow header files:<iostream><iomanip><cstdlib><ctime>

A: 

double randomdouble()  // creating 0-1 uniform distribution.

{

   return(rand()/(static_cast<double>(RAND_MAX)+1));

}

B:

4-digit precision.

double AverageRandom(double min,double max)
　　　　{
　　　　int minInteger = (int)(min*10000);
　　　　int maxInteger = (int)(max*10000);
　　　　int randInteger = rand()*rand();
　　　　int diffInteger = maxInteger - minInteger;
　　　　int resultInteger = randInteger % diffInteger + minInteger;
　　　　return resultInteger/10000.0;
　　　　}

double dValue[400];
　　　　srand(GetTickCount());
　　　　for(int i= 0;i < 400; i++)
　　　　{
　　　　double dValue[i] = AverageRandom(-1,1);
　　　　}

we must pay attention to the refresh frequency of the computer,approximate 55ms.

so often let the srand(GetTickCount()) outside of the circle.

in order to get binary value,using binary_value=(dvalue>=0.5).

if you want to using normal random number,we can using the below program.

从图中可以看出，在μ附近的概率密度大，远离μ的地方概率密度小，我们要产生的随机数要服从这种分布，就是要使产生的随机数在μ附近的概率要大，远离μ处小，怎样保证这一点呢，可以采用如下的方法：在图2的大矩形中随机产生点，这些点是平均分布的，如果产生的点落在概率密度曲线的下方，则认为产生的点是符合要求的，将它们保留，如果在概率密度曲线的上方，则认为这些点不合格，将它们去处。如果随机产生了一大批在整个矩形中均匀分布的点，那么被保留下来的点的横坐标就服从了正态分布。可以设想，由于在μ处的f(x)的值比较大，理所当然的在μ附近的点个数要多，远离μ处的少，这从面积上就可以看出来。我们要产生的随机数就是这里的横坐标。(转贴 http://www.vckbase.com/document/viewdoc/?id=1424任意分布的随机数的产生方法-VC程序实现方法)

solution 1

double Normal(double x,double miu,double sigma) //normal distribution pdf
　　　　{
　　　　return 1.0/sqrt(2*PI*sigma) * exp(-1*(x-miu)*(x-miu)/(2*sigma*sigma));
　　　　}
　　　　double NormalRandom(double miu,
　　　　　　　　　double sigma,double min,double max)//generate normal random number.
　　　　{
　　　　double x;
　　　　double dScope;
　　　　double y;
　　　　do
　　　　{
　　　　x = AverageRandom(min,max);
　　　　y = Normal(dResult, miu, sigma);
　　　　dScope = AverageRandom(0, Normal(miu,miu,sigma));
　　　　}while( dScope > y);
　　　　return x;
　　　　}

solution 2

refer to <<Numerical recipes in c++ >> pp292-294   <<simulation modeling and analysis>> pp465-466

if the u1,u2 is uniform random at range (0,1),and independently.

x1=sqrt(-2*log(u1))*cos(2*pi*u2);

x2=sqrt(-2*log(u1))*sin(2*pi*u2);   x1,x2 is normal distribution.

and also independently.

 some other RNG introduce(Professor Pingzhi Fan collected):

1 LCG U(0,1),introduced by Lehmer(1951)

  Z(i)=(a*Z(i-1)+c)(mod m), satisfy 0<m,a<m,c<m,and Z(0)<m;

  "Few good men"(for 32 bit machines):Z(i)=(16807*Z(i-1))(mod(pow(2,31)-1)),Z(i)=(69069*Z[i-1]+1)(mod(pow(2,32))).

2 Practical U(0,1) Generators

  #include <stdio.h>  %Developed by George Marsaglia,1999.

  #define znew (z=36969*(z&65535)+(z>>16))

  #define wnew (w=18000*(w&65535)+(w>>16))

  #define MWC ((znew<<16)+wnew)

  #define SHR3 (jsr^=(jsr<<17),jsr^=(jsr>>13),jsr^=(jsr<<5))

  #define CONG (jcong=69069*jcong+1234567))

  #define FIB ((b=a+b),(a=b-a))

  #define KISS ((MWC^CONG)+SHR3)

  #define LFIB4 (c++,t[c]=t[c]+t[UC(c+58)]+t[UC(c+119)]+t[UC(c+178)])

  #define SWB   (c++,bro=(x<y),t[c]=(x=t[UC(c+34)])-(y=t[UC(c+19)]+bro))

  #define UNI (KISS*2.328306e-10)

  #define VNI ((long)KISS)*4.656613e-10

  #define UC (unsigned char)  // a cast operation

  type unsigned long UL;

// Global static variables

static UL z=362436069,w=521288629,jsr=123456789,jcong=380116160;

static UL a=224466889,b=7584631,t[256];

// useing random seeds to reset z,w,jsr,jcong,a,b,and the table t[256]

static UL x=0,y=0,bro;

static unsigned char c=0;

// example procedure to set the table using KISS

void settable(UL i1,UL i2,UL i3,UL i4,UL i5,UL i6)

{  int i; z=i1;w=i2,jsr=i3;jcong=i4;a=i5;b=i6;

for(i=0;i<256;i=i+1) t[i]=KISS;

}

// this is a test main program

int main(void)

{

  int i; UL k;

settable(12345,65435,34221,12345,9983651,95746118);

for(i=1;i<100000;i++){k=LFIB4;}

printf("%u/n",k-1064612766U);

......

Using UNI produce uniform random real in (0,1),while VNI will produce in (-1,1);

3 Uniform Distribute R.V.U(a,b)(Inverse-Transform Method)

  1) Generate U--U(0,1).

  2) Return x=a+(b-a)U.

4 Exponential Distributin R.V.Expo(beta)(Inverse_Transform Method)

  1).Generate U--U(0,1);

  2).Return X=-beta*ln(1-U).

5 Normal Distribution N(0,1)  Marsaglia-Bray Polar Method(1965)

  1.Generate U1 and U2 as IID U(0,1);let Vi=2Ui-1 for i=1,2;and let W=V1^2+V2^2.

  2.If W>1,go back to step 1.Otherwise let Y=Sqrt((-2lnW)/W),X1=V1Y,and X2=V2Y.Then X1 and X2 are IID N(0,1)random variates.

  since a rejection of U1 and U2 can occur in step 2(with probability 1-Pi/4),the polar method will require a random number of U(0,1) random variables to generate each pair of N(0,1)random variates.

 X'=u+lu*X,X--N(0,1),X'--(u,lu^2).

6 Normal N(0,1) Box-Muller Method(1958)

  1) Generate U1 and U2 as IID U(0,1).

  2) Return X1=sqrt(-2lnU1)cos(2*pi*U2) and X2=sqrt(-2lnU1)sin(2*pi*U2).

  however,if U2 depends on U1 such as two adjacent random numbers produced by LCG(not truly IID U(0,1)r.v),two N(0,1)are not IID,therefore,it is not as good as polar method.

7 Lognormal Distribution LN(u,lu^2)

  1) Generate Y--N(u,lu^2).

  2) Return X=e^Y.

8 Normal Distribution

  sum-of-12 method:

  1) Generate U1,U2,....U12 as 12 IID U(1,1).

  2) Return X=(U1+U2+..U12)-6.0.

9 Rayleigh/Rice

  Rayleigh distribution

  1) Generate Y1--N(0,1),Y2--N(0,1);

  2) Return X=Sqrt(Y1^2+Y2^2).

  Rice distribution

  2) Generate Y1--N(0,1),Y2--N(0,1);

  2) Return X=sqrt((A+Y1)^2+Y2^2).

Generating Source based on VC++6.0(allowing to learn,but prohibit to spread it on the Internet without permission)

// Here we generate source of '0' and '1',in order to
// in order to satisfy other circumstance,we program a
// generic program,which can produce uniform at(min,max).
#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <ctime>
#include <cmath>
using namespace std;

void randint(int a[],int n,int min,int max)
{
 int i;
 double randdouble;
 srand((unsigned)time(NULL));
 if(min==0&&max==1)
      for(i=0;i<n;i++)
  a[i]=(rand()/(static_cast<double>(RAND_MAX)+1))>=0.5;
    
    else
 {
  for(i=1;i<n;i++)
  {
     randdouble=rand()/(static_cast<double>(RAND_MAX)+1);
        a[i]=(max-min)*(randdouble>=0.5)+min;
  }
 }

}

void main()  //测试函数
{
  int i,min=0,max=1;
  int a[10];
  int n=10;
  randint(a,n,min,max);
  for(i=0;i<10;i++)
   cout<<a[i]<<endl;
}

2 Mapping

common.h

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <ctime>
#include <cmath>

VC6.0++ contain the header file complex.h,so we can using it to generate complex variable.

also we can definite an struct.

for example:

struct complex
{
 double real;
 double imag;
};

some test of complex variable.

#include <iostream>
#include <complex>
#include <cmath>
using namespace std;

struct A
{
 int a;
 char b;
 
 A::A(int i,char c)
 {
  a = i;
  b = c;
 }
};
/*ostream& operator<<(ostream& os, const A& obj)
{
 os<<obj.a<<" "<<obj.b<<endl;
 return os;
}*/

void main()
{
 complex<double> aa(3,4);
 complex<double> bb(3,4);
 complex<double> cc = aa*bb;
 
 cout<<cc;
 
 A abc(3,'d');
/* cout<<abc<<"adfasd";*/
 cout<<cc.real()<<" "<<cc.imag()<<endl;
}

/*struct complex
{
   double real;
   double imag;
}

class complex
{
   private:
   double _real;
   double _image;

   public:
   double real()  { return _real; }
   double imag()  { return _imag; }
} */

// simulate the modulation.
// here we only consider BPSK,QPSK,16QAM,Constellation
// use constant CL as the number of the above constellation.
// CL is declare at the main()

#include "common.h"

void randint(char a[],int n,int min,int max);
void mapping(char a[],struct complex symb[],int n,int CL);

using namespace std;

struct complex
{
 double real;
 double imag;
};

void mapping(char a[],struct complex symb[],int n,int CL)   // Digital modulation,
{                                                           // you can modify it to satisfy your
 int i,j=0;                                                // requirements
    
 switch(CL)
 {
    case 2:// choice BPSK.
     {
      for(i=0;i<n;i++)
      {
       switch(a[i])
       {
       case '1':
        {symb[j].real=-1.0;
        symb[j++].imag=0.0;
        break;
        }
       case '0':
        {symb[j].real=1.0;
        symb[j++].imag=0.0;
        break;
        }
       default:
        cout<<"Binary Source Error!"<<endl;
        break;
       }
      }
      break;
     }
    case 4: // choice QPSK.
     {
      for(i=0;i<n;i=i+2)
      {
       switch((a[i]-48)*2+(a[i+1]-48))
       {
       case 0:
        {symb[j].real=1.0;
        symb[j++].imag=1.0;
        break;
        }
       case 1:
        {symb[j].real=1.0;
        symb[j++].imag=-1.0;
        break;
        }
       case 2:
        {symb[j].real=-1.0;
        symb[j++].imag=1.0;
        break;
        }
       case 3:
        {symb[j].real=-1.0;
        symb[j++].imag=-1.0;
        break;
        }
       default:
        cout<<"Binary Source Error!"<<endl;
        break;
       }
      }
      break;
     }
    default:
     cout<<"You input a wrong integer!"<<endl;
 }
}

void main()                  // test function
{
 int i,min=0,max=1;          // 变量定义
 struct complex symb[20];
 int CL=4;
 char ch[20];
 int n=20;
 
 randint(ch,n,min,max);     // 调用随机数的产生
 
 for(i=0;i<20;i++)         // 查看产生的二进制符号是否正确
  cout<<ch[i]<<endl;
 
 mapping(ch,symb,n,CL);  // 调用符号映射子函数
 
 for(i=0;i<10;i++)                                    // 查看输出的映射符号是否正确
 {
  cout<<symb[i].real<<"+j"<<symb[i].imag<<endl;
 }

}

(待续....)

又到了新的一年，总感觉有点茫茫然，都不知道有多长时间没有这样的空闲了，想来总该做的什么。

说起来这个春节家里人都过的不是怎么好，遇到的这些事让我时刻都惦记老爸老妈，想以前，从来都不曾帮他们想想问题。连他们要求的每个月给家里一次电话都没有做到，家里就我和我哥，我妈常说要是有个女儿该有多好，说女儿贴心。想来也确实是这样，每次我能和妈说什么心里话呢，她的心里话又找谁说呢。每次电话回去都是催我要尽快解决个人问题，注意身体，没有钱花了一定要跟家里说，要吃好，不要苦了自己，注意安全，晚上不要一个人出去。对他们来说我过的好就是他们的最大的安慰了。

记忆中，我爸就哭过一次，也就是这个春节我妈在雪地里摔倒，伤的很严重。在电话里他哽噎了。幸好检查没有什么问题，我妈哭了，她说的是如果有什么问题她怕拖累我们，如果这样她还不如就这样去了。听了这话心里都不知道是什么滋味。

以前对于圣经就一直反感，或许可以作为老年时的精神寄托。什么事情都那上帝来做解释，时刻审视自己的罪恶。从中充斥了很多的人类的原罪论，如杀兄弃弟等。因为世间的罪恶，所以上帝采用大灾难来洗涤灵魂的罪恶。事先给予虔诚信徒以启示。在这样的情况下，很多的自然灾害就有了合理的解释。

很早以前就听说过《忏悔录》，经过千多年还闪烁着智慧的火花。由于时间问题只看了一部分，很多对自己内心世界的剖析，有对善恶来源的追寻，有对上帝的忏悔。“我年轻时一度狂热追求的满足只不过是地域的快乐”，“这时我所喜欢的还不过是爱与被爱”，“最高的存在亦即最高的生命”，“人生是迈向死亡的生命或是生命的死亡”。个人认为对生命形式，对善恶，对存在等进行分析是需要一定条件的，对于今社会也不例外，得拥有很好的物质条件。如果说文章以经世济用为标准，貌似对于年青人来说没有现实的意义。

做技术的最大的误区就是陷入技术维上，这也是我们必须跳出的观点。以前给自己定位的目标就是技术牛人。打通DSP 单片机 FPGA VC。看了这个报告集才发现还有很多市场规则需要学习，得尽早为自己规划学习一下经济方面的理论知识了。认认真真做事，踏踏实实做人。一个人最难的就在于细致努力做好每一件事。就行血色烂漫-玫瑰绽放里姜士安说的，“对自己的要求一直就是，把该我干的事情干好。对上，让上级放心，不能一件事交给你，后面跟着七八个工作组收拾。对下，让下级信任，觉得跟着你干有前途、有价值。”

现设线性时变系统的离散状态防城和观测方程为：

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时刻观测噪声

则卡尔曼滤波的算法流程为：

C语言实现Kalman：

#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 )  

  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);  }

C 实现Kalman：

============================kalman.h================================

// kalman.h: interface for the kalman class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_KALMAN_H__ED3D740F_01D2_4616_8B74_8BF57636F2C0__INCLUDED_)
#define AFX_KALMAN_H__ED3D740F_01D2_4616_8B74_8BF57636F2C0__INCLUDED_

#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* 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();


};

#endif // !defined(AFX_KALMAN_H__ED3D740F_01D2_4616_8B74_8BF57636F2C0__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)
{     
    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;
}