예제 #1
0
        private void initializeKalman(PointF startPoint)
        {
            var measurementDimension = 2; //just coordinates

            var initialState = new ModelState {
                Position = startPoint, Velocity = new PointF(0.5f, -2f)
            };
            var initialStateError = ModelState.GetProcessNoise(0);

            kalman = new DiscreteKalmanFilter <ModelState, PointF>(initialState, initialStateError,
                                                                   measurementDimension /*(position)*/, 0 /*no control*/,
                                                                   x => ModelState.ToArray(x), x => ModelState.FromArray(x), x => new double[] { x.X, x.Y });

            kalman.ProcessNoise     = ModelState.GetProcessNoise(2);
            kalman.MeasurementNoise = Matrix.Diagonal <double>(kalman.MeasurementVectorDimension, 1);

            kalman.MeasurementMatrix = new double[, ] //just pick point coordinates for an observation [2 x 4] (look at ConstantVelocity2DModel)
            {
                //X,  vX, Y,  vY (look at ConstantVelocity2DModel)
                { 1, 0, 0, 0 },      //picks X
                { 0, 0, 1, 0 }       //picks Y
            };

            kalman.TransitionMatrix = ModelState.GetTransitionMatrix();
        }
예제 #2
0
        private void initializeKalman()
        {
            float accelNoise       = (float)numProcessNoise.Value;
            float measurementNoise = (float)numMeasurementNoise.Value;

            var measurementDimension = 2;                              //just coordinates

            var initialState      = process.GetNoisyState(accelNoise); //assuming we measured process params (noise)
            var initialStateError = ModelState.GetProcessNoise(accelNoise);

            kalman = new DiscreteKalmanFilter <ModelState, PointF>(initialState, initialStateError,
                                                                   measurementDimension /*(position)*/, 0 /*no control*/,
                                                                   x => ModelState.ToArray(x), x => ModelState.FromArray(x), x => new double[] { x.X, x.Y });

            kalman.ProcessNoise     = ModelState.GetProcessNoise(accelNoise);
            kalman.MeasurementNoise = Matrix.Diagonal <double>(kalman.MeasurementVectorDimension, measurementNoise).ElementwisePower(2); //assuming we measured process params (noise) - ^2 => variance

            kalman.MeasurementMatrix = new double[, ]                                                                                    //just pick point coordinates for an observation [2 x 4] (look at ConstantVelocity2DModel)
            {
                //X,  vX, Y,  vY (look at ConstantVelocity2DModel)
                { 1, 0, 0, 0 },      //picks X
                { 0, 0, 1, 0 }       //picks Y
            };

            kalman.TransitionMatrix = ModelState.GetTransitionMatrix(ConstantVelocityProcess.TimeInterval);
        }
        private void initializeKalman(PointF startPoint)
        {
            var measurementDimension = 2; //just coordinates

            var initialState = new ModelState {
                Position = startPoint, Velocity = new PointF(0.2f, -1.5f)
            };
            var initialStateError = ModelState.GetProcessNoise(10);

            kalman = new DiscreteKalmanFilter <ModelState, PointF>(initialState, initialStateError,
                                                                   measurementDimension /*(position)*/, 0 /*no control*/,
                                                                   x => ModelState.ToArray(x), x => ModelState.FromArray(x), x => new double[] { x.X, x.Y });

            kalman.ProcessNoise     = ModelState.GetProcessNoise(1);
            kalman.MeasurementNoise = Matrix.Diagonal <double>(kalman.MeasurementVectorDimension, 10000.0);

            kalman.MeasurementMatrix = ModelState.GetPositionMeasurementMatrix();
            kalman.TransitionMatrix  = ModelState.GetTransitionMatrix();
        }
 public static ConstantVelocity2DModel Evaluate(ConstantVelocity2DModel state, double[,] transitionMat)
 {
     var stateVector = state.ToArray().Multiply(transitionMat);
     return ConstantVelocity2DModel.FromArray(stateVector);
 }
        public static ConstantVelocity2DModel Evaluate(ConstantVelocity2DModel state, double[,] transitionMat)
        {
            var stateVector = state.ToArray().Multiply(transitionMat);

            return(ConstantVelocity2DModel.FromArray(stateVector));
        }