MATRIX.H

gehe zur Dokumentation dieser Datei

// matrix.h - definiert die Matrix-, Vektor- und MatrizenListe-Klassen.
// Dabei enthält das Array alle Elemente der Matrix. Das wird erreicht, indem
// die Zeilen der Matrix hindereinander gespeichert werden, d.h. Zeile 1,
// Zeile 2, ..., Zeile n.

#ifndef __MATRIX_H
#define __MATRIX_H

#include "utils\u_utils.h"

// Konstanten fuer Reihenfolge der Transformationen
const unsigned REIHENFOLGE_XYZ= 10;
const unsigned REIHENFOLGE_ZYX= 13;

class TVektor;

//******************************************************************************
// Klasse Matrix
// -------------
// mit m Zeilen und n Spalten
// es besteht die Möglichkeit, die Matrizen in homogener Schreibweise
// anzugeben (durch zusätzliche homogene Komponente)
// in diesem Fall wird die Membervariable homogene_koordinaten=true gesetzt
//******************************************************************************
class TMatrix
{
        friend TVektor;

protected:
        // Membervariablen zur Darstellung der Matrix
        double *arr; // eindimensionales Feld zur Speicherung der Matrixelemente
        unsigned ze; // Zeilen
        unsigned sp; // Spalten
        // Flag, das angibt, ob Matrix in homogener Schreibweise dargestellt ist
        bool homogene_koordinaten;

public:
        // Konstruktoren und Destruktor:
        TMatrix();                       // Standardkonstruktor
        TMatrix(unsigned m, unsigned n); // initialisiert eine m*n-Nullmatrix
        TMatrix (const TMatrix & mat);   // eigener Copy-Kontruktor
        virtual  ~TMatrix();                      // Klassendestruktor

// Klassenmethoden:
        // Test, ob Matrix bzw. Vektor in homogenen Koordinaten angegeben ist
        bool ist_homogen(void) const
        {
                return homogene_koordinaten;
        }

        // überladene Operatoren :
        TMatrix operator= (const TMatrix & mat); // Matrizenzuweisung
        TMatrix operator + (const TMatrix & mat); // Matrizenaddition
        TMatrix operator - (const TMatrix & mat); // Matrizensubtraktion
        TMatrix operator * (const TMatrix & mat); // Matrizenmultiplikation
        TMatrix operator * (double & fakt); // reelle Vervielfachung für TMatrix*double
        friend TMatrix operator * (double fakt, const TMatrix & mat); // double*TMatrix

        // Berechnung der Inversen einer Matrix,
        // sofern es sich um eine reguläre Matrix handelt
        TMatrix invers(void);

        // Erstellung einer Einheitsmatrix mit Rang m
        TMatrix einheitsmatrix(unsigned m);

        // **** Transformationsmethoden ***************************

        // Verschiebe-(Translations)TMatrix erzeugen
        // Verschiebung um (Tx,Ty,Tz) Vektor
        TMatrix verschiebematrix(const TVektor & vekt);

        // Rotationsmatrix erzeugen
        // Drehung um x-,y-, bzw. z-Achse mit Winkel
        // Anmerkung: wenn Winkel negativ angegeben, dann handelt es sich um eine
        //            inverse Drehung
        TMatrix rotationsmatrix_x(double winkel);
        TMatrix rotationsmatrix_y(double winkel);
        TMatrix rotationsmatrix_z(double winkel);

        // Zusammenfassung aller Transformationen in einer Funktion
        // Reihenfolge: REIHENFOLGE_XYZ= 10
        //              REIHENFOLGE_ZYX= 13
        TMatrix transformiere(unsigned reihenfolge, const TVektor & verschiebung,
                                                  double drehung_x, double drehung_y, double drehung_z);
};


//******************************************************************************
// Klasse Vektor
// -------------
// ist ein Spezialfall einer Matrizenklasse, bei dem gilt:
// Spaltenanzahl (sp)= 1
// es besteht die Möglichkeit, die Komponenten des Vektors
// in homogenen Koordinaten anzugeben (durch zusätzliche homogene Komponente)
// in diesem Fall wird die Membervariable homogene_koordinaten=true gesetzt
//******************************************************************************
class TVektor : public TMatrix
{

public:
        // Konstruktoren:

        // Standardkonstruktor
        TVektor(void) : TMatrix()
        {
                sp= 1;
        }

        // Konstruktor zur Initialisierung eines Vektors
        // mit m Zeilen in kartesischen Koordinaten
        TVektor(unsigned m) : TMatrix(m, 1)
        {}

        // Konstruktor zur Initialisierung eines 3D-Vektors mit kartesischen Koordinaten
        TVektor(double x, double y, double z) : TMatrix(3, 1)
        {
                arr[0]= x;
                arr[1]= y;
                arr[2]= z;
        }

        // Copy-Konstruktor, um aus einer (m,1)-Matrix einen Vektortyp zu machen
        TVektor (const TMatrix & mat);

        // Klassenmethoden:

        // Vektor skalieren
        friend TVektor operator * (double fakt, const TVektor & vekt);

        // Matrix wird mit einem Vektor multipliziert und das Ergebnis ist ein Vektor
        // friend TVektor operator * (const TMatrix & mat, const TVektor & vekt);

        // Umwandlung in einen Vektor mit homogenen Koordinaten
        TVektor mache_homogen(void);

        // Umwandlung in einen Vektor mit kartesischen Koordinaten
        TVektor mache_kartesisch(void);

        // Berechnung des Betrags (Länge) eines Vektors
        double vektor_betrag (void) const;

        // Berechnung des Skalarproduktes zweier Vektoren
        double skalarprodukt (const TVektor & vekt);

        // Berechnung des Winkels zwischen zwei Vektoren
        double winkel (const TVektor & vekt);

        // Setzen der x,y,z-Koordinaten eines 3dim Vektors
        bool set_XYZ(double x, double y, double z);

        // Ausgabe der x,y,z-Koordinaten eines 3dim Vektors
        bool get_XYZ(double & x, double & y, double & z);

};


//******************************************************************************
// Matrizenliste-Klasse
// --------------------
// Liste von Transformationsmatrizen
// organisiert als Stack
// mit push(element), pop(), ist_leer()
//******************************************************************************
class TMatrizenListe
{
private:
        // Membervariablen
        TMatrix *liste;        // Liste als Zeiger auf die Matrizen
        unsigned akt_elemente; // aktuelle Anzahl von Matrixelements in der Liste
        unsigned max_elemente; // maximale Anzahl von abzuspeichernden Matrizen

public:
        // Konstruktoren und Destruktoren

        // Listenkonstruktor um eine Liste mit einer bestimmten Anzahl von
        // Listenelementen zu erzeugen
        TMatrizenListe(unsigned anzahl= 10);

        // Standarddestruktor
        virtual  ~TMatrizenListe()
        {
                _FREELIST(liste);
        }

        // Klassenmethoden:

        // Test, ob Matrizenliste leer ist
        bool ist_leer(void)
        {
                return (akt_elemente == 0);
        }

        // Gibt die Anzahl der Listenlemente zurück
        unsigned elementanzahl(void)
        {
                return akt_elemente;
        }

        // Matrix zur Liste hinzufügen
        bool push(const TMatrix & trafo);

        // letzte Matrix aus Liste entfernen
        // liefert entfernte Matrix zurück
        TMatrix pop(void);

        // Listenelement mit Nummer position (1 .. akt_elemente) ausgeben(Direktzugriff)
        // liefert die Matrix an der Stelle position zurück
        TMatrix zeige(unsigned position);

};

#endif

---