thecooldrop / openrfs Goto Github PK

The innovation covariance and its inverse are not stored in uniform fashion with respect to how covariances in Kalman filter are stored.

Basically the problem is that number of innovation matrices does not get multiplied leading to mismatch between updated number of components and number of innovation matrices.

When using the Kalman filter as part of GMPHD filter the predict step fails on first recursion due to state being empty.

Namely when running the predict step of Kalman filter initialized with empty state it fails due to mismatch in matrix dimesions in predict() method.

Check that for Kalman filter initialized with empty state and covariance the predict() method and update() method can run successfully for:

• Kalman filter
• Extended Kalman filter
• Unscented Kalman filter

As is the PHD filters are implemented only to operate with Kalman filter. The filters should be able to operate with generic Kalman filters.

Proposal is to make changes to interface so that the PHD filter can operate with any filter subclassing the Kalman ABC

The merging of Gaussian components needs to be done for many different filters such as in GMPHD and CPHD filters, thus it would be of use to implement this algorithm as separate method.

This is a feature request to implement the cardinalized PHD fillter laid out in paper by Ba-Ngu Vo.

Since this filter is direct refinition of the GM-PHD algorithm already implemented it also belongs in this collection of algorithms.

Right now it is necessary for user to define the kinematic model matrices for each Kalman filter. It would be easier if some standard models were already available for faster deployment of tests.

Here a factory interface is proposed as solution. This class should contain only static methods which compute the model matrices given some specified inputs.

The class should be able to generate following basic kinematic models:

• continuous white noise acceleration model ( CV or constant velocity model )
• continuous wiener process acceleration model ( CA or constant acceleration model )

The descriptions of these models can be found in book by Yaakov Bar-Shalom - Estimation with Application to Tracking and Navigation chapter 6

As title says the implementation of GMPHD filter can be done much better, so this should be done

The GMPHD constructor is very complex right now containing many parameters which can be made optional. Also it is heavily coupled with implementation of Kalman class, as it fumbles with internal state of the kalman_filter.

The following two things need to be done in order to improve this:

• Make the spawning parameters of GMPHD filter optional
• Create a GMPHD builder class to enable efficient construction of GMPHD instances

Right now the Kalman filters do not have the uniform interface, even though they are all subclassing the Kalman ABC.

This should be improved by making Kalman filters an object which contains its own internal state in order to make the interface for users uniform

It was noted that all Kalman filters implemented up to now require four matrices and some special variables and it could reduce code duplication if that initialization is moved to the Kalman ABC.

The cardinality balanced multi-target multi-bernoulli filter by Ba Ngu Vo is an algorithm for multitarget tracking based on more powerful approximation then PHD algortihms.

Since it is based on the RFS framework of algorithms it belongs into this library.

It was noted that in following part of estimationn/ukf.py the vectorization is wrong:

self._innovation = measurements - self._mean_measurements

The error here is that two matrices are subtracted instead of subtracting each measurement from all of self._mean_measurements. Following corrections need to be undertaken:

• Correct the vectorization of update method
• Correct the subsequent computations relying on self._innovation
• Correct the pure_update method to make sure that each state is updated with each of measurements

In the end the behavior of the filter should be such that each predicted state is updated with each of provided measurements resulting in number of states equal to number of states multiplied by number of measurements.

Classes working with Gaussian mixtures are already implemented in PHD and CPHD filter. It would seem that an uniform interface for accessing the weights, means and covariances if components in Gaussian mixture would be in order. Further a common algorithm for reducing the mixtures of Gaussian components could be included.

The implementation should contain following things:

• Constructor declaring the fields to store weights, means and covariances of Gaussian mixture components

• Property setters and getters for accessing the components

• An algorithm for reducing tge Gaussian mixture by merging alike components

The issue is closed as soon as this mixin is used in classes using Gaussian mixtures for computations

Kalman filter classes contain many optional parameters which should not be set by user in any case. Reduce the complexity of Kalman filter constructors by removing the optional parameters which should not be set by the user.

These include in Kalman base class:

• states
• covariances
• innovation
• innovation_covariances
• inv_innovation_covariances
• kalman_gains
• expected_measurements