C++Talk.NET

Guest

Hallo zusammen,
ich versuche gerade einen Kalman Filter in C++ zu implementieren, habe
allerdings noch (Design) Problem.
Nachfolgend mein aktueller Code: ( Man möge mir evt. Syntaxfehler
verzeihen, ich habe die Klassen für
das Posting gekürzt )

class ExtendedKalmanFilter
{
public:
ExtendedKalmanFilter( const unsigned int& numStates );
virtual ~ExtendedKalmanFilter( );

void executePredictionStep( const KalmanFilterControlVector& u );
{
// Die Referenz zu den benötigten Matritzen bestimmen
KalmanFilterStateVector& x = onGetStateVector( );
KalmanFilterLinearisedSystemModel& A = onGetLinearisedSystemModel( );

// 1.) Das linearisierte System Model [A] aktualisieren
A.updateSystemModel( x, u );

// ...Snip...
}

protected:
// Den State Vector [x] anfordern
virtual KalmanFilterStateVector& onGetStateVector( ) = 0;

// Das Linearisierte System Model [A] anfordern
virtual KalmanFilterLinearisedSystemModel&
onGetLinearisedSystemModel( ) = 0;
};

class SixStateExtendedKalmanFilter
: public ExtendedKalmanFilter
{
public:
SixStateExtendedKalmanFilter( );
virtual ~SixStateExtendedKalmanFilter( );

private:
// Den State Vector [x] anfordern
KalmanFilterStateVector& onGetStateVector( );

// Das Linearisierte System Model [A] anfordern
KalmanFilterLinearisedSystemModel& onGetLinearisedSystemModel( );

private:
SixStateExtendedKalmanFilterStateVector m_x;
SixStateExtendedKalmanFilterLinearisedSystemModel m_A;

};

class KalmanFilterLinearisedSystemModel
: public Matrix
{
public:
KalmanFilterLinearisedSystemModel( const unsigned int& numStates );
virtual ~KalmanFilterLinearisedSystemModel( );

// Das linearisierte System Model aktualisieren. Die Inputs sind:
// - State Vector [x]
// - Control Vector [u]
virtual void updateSystemModel( const KalmanFilterStateVector& x,
const KalmanFilterControlVector& u ) = 0;
};

class SixStateExtendedKalmanFilterLinearisedSystemModel
: public KalmanFilterLinearisedSystemModel
{
public:
SixStateExtendedKalmanFilterLinearisedSystemModel( );
virtual ~SixStateExtendedKalmanFilterLinearisedSystemModel( );

// Das linearisierte System Model aktualisieren. Die Inputs sind:
// - State Vector [x]
// - Control Vector [u]
void updateSystemModel( const KalmanFilterStateVector& x, const
KalmanFilterControlVector& u )
{
// Die Elemente aus dem State Vector auslesen
//const double phi = x.getElement( 0, 0 );
//const double theta = x.getElement( 0, 1 );
//const double psi = x.getElement( 0, 2 );
// Ein direkter Zugriff auf die Matrix Elemente ist nicht so
toll...

// Tue etwas sinnvolles...
}
};

class KalmanFilterStateVector
: public Matrix
{
public:
KalmanFilterStateVector( const unsigned int& numStates );
virtual ~KalmanFilterStateVector( );
};

class SixStateExtendedKalmanFilterStateVector
: public KalmanFilterStateVector
{
public:
SixStateExtendedKalmanFilterStateVector( );
virtual ~SixStateExtendedKalmanFilterStateVector( );

double getPhi( ) const
{
return getElement( 0, 0 );
}

double getTheta( ) const
{
return getElement( 0, 1 );
}

double getPsi( ) const
{
return getElement( 0, 2 );
}
};

Meine Idee zu dem Design war folgende:
Der Kalman Filter benötigt unterschiedliche Matritzen und Vektoren
( StateVector, ControlVector, SystemModel und einige mehr ).
Die konkreten Implementierungen dieser Matrizten ist bei jedem Filter
unterschiedlich. Aus diesem Grund habe ich für all diese
Matritzen Basisklassen eingeführt. Mein konkreter Kalman Filter
(SixStateExtendedKalmanFilter) hat nun eine passende Anzahl von
Klassen die sich alle von ihren Basisklassen ableiten und die konkrete
Filter Implementierung besitzen.

Die Gemeinsamkeit verschiedener Kalman Filter ist der Algorithmus
( wann muss, in welcher Reihenfolge, welche Matrix angewendet
werden ).
Ein Teil des Algorithmus steckt in der executePredictionStep()
Methode. In der Methode werden die virtuelle Methoden aufgerufen,
die im SixStateExtendedKalmanFilter definiert sind. Diese geben die
Basisklassen Referenzen auf die Matritzen zurück. Im weiteren
Verlauf wird die updateSystemModel() Methode aufgerufen. Die Methode
bekommt eine Referenz auf die Basisklassen übergeben.
Genau hier liegt mein Problem, denn innerhalb der updateSystemModel()
Methode würde ich gerne auf die Methoden der abgeleiteten
Klasse zugreifen ( getPhi(), getTheta(), getPsi() ).

Ein einfacher Weg wär sicher ein dynamic_cast. Das gefällt mir jedoch
nicht so gut weil ein cast oft für ein schlechtes Design
spricht ( Ja, manchmal muss man casten, aber oft lässt es sich
vermeiden Smile

)

Eine andere Möglichkeit wäre es für die Basisklasse des
KalmanFilterStateVector eine virtuelle Methode zu finden, die
allgemein
genug ist, um alle möglichen Kalman Filter abzudecken. So eine Methode
gibt es aber nicht denke ich, da die Filter zu unterschiedlich
sein können.

Dann habe ich noch an das Visitor Pattern gedacht. Das klappt aber
auch nicht, da der Visitor dann die Konkrete Implementierung
des KalmanFilterStateVector kennen muss.

Irgendwie ist der Wurm drin Smile

Da ich sicher nicht der erste bin der
so ein Problem hat, hoffe ich das ihr mir ein paar Denkanstösse
geben könnt. Vielleicht ist mein bisheriger Ansatz auch einfach nur
"Müll" vielleicht habt ihr bessere Ideen ?

Danke sagt
Markus

Guest

Hat niemand eine Idee oder war es zu undeutlich beschrieben ?

Gruss
Markus

Guest

On 21 Mrz., 06:59, DesignPatt...@web.de wrote:

Marcel Müller · Guest

DesignPattern (AT) web (DOT) de wrote:

Thorsten Nitz · Guest

DesignPattern (AT) web (DOT) de schrieb:

[ jede Menge Code ]

Den Zweck Deiner Architektur habe ich nicht sicher ergründen können.
Hier meine Anmerkungen zu dem, was ich verstanden zu haben glaube.