kalman_UKF.cpp

Here we use an example with a nonlinear measurement function. The x and y values are measured by a distance and an elevation, giving a nonlinear measure function h(x)=[sqrt(x^2+y^2),atan(y,x)]. The function vector/matrix is specified using a lambda function wrapped into a convenience macro; FCN_XUW

Output

True, measured and predicted states

Acceleration in X and Y

Error covariance

Source

#include "sigpack.h"

using namespace std;
using namespace sp;
int main()
{
  // Number of samples
  arma::uword Nsamp = 120;
  arma::uword N     = 6; // Nr of states [X,Y,Vx,Vy,Ax,Ay]
  arma::uword M     = 2; // Nr of measurements
  arma::uword L     = 0; // Nr of inputs

  //    // Instatiate a Extended Kalman Filter
  //    EKF kalman(N,M,L);
  // Instatiate an Unscented Kalman Filter
  UKF kalman(N, M, L);

  // Initialisation and setup of system
  double P0 = 50;
  double Q0 = 0.001;
  double R0 = 8;

  // Meas interval
  double dT = 0.1;

  // [X,Y,Vx,Vy,Ax,Ay] 2D position, velocity and acceleration as states
  arma::mat x = {0, 5, 10, 50, -0.5, -9.8};
  arma::inplace_trans(x);
  arma::mat x_init(x * 0.5); // Init state as 50% of actual value
  kalman.set_state_vec(x_init);

  // Set transition function
  arma::mat A = {{1, 0, dT, 0, dT * dT / 2, 0},
                 {0, 1, 0, dT, 0, dT * dT / 2},
                 {0, 0, 1, 0, dT, 0},
                 {0, 0, 0, 1, 0, dT},
                 {0, 0, 0, 0, 1, 0},
                 {0, 0, 0, 0, 0, 1}};
  kalman.set_trans_mat(A);
  //    fcn_t f0 = FCN_XUW{ return x(0)+x(2)*dT+x(4)*dT*dT/2; };
  //    fcn_t f1 = FCN_XUW{ return x(1)+x(3)*dT+x(5)*dT*dT/2; };
  //    fcn_t f2 = FCN_XUW{ return x(2)+x(4)*dT; };
  //    fcn_t f3 = FCN_XUW{ return x(3)+x(5)*dT; };
  //    fcn_t f4 = FCN_XUW{ return x(4); };
  //    fcn_t f5 = FCN_XUW{ return x(5); };
  //    fcn_v  f = {f0,f1,f2,f3,f4,f5};
  //    kalman.set_trans_fcn(f);

  // Set process noise
  arma::mat Q = Q0 * arma::diagmat(arma::vec("1 1 0.1 0.1 0.01 0.01"));
  kalman.set_proc_noise(Q);

  // Nonlinear measurement function
  fcn_t h0 = FCN_XUW { return sqrt(x(0) * x(0) + x(1) * x(1)); };
  fcn_t h1 = FCN_XUW { return atan2(x(1), x(0)); };
  fcn_v h  = {h0, h1};
  kalman.set_meas_fcn(h);

  // Nonlinear measurement jacobian - analytical
  //    fcn_t h_zero   = FCN_XUW{ return 0; };
  //    fcn_t h00_j    = FCN_XUW{ return x(0)/sqrt(x(0)*x(0)+x(1)*x(1)); };
  //    fcn_t h01_j    = FCN_XUW{ return x(1)/sqrt(x(0)*x(0)+x(1)*x(1)); };
  //    fcn_t h10_j    = FCN_XUW{ return -x(1)/(x(0)*x(0)+x(1)*x(1)); };
  //    fcn_t h11_j    = FCN_XUW{ return x(0)/(x(0)*x(0)+x(1)*x(1)); };
  //  fcn_m h_jac =
  //  {
  //        {h00_j,h01_j,h_zero,h_zero,h_zero,h_zero},
  //        {h10_j,h11_j,h_zero,h_zero,h_zero,h_zero}
  //  };
  //  kalman.set_meas_jac(h_jac);

  // Error cov
  arma::mat P = P0 * arma::eye<arma::mat>(N, N);
  kalman.set_err_cov(P);

  // Meas noise  (for distance and angle)
  arma::mat R = {{1, 0}, {0, 0.005}};
  R *= R0;
  kalman.set_meas_noise(R);

  // Create simulation data
  arma::mat z(M, Nsamp, arma::fill::zeros);
  arma::mat z0(M, Nsamp, arma::fill::zeros);
  for (arma::uword n = 0; n < Nsamp; n++)
  {
    arma::mat v0(N, 1, arma::fill::zeros);

    // Update state
    x = A * x + Q * arma::randn(N, 1);

    // Update measurement
    z0(0, n) = x(0);
    z0(1, n) = x(1);

    // Add meas noise
    z.col(n) = eval_fcn(h, z0.col(n)) + 0.5 * R * arma::randn(M, 1);
  }

  arma::mat xhat_log(N, Nsamp);
  arma::mat e_log(M, Nsamp);
  arma::cube P_log(N, N, Nsamp);
  arma::mat xs_log(M, Nsamp);
  arma::cube Ps_log(N, N, Nsamp);
  arma::cube K_log(N, M, Nsamp);

  // Kalman filter loop
  for (arma::uword n = 0; n < Nsamp; n++)
  {
    // Update
    kalman.update(z.col(n));
    xhat_log.col(n) = kalman.get_state_vec();

    // Predict
    kalman.predict();

    e_log.col(n)   = kalman.get_err();
    P_log.slice(n) = kalman.get_err_cov();
    K_log.slice(n) = kalman.get_kalman_gain();
  }

  // RTS smoother
  kalman.rts_smooth(xhat_log, P_log, xs_log, Ps_log);

  // Display result
  gplot gp0;
  gp0.window("Plot", 10, 10, 500, 500);
  gp0.set_term("qt");
  gp0.plot_add(z0.row(0), z0.row(1), "True Y",
               "lines dashtype 2 linecolor \"black\"");
  gp0.plot_add(arma::mat(z.row(0) % cos(z.row(1))),
               arma::mat(z.row(0) % sin(z.row(1))), "Meas Y", "points");
  gp0.plot_add(xhat_log.row(0), xhat_log.row(1), "Kalman x hat");
  gp0.plot_add(xs_log.row(0), xs_log.row(1), "RTS smooth");
  gp0.plot_show();

  gplot gp1;
  gp1.window("Plot", 800, 10, 500, 500);
  gp1.set_term("qt");
  gp1.plot_add(xhat_log.row(4), "Acc x");
  gp1.plot_add(xhat_log.row(5), "Acc y");
  gp1.plot_show();

  gplot gp2;
  gp2.window("Plot", 800, 10, 500, 500);
  gp2.set_term("qt");

  arma::mat ppp = P_log.tube(0, 0);
  gp2.plot_add(ppp, "P  x");
  ppp = P_log.tube(1, 1);
  gp2.plot_add(ppp, "P  y");
  ppp = P_log.tube(2, 2);
  gp2.plot_add(ppp, "P Vx");
  ppp = P_log.tube(3, 3);
  gp2.plot_add(ppp, "P Vy");
  ppp = P_log.tube(4, 4);
  gp2.plot_add(ppp, "P Ax");
  ppp = P_log.tube(5, 5);
  gp2.plot_add(ppp, "P Ay");
  gp2.plot_show();

  return 0;
}