Merge lp:~vytng/kalmanfilterimpl/gui into lp:kalmanfilterimpl

[Vy Thuy Nguyen]

GUI plugins for graphs/charts added

[lp:~vytng/kalmanfilterimpl/gui]

6. By vy thuy nguyen(<email address hidden>) on 2012-06-29

GUI plugins for graphing

[Vy Nguyen (oontvoo)]

This is merged.

review: Approve

=== modified file 'nbproject/project.properties'
--- nbproject/project.properties	2012-06-26 08:40:46 +0000
+++ nbproject/project.properties	2012-06-29 05:34:21 +0000
@@ -25,11 +25,17 @@
 dist.jar=${dist.dir}/KalmanFilter.jar
 dist.javadoc.dir=${dist.dir}/javadoc
 excludes=
+file.reference.chart.ext.jar=C:\\Users\\VyNguyen\\Downloads\\easycharts_41_eval\\EasyCharts\\chart.ext.jar
+file.reference.chart.jar=C:\\Users\\VyNguyen\\Downloads\\easycharts_41_eval\\EasyCharts\\chart.jar
+file.reference.chartServer.jar=C:\\Users\\VyNguyen\\Downloads\\easycharts_41_eval\\EasyCharts\\chartServer.jar
 file.reference.Jama-1.0.2.jar=Jama-1.0.2.jar
 includes=**
 jar.compress=false
 javac.classpath=\
-    ${file.reference.Jama-1.0.2.jar}
+    ${file.reference.Jama-1.0.2.jar}:\
+    ${file.reference.chart.ext.jar}:\
+    ${file.reference.chart.jar}:\
+    ${file.reference.chartServer.jar}
 # Space-separated list of extra javac options
 javac.compilerargs=
 javac.deprecation=false

=== removed file 'src/kalmanfilter/KalmanFilter.java'
--- src/kalmanfilter/KalmanFilter.java	2012-06-28 02:28:33 +0000
+++ src/kalmanfilter/KalmanFilter.java	1970-01-01 00:00:00 +0000
@@ -1,80 +0,0 @@
-/**
- * Implementation of the Kalman Filter
- * Copyright (C) 2012  Vy Nguyen
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Library General Public License for more details.
- * 
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
- * Boston, MA  02110-1301, USA.
- */
-package kalmanfilter;
-  
-import Jama.Matrix;
-
-/**
- * Implements the Kalman Filter using Jama's Matrix API
- * 
- * @author Vy Thao Nguyen
- */
-public class KalmanFilter 
-{
-    // variable states
-    private Matrix X; // input vector
-    private Matrix P; // state covariance matrix
-    private Matrix Q; // process noise covariance matrix
-
-    // const states
-    private final Matrix H; // observation matrix
-    private final Matrix I; // the identity matrix 
-    private final Matrix A; // state matrix
-    private final Matrix R; // measurement noise covariance matrix
-    private final Matrix B; // control input matrix
-    private final Matrix u; 
-    
-    public KalmanFilter(Matrix X, Matrix P, Matrix Q, Matrix H, Matrix A, Matrix R, Matrix B, Matrix u)
-    {
-        this.X = X;
-        this.P = P;
-        this.Q = Q;
-        this.H = H;
-        this.A = A;
-        this.R = R;
-        this.B = B;
-        this.u = u;
-        
-        I = Matrix.identity(P.getRowDimension(), P.getColumnDimension());
-    }
-
-    public KalmanFilter timeUpdate()
-    {
-        X = A.times(X).plus(B.times(u));
-        P = A.times(P).times(A.transpose()).plus(Q);
-        return this; // for easy chaining
-    }
-
-    public Matrix messurementUpdate(Matrix Xk)
-    {
-        // compute kalman gain
-        //Kk+1 = PkHT(H PkHT + R)-1
-        Matrix K = P.times(H.transpose()).times((H.times(P).times(H.trace()).plus(R)).inverse());
-        
-        // update x
-        // xk+1 = xk + K(zk+1 − Hxk )
-        X = X.plus(K.times((Xk.times(H)).minus(H.times(X))));
-
-        // update P
-        P = (I.minus(K.times(H))).times(P);
-        
-        return X;
-    }
-}

=== removed file 'src/kalmanfilter/RunFilter.java'
--- src/kalmanfilter/RunFilter.java	2012-06-28 04:07:30 +0000
+++ src/kalmanfilter/RunFilter.java	1970-01-01 00:00:00 +0000
@@ -1,268 +0,0 @@
-/**
- * Implementation of the Kalman Filter
- * Copyright (C) 2012  Vy Nguyen
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Library General Public License for more details.
- * 
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
- * Boston, MA  02110-1301, USA.
- */
-
-package kalmanfilter;
-
-import Jama.Matrix;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-/**
- *
- * @author  Vy Thao Nguyen
- */
-public class RunFilter 
-{
-    /**
-     * Represents a point
-     */
-    public static class Point implements Comparable<Point>
-    {
-        final double x; // x coord
-        final double y; // y coord
-        final double t; // time coord
-        final double vx; // instant x-velocity
-        final double vy; // instant y-velocity
-        final double ax; // instant x-acceleration
-        final double ay; // instant y-acceleration
-        
-        /**
-         * 
-         * @param x
-         * @param y
-         * @param t
-         * @param vx
-         * @param vy
-         * @param ax
-         * @param ay
-         */
-        public Point(double x, double y, double t, double vx, double vy, double ax, double ay)
-        {
-            this.x = x;
-            this.y = y;
-            this.t = t;
-            this.vx = vx;
-            this.vy = vy;
-            this.ax = ax;
-            this.ay = ay;
-        }
-        
-        @Override
-        public int compareTo(Point o)
-        {
-            return Double.compare(t, o.t);
-        }
-    }
-    
-    /**
-     * 
-     * @param inputs
-     * @param sensorNoise
-     * @return
-     */
-    public static List<Point> filter(List<Point> inputs, double sensorNoise)
-    {
-        // sort the points in time order
-        Collections.sort(inputs);
-
-        List<Point> output = new ArrayList<>(inputs.size());
-        
-        //(Matrix X, Matrix P, Matrix Q, Matrix H, Matrix A, Matrix R)
-        KalmanFilter filter = new KalmanFilter(createX(inputs, 0),
-                                               getP0(),
-                                               getQ(),
-                                               getH(),
-                                               createA(inputs, 0),
-                                               createR(sensorNoise),
-                                               createB(),
-                                               createU());
-             
-        for (int n = 1; n < inputs.size(); ++n)
-        {
-            Matrix corrected = filter.timeUpdate().messurementUpdate(createX(inputs, n));
-            output.add(decodeX(corrected, inputs.get(n).t));
-        }
-
-        return output;
-    }
-    
-    /**
-     * TODO: correctly decode the state matrix into a point.
-     * (that is, retrieve a and v)
-     * 
-     * @param X the corrected state matrix
-     * @return the corrected value of (x,y,t)
-     */
-    private static Point decodeX(Matrix X, double t)
-    {
-        //return new Point(X.get(0, 0), X.get(0, 1), t, 0, 0);
-        throw new UnsupportedOperationException();
-    }
-    
-    /**
-     * TODO: correctly encode the point (velocity, acceleration, etc.) into a matrix.
-     * 
-     * Vector x = {x, y, vx , vy , ax, ay}
-     * 
-     * @param points 
-     * @param currentIndex index of the point the filter is currently looking at
-     * @return the input vector X
-     */
-    private static Matrix createX(List<Point> points, int currentIndex)
-    {
-        Matrix x = new Matrix(1, 6);
-        
-        List<Point> updatedPoints = computeVAndA(points);
-        
-        x.set(0, 0, updatedPoints.get(currentIndex).x);
-        x.set(0, 1, updatedPoints.get(currentIndex).y);
-        x.set(0, 2, updatedPoints.get(currentIndex).vx);
-        x.set(0, 3, updatedPoints.get(currentIndex).vy);
-        x.set(0, 4, updatedPoints.get(currentIndex).ax);
-        x.set(0, 5, updatedPoints.get(currentIndex).ay);
-        
-        return x;
-    }
-
-    /**
-     * Compute the instant velocity and acceleration of each point
-     * <b>This method makes the following assumptions:</b>
-     *      1. Acceleration of a Point object is constant and was properly set in the constructor.
-     *      2. The velocity of the first point is either 0 or has already been correctly calculated.
-     *    
-     * TODO: take variable acceleration into account.
-     * 
-     * @param points
-     * @return list of point with correct v and a 
-     */
-    private static List<Point> computeVAndA(List<Point> points)
-    {
-        int size = points.size();
-        double vx_0 = points.get(0).vx;
-        double vy_0 = points.get(0).vy;
-        double ax_0 = points.get(0).ax;
-        double ay_0 = points.get(0).ay;   
-        
-        List<Point> result = new ArrayList<Point> (size);
-        result.add(points.get(0));
-        
-        for (int i = 1; i < size; ++i)
-        {
-            double dt = points.get(i).t - points.get(0).t;
-            double vx = vx_0 + ax_0 * dt;
-            double vy = vy_0 + ay_0 * dt;
-            
-            result.add(new Point(points.get(i).x,
-                                 points.get(i).y,
-                                 points.get(i).t,
-                                 vx,
-                                 vy,
-                                 points.get(i).ax,
-                                 points.get(i).ay
-                        ));
-        }
-        
-        return result;
-    }
-    
-    /**
-     * TODO:
-     * Same as createX(...)'s
-     * 
-     * @param inputs
-     * @param currentIndex
-     * @return the state matrix A based on the the current and past position
-     */
-    private static Matrix createA(List<Point> inputs, int currentIndex)
-    {
-        throw new UnsupportedOperationException();
-    }
-    
-    /**
-     * 
-     * @param error the sensor's error
-     * @return the measurement noise covariance matrix
-     */
-    private static Matrix createR (double error)
-    {
-        Matrix R = new Matrix(1,1);
-        R.set(0, 0, error);
-        return R;
-    }
-    /**
-     * 
-     * @return the initial P matrix, which contains all zeroes 
-     */
-    private static Matrix getP0()
-    {
-        double m6x6[][] = new double[VARS_COUNT][VARS_COUNT];
-        
-        for (int n = 0; n < VARS_COUNT; ++n)
-            Arrays.fill(m6x6[n], 0);
-
-        return Matrix.constructWithCopy(m6x6);
-    }
-
-    /**
-     * TODO:
-     * correctly determine this
-     * 
-     * @return the process noise covariance matrix
-     */
-    private static Matrix getQ()
-    {
-        throw new UnsupportedOperationException();
-    }
-
-    /**
-     * 
-     * @return the [1 by n] observation matrix: [1 0 0 0 .... 0 ] 
-     */
-    private static Matrix getH()
-    {
-        Matrix H = new Matrix(1,6);
-        H.set(0, 0, 1);
-        return H;
-    }
-    
-    /**
-     * TODO: determine the value of B
-     * (could take an argument)
-     * @return 
-     */
-    private static Matrix createB()
-    {
-        throw new UnsupportedOperationException();
-    }
-    
-    /**
-     * TODO: similar to B
-     * 
-     * @return 
-     */
-    private static Matrix createU()
-    {
-        throw new UnsupportedOperationException();
-    }
-    
-    private static final int VARS_COUNT = 6;
-}

=== added directory 'src/kalmanfilter/gui'
=== added directory 'src/kalmanfilter/impl'
=== added file 'src/kalmanfilter/impl/KalmanFilter.java'
--- src/kalmanfilter/impl/KalmanFilter.java	1970-01-01 00:00:00 +0000
+++ src/kalmanfilter/impl/KalmanFilter.java	2012-06-29 05:34:21 +0000
@@ -0,0 +1,80 @@
+/**
+ * Implementation of the Kalman Filter
+ * Copyright (C) 2012  Vy Nguyen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ */
+package kalmanfilter.impl;
+  
+import Jama.Matrix;
+
+/**
+ * Implements the Kalman Filter using Jama's Matrix API
+ * 
+ * @author Vy Thao Nguyen
+ */
+public class KalmanFilter 
+{
+    // variable states
+    private Matrix X; // input vector
+    private Matrix P; // state covariance matrix
+    private Matrix Q; // process noise covariance matrix
+
+    // const states
+    private final Matrix H; // observation matrix
+    private final Matrix I; // the identity matrix 
+    private final Matrix A; // state matrix
+    private final Matrix R; // measurement noise covariance matrix
+    private final Matrix B; // control input matrix
+    private final Matrix u; 
+    
+    public KalmanFilter(Matrix X, Matrix P, Matrix Q, Matrix H, Matrix A, Matrix R, Matrix B, Matrix u)
+    {
+        this.X = X;
+        this.P = P;
+        this.Q = Q;
+        this.H = H;
+        this.A = A;
+        this.R = R;
+        this.B = B;
+        this.u = u;
+        
+        I = Matrix.identity(P.getRowDimension(), P.getColumnDimension());
+    }
+
+    public KalmanFilter timeUpdate()
+    {
+        X = A.times(X).plus(B.times(u));
+        P = A.times(P).times(A.transpose()).plus(Q);
+        return this; // for easy chaining
+    }
+
+    public Matrix messurementUpdate(Matrix Xk)
+    {
+        // compute kalman gain
+        //Kk+1 = PkHT(H PkHT + R)-1
+        Matrix K = P.times(H.transpose()).times((H.times(P).times(H.trace()).plus(R)).inverse());
+        
+        // update x
+        // xk+1 = xk + K(zk+1 − Hxk )
+        X = X.plus(K.times((Xk.times(H)).minus(H.times(X))));
+
+        // update P
+        P = (I.minus(K.times(H))).times(P);
+        
+        return X;
+    }
+}

=== added file 'src/kalmanfilter/impl/RunFilter.java'
--- src/kalmanfilter/impl/RunFilter.java	1970-01-01 00:00:00 +0000
+++ src/kalmanfilter/impl/RunFilter.java	2012-06-29 05:34:21 +0000
@@ -0,0 +1,268 @@
+/**
+ * Implementation of the Kalman Filter
+ * Copyright (C) 2012  Vy Nguyen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ */
+
+package kalmanfilter.impl;
+
+import Jama.Matrix;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ *
+ * @author  Vy Thao Nguyen
+ */
+public class RunFilter 
+{
+    /**
+     * Represents a point
+     */
+    public static class Point implements Comparable<Point>
+    {
+        final double x; // x coord
+        final double y; // y coord
+        final double t; // time coord
+        final double vx; // instant x-velocity
+        final double vy; // instant y-velocity
+        final double ax; // instant x-acceleration
+        final double ay; // instant y-acceleration
+        
+        /**
+         * 
+         * @param x
+         * @param y
+         * @param t
+         * @param vx
+         * @param vy
+         * @param ax
+         * @param ay
+         */
+        public Point(double x, double y, double t, double vx, double vy, double ax, double ay)
+        {
+            this.x = x;
+            this.y = y;
+            this.t = t;
+            this.vx = vx;
+            this.vy = vy;
+            this.ax = ax;
+            this.ay = ay;
+        }
+        
+        @Override
+        public int compareTo(Point o)
+        {
+            return Double.compare(t, o.t);
+        }
+    }
+    
+    /**
+     * 
+     * @param inputs
+     * @param sensorNoise
+     * @return
+     */
+    public static List<Point> filter(List<Point> inputs, double sensorNoise)
+    {
+        // sort the points in time order
+        Collections.sort(inputs);
+
+        List<Point> output = new ArrayList<>(inputs.size());
+        
+        //(Matrix X, Matrix P, Matrix Q, Matrix H, Matrix A, Matrix R)
+        KalmanFilter filter = new KalmanFilter(createX(inputs, 0),
+                                               getP0(),
+                                               getQ(),
+                                               getH(),
+                                               createA(inputs, 0),
+                                               createR(sensorNoise),
+                                               createB(),
+                                               createU());
+             
+        for (int n = 1; n < inputs.size(); ++n)
+        {
+            Matrix corrected = filter.timeUpdate().messurementUpdate(createX(inputs, n));
+            output.add(decodeX(corrected, inputs.get(n).t));
+        }
+
+        return output;
+    }
+    
+    /**
+     * TODO: correctly decode the state matrix into a point.
+     * (that is, retrieve a and v)
+     * 
+     * @param X the corrected state matrix
+     * @return the corrected value of (x,y,t)
+     */
+    private static Point decodeX(Matrix X, double t)
+    {
+        //return new Point(X.get(0, 0), X.get(0, 1), t, 0, 0);
+        throw new UnsupportedOperationException();
+    }
+    
+    /**
+     * TODO: correctly encode the point (velocity, acceleration, etc.) into a matrix.
+     * 
+     * Vector x = {x, y, vx , vy , ax, ay}
+     * 
+     * @param points 
+     * @param currentIndex index of the point the filter is currently looking at
+     * @return the input vector X
+     */
+    private static Matrix createX(List<Point> points, int currentIndex)
+    {
+        Matrix x = new Matrix(1, 6);
+        
+        List<Point> updatedPoints = computeVAndA(points);
+        
+        x.set(0, 0, updatedPoints.get(currentIndex).x);
+        x.set(0, 1, updatedPoints.get(currentIndex).y);
+        x.set(0, 2, updatedPoints.get(currentIndex).vx);
+        x.set(0, 3, updatedPoints.get(currentIndex).vy);
+        x.set(0, 4, updatedPoints.get(currentIndex).ax);
+        x.set(0, 5, updatedPoints.get(currentIndex).ay);
+        
+        return x;
+    }
+
+    /**
+     * Compute the instant velocity and acceleration of each point
+     * <b>This method makes the following assumptions:</b>
+     *      1. Acceleration of a Point object is constant and was properly set in the constructor.
+     *      2. The velocity of the first point is either 0 or has already been correctly calculated.
+     *    
+     * TODO: take variable acceleration into account.
+     * 
+     * @param points
+     * @return list of point with correct v and a 
+     */
+    private static List<Point> computeVAndA(List<Point> points)
+    {
+        int size = points.size();
+        double vx_0 = points.get(0).vx;
+        double vy_0 = points.get(0).vy;
+        double ax_0 = points.get(0).ax;
+        double ay_0 = points.get(0).ay;   
+        
+        List<Point> result = new ArrayList<Point> (size);
+        result.add(points.get(0));
+        
+        for (int i = 1; i < size; ++i)
+        {
+            double dt = points.get(i).t - points.get(0).t;
+            double vx = vx_0 + ax_0 * dt;
+            double vy = vy_0 + ay_0 * dt;
+            
+            result.add(new Point(points.get(i).x,
+                                 points.get(i).y,
+                                 points.get(i).t,
+                                 vx,
+                                 vy,
+                                 points.get(i).ax,
+                                 points.get(i).ay
+                        ));
+        }
+        
+        return result;
+    }
+    
+    /**
+     * TODO:
+     * Same as createX(...)'s
+     * 
+     * @param inputs
+     * @param currentIndex
+     * @return the state matrix A based on the the current and past position
+     */
+    private static Matrix createA(List<Point> inputs, int currentIndex)
+    {
+        throw new UnsupportedOperationException();
+    }
+    
+    /**
+     * 
+     * @param error the sensor's error
+     * @return the measurement noise covariance matrix
+     */
+    private static Matrix createR (double error)
+    {
+        Matrix R = new Matrix(1,1);
+        R.set(0, 0, error);
+        return R;
+    }
+    /**
+     * 
+     * @return the initial P matrix, which contains all zeroes 
+     */
+    private static Matrix getP0()
+    {
+        double m6x6[][] = new double[VARS_COUNT][VARS_COUNT];
+        
+        for (int n = 0; n < VARS_COUNT; ++n)
+            Arrays.fill(m6x6[n], 0);
+
+        return Matrix.constructWithCopy(m6x6);
+    }
+
+    /**
+     * TODO:
+     * correctly determine this
+     * 
+     * @return the process noise covariance matrix
+     */
+    private static Matrix getQ()
+    {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * 
+     * @return the [1 by n] observation matrix: [1 0 0 0 .... 0 ] 
+     */
+    private static Matrix getH()
+    {
+        Matrix H = new Matrix(1,6);
+        H.set(0, 0, 1);
+        return H;
+    }
+    
+    /**
+     * TODO: determine the value of B
+     * (could take an argument)
+     * @return 
+     */
+    private static Matrix createB()
+    {
+        throw new UnsupportedOperationException();
+    }
+    
+    /**
+     * TODO: similar to B
+     * 
+     * @return 
+     */
+    private static Matrix createU()
+    {
+        throw new UnsupportedOperationException();
+    }
+    
+    private static final int VARS_COUNT = 6;
+}