File: INCLUDE\AUTOJUST\MATRIX.H
1 // matrix.h - definiert die Matrix-, Vektor- und MatrizenListe-Klassen.
2 // Dabei enthält das Array alle Elemente der Matrix. Das wird erreicht, indem
3 // die Zeilen der Matrix hindereinander gespeichert werden, d.h. Zeile 1,
4 // Zeile 2, ..., Zeile n.
5
6 #ifndef __MATRIX_H
7 #define __MATRIX_H
8
9 #include "utils\u_utils.h"
10
11 // Konstanten fuer Reihenfolge der Transformationen
12 const unsigned REIHENFOLGE_XYZ= 10;
13 const unsigned REIHENFOLGE_ZYX= 13;
14
15 class TVektor;
16
17 //******************************************************************************
18 // Klasse Matrix
19 // -------------
20 // mit m Zeilen und n Spalten
21 // es besteht die Möglichkeit, die Matrizen in homogener Schreibweise
22 // anzugeben (durch zusätzliche homogene Komponente)
23 // in diesem Fall wird die Membervariable homogene_koordinaten=true gesetzt
24 //******************************************************************************
25 class TMatrix
26 {
27 friend TVektor;
28
29 protected:
30 // Membervariablen zur Darstellung der Matrix
31 double *arr; // eindimensionales Feld zur Speicherung der Matrixelemente
32 unsigned ze; // Zeilen
33 unsigned sp; // Spalten
34 // Flag, das angibt, ob Matrix in homogener Schreibweise dargestellt ist
35 bool homogene_koordinaten;
36
37 public:
38 // Konstruktoren und Destruktor:
39 TMatrix(); // Standardkonstruktor
40 TMatrix(unsigned m, unsigned n); // initialisiert eine m*n-Nullmatrix
41 TMatrix (const TMatrix & mat); // eigener Copy-Kontruktor
42 virtual ~TMatrix(); // Klassendestruktor
43
44 // Klassenmethoden:
45 // Test, ob Matrix bzw. Vektor in homogenen Koordinaten angegeben ist
46 bool ist_homogen(void) const
47 {
48 return homogene_koordinaten;
49 }
50
51 // überladene Operatoren :
52 TMatrix operator= (const TMatrix & mat); // Matrizenzuweisung
53 TMatrix operator + (const TMatrix & mat); // Matrizenaddition
54 TMatrix operator - (const TMatrix & mat); // Matrizensubtraktion
55 TMatrix operator * (const TMatrix & mat); // Matrizenmultiplikation
56 TMatrix operator * (double & fakt); // reelle Vervielfachung für TMatrix*double
57 friend TMatrix operator * (double fakt, const TMatrix & mat); // double*TMatrix
58
59 // Berechnung der Inversen einer Matrix,
60 // sofern es sich um eine reguläre Matrix handelt
61 TMatrix invers(void);
62
63 // Erstellung einer Einheitsmatrix mit Rang m
64 TMatrix einheitsmatrix(unsigned m);
65
66 // **** Transformationsmethoden ***************************
67
68 // Verschiebe-(Translations)TMatrix erzeugen
69 // Verschiebung um (Tx,Ty,Tz) Vektor
70 TMatrix verschiebematrix(const TVektor & vekt);
71
72 // Rotationsmatrix erzeugen
73 // Drehung um x-,y-, bzw. z-Achse mit Winkel
74 // Anmerkung: wenn Winkel negativ angegeben, dann handelt es sich um eine
75 // inverse Drehung
76 TMatrix rotationsmatrix_x(double winkel);
77 TMatrix rotationsmatrix_y(double winkel);
78 TMatrix rotationsmatrix_z(double winkel);
79
80 // Zusammenfassung aller Transformationen in einer Funktion
81 // Reihenfolge: REIHENFOLGE_XYZ= 10
82 // REIHENFOLGE_ZYX= 13
83 TMatrix transformiere(unsigned reihenfolge, const TVektor & verschiebung,
84 double drehung_x, double drehung_y, double drehung_z);
85 };
86
87
88 //******************************************************************************
89 // Klasse Vektor
90 // -------------
91 // ist ein Spezialfall einer Matrizenklasse, bei dem gilt:
92 // Spaltenanzahl (sp)= 1
93 // es besteht die Möglichkeit, die Komponenten des Vektors
94 // in homogenen Koordinaten anzugeben (durch zusätzliche homogene Komponente)
95 // in diesem Fall wird die Membervariable homogene_koordinaten=true gesetzt
96 //******************************************************************************
97 class TVektor : public TMatrix
98 {
99
100 public:
101 // Konstruktoren:
102
103 // Standardkonstruktor
104 TVektor(void) : TMatrix()
105 {
106 sp= 1;
107 }
108
109 // Konstruktor zur Initialisierung eines Vektors
110 // mit m Zeilen in kartesischen Koordinaten
111 TVektor(unsigned m) : TMatrix(m, 1)
112 {}
113
114 // Konstruktor zur Initialisierung eines 3D-Vektors mit kartesischen Koordinaten
115 TVektor(double x, double y, double z) : TMatrix(3, 1)
116 {
117 arr[0]= x;
118 arr[1]= y;
119 arr[2]= z;
120 }
121
122 // Copy-Konstruktor, um aus einer (m,1)-Matrix einen Vektortyp zu machen
123 TVektor (const TMatrix & mat);
124
125 // Klassenmethoden:
126
127 // Vektor skalieren
128 friend TVektor operator * (double fakt, const TVektor & vekt);
129
130 // Matrix wird mit einem Vektor multipliziert und das Ergebnis ist ein Vektor
131 // friend TVektor operator * (const TMatrix & mat, const TVektor & vekt);
132
133 // Umwandlung in einen Vektor mit homogenen Koordinaten
134 TVektor mache_homogen(void);
135
136 // Umwandlung in einen Vektor mit kartesischen Koordinaten
137 TVektor mache_kartesisch(void);
138
139 // Berechnung des Betrags (Länge) eines Vektors
140 double vektor_betrag (void) const;
141
142 // Berechnung des Skalarproduktes zweier Vektoren
143 double skalarprodukt (const TVektor & vekt);
144
145 // Berechnung des Winkels zwischen zwei Vektoren
146 double winkel (const TVektor & vekt);
147
148 // Setzen der x,y,z-Koordinaten eines 3dim Vektors
149 bool set_XYZ(double x, double y, double z);
150
151 // Ausgabe der x,y,z-Koordinaten eines 3dim Vektors
152 bool get_XYZ(double & x, double & y, double & z);
153
154 };
155
156
157 //******************************************************************************
158 // Matrizenliste-Klasse
159 // --------------------
160 // Liste von Transformationsmatrizen
161 // organisiert als Stack
162 // mit push(element), pop(), ist_leer()
163 //******************************************************************************
164 class TMatrizenListe
165 {
166 private:
167 // Membervariablen
168 TMatrix *liste; // Liste als Zeiger auf die Matrizen
169 unsigned akt_elemente; // aktuelle Anzahl von Matrixelements in der Liste
170 unsigned max_elemente; // maximale Anzahl von abzuspeichernden Matrizen
171
172 public:
173 // Konstruktoren und Destruktoren
174
175 // Listenkonstruktor um eine Liste mit einer bestimmten Anzahl von
176 // Listenelementen zu erzeugen
177 TMatrizenListe(unsigned anzahl= 10);
178
179 // Standarddestruktor
180 virtual ~TMatrizenListe()
181 {
182 _FREELIST(liste);
183 }
184
185 // Klassenmethoden:
186
187 // Test, ob Matrizenliste leer ist
188 bool ist_leer(void)
189 {
190 return (akt_elemente == 0);
191 }
192
193 // Gibt die Anzahl der Listenlemente zurück
194 unsigned elementanzahl(void)
195 {
196 return akt_elemente;
197 }
198
199 // Matrix zur Liste hinzufügen
200 bool push(const TMatrix & trafo);
201
202 // letzte Matrix aus Liste entfernen
203 // liefert entfernte Matrix zurück
204 TMatrix pop(void);
205
206 // Listenelement mit Nummer position (1 .. akt_elemente) ausgeben(Direktzugriff)
207 // liefert die Matrix an der Stelle position zurück
208 TMatrix zeige(unsigned position);
209
210 };
211
212 #endif
213
214