LPR research courses computer misc persons info www


Klassenbeschreibung der Bibliothek GeoSym



Übersicht

Im folgenden sind die einzelnen Klassen in einer Übersicht aufgeführt. Die direkte Anwahl einer Klasse kann durch Anklicken des Verweises erfolgen.





Nomenklatur


Bei der Beschreibung von Methoden einer Klasse soll anhand der Formatierung ersichtlich sein, ob es sich bei der Methode um eine normale, überschriebene oder geerbte Methode handelt. Zu diesem Zweck werden die folgenden Formatierungen verwendet:

StilArt der Methode
Fett:normale Methode
Fett und Kursiv:Überschriebene virtuelle Methode
Kursiv:Geerbte Methode
Normal:Standard-Methode

Bei einer normalen Methode handelt es sich um eine Methode, die durch die Klasse selbst deklariert ist.
Die vituelle überschriebene Methode ist von einer Basisklasse deklariert worden, wird aber durch eine Methode der Klasse überschrieben.
Eine geerbte Methode ist zwar ebenfalls durch eine Basisklasse deklariert, wird aber nicht durch eine Methode der Klasse überschrieben.
Bei einer Standard-Methode handelt sich um den Standard Konstruktor oder Destruktor einer Klasse, d.h. diese sind nicht explizit implementiert.


Allgemeine Hinweise


Listen

Bei den verwendeten impliziten Listen soll das Konzept von Zugriffen auf Listenelemente beschrieben werden. Dabei werden zwei Accessoren verwendet, die dazu dienen die Länge der Liste zu erfragen und den Zugriff auf ein bestimmtes Element der Liste mittels dessen Index ermöglichen.
Die beiden Accessoren sind dabei durch die Methoden GetxxLen() und Getxx( int index ) implementiert.

Ein- und Ausgabe in Streams

Bei der Ein- und Ausgabe durch Streams werden die beiden Methoden Scan( istream& > und Print( ostream& ) verwendet. Besitzt eine Klasse eine dieser Methoden, so wird automatisch ein entsprechender Streamoperator << oder >> definiert, der lediglich die entsprechende Methode Scan oder Print aufruft.



Basisklassen


Um ein besseres Verständnis für die folgenden Klassen der GeoSym-Bibliothek zu erleichtern, sollen in diesem Teil die Definitionen von Basisklassen gezeigt werden, von denen einige der GeoSym-Klassen abgeleitet sind.

1. Basisklasse class Face3D

Die abstrakte Klasse Face3D soll in diesem Rahmen genauer betrachtet werden, da sie eine einheitliche Schnittstelle für Flächen darstellt.

class Face3D
{
  public:
                                ~Face3D();

    VIRT int                    GetLen()                const = 0;
    VIRT ID                     GetId()                 const = 0;
    VIRT Vector3D               GetVertex( int i )      const = 0;
    VIRT Vector3D               GetNormalVector()       const;

    ostream&                    Print( ostream& o )     const;

    // Shortcuts
    int                         len()                   const;
    Vector3D                    v( int i )              const;

    friend ostream&             operator <<( ostream& o, Face3D& face );
};

Methoden der Basisklasse

2. Basisklasse class Node

class Node
{
  public:
                                Node();
    virtual                     ~Node();

    Node*                       GetSucc()       const;
    Node*                       GetPred()       const;

    class List&                 GetList()       const;

    virtual SIZE_T              GetSize()       const;

    BOOL                        IsTail()        const;
    BOOL                        IsHead()        const;
    BOOL                        IsFirst()       const;
    BOOL                        IsLast()        const;
    BOOL                        IsValidNode()   const;

    // Shortcuts
    Node*                       succ()          const;
    Node*                       pred()          const;
    class List&                 list()          const;
    virtual SIZE_T              size()          const;

    void                        init();
};

3. Basisklasse class TNode

template <class T> class TNode : public Node
{
  public:
    virtual SIZE_T              GetSize() const;
    T*                          GetSucc() const;

    T*                          GetPred() const;

    class TList<T>&             GetList() const;

    // Shortcuts
    virtual SIZE_T              size()  const;
    T*                          succ()  const;
    T*                          pred()  const;
    class TList<T>&             list()  const;
};

4. Basisklasse class Vector3D

class Vector3D
{
  public:
                                Vector3D( double x=0.0, double y=0.0, double z=0.0 );
	
    BOOL                        operator==( const Vector3D &v );
	
    Vector3D&                   operator+=( const Vector3D &v );
    Vector3D&                   operator-=( const Vector3D &v );
	
    Vector3D&                   operator*=( double scalar );
    Vector3D&                   operator*=( const RotLat &r );
    Vector3D&                   operator*=( const Vector3D &v );
	
    double                      operator*( const Vector3D &v );
	
    Vector3D&                   Normalize();
	
    double                      GetX() const;
    double                      GetY() const;
    double                      GetZ() const;
    double                      GetNorm() const;
	
    istream&                    Scan( istream& i );
    ostream&                    Print( ostream& o ) const ;
	
    friend istream&             operator >>( istream& i, Vector3D &v );
    friend ostream&             operator <<( ostream& o, const Vector3D &v );
};

5. Basisklasse class RotLat

class RotLat
{
  public:
    static const RotLat         identity;
	
                                RotLat();
                                RotLat( const RotLat& rotlat );
	
    RotLat&                     operator=( const RotLat& rotlat );
	
    RotLat&                     Identity();
    RotLat&                     Invert();
	
    RotLat&                     Rotate( const Vector3D &rot );
    RotLat&                     RotateX( double phi );
    RotLat&                     RotateY( double phi );
    RotLat&                     RotateZ( double phi );
	
    RotLat&                     Translate( const Vector3D &trans );
    RotLat&                     TranslateX( double dx );
    RotLat&                     TranslateY( double dy );
    RotLat&                     TranslateZ( double dz );

    RotLat&                     SetTranslation( const Vector3D &trans );
	
    const RotLat&               Apply( Vector3D &vector ) const;
    const RotLat&               ApplyReverse( Vector3D &vector ) const;
	
    RotLat&                     operator *=( const RotLat& rotlat );
	
    Vector3D                    GetTranslation() const;

    istream&                    Scan( istream& i );
    ostream&                    Print( ostream& o ) const ;
	
    friend istream&             operator >>( istream& i, RotLat& rotlat );
    friend ostream&             operator <<( ostream& o, const RotLat& rotlat );
};

5. Basisklasse template class TGeoList

template  class TGeoList
  : public GeoList
{
  public:
                                TGeoList( int skipcount=20 );
                                ~TGeoList();

    T*                          Append( T* node );
	
    T*                          GetNode( int index );

    void                        Fix();
    void                        UnFix();

    T*                          GetHead() const;
    T*                          GetTail() const;
    T*                          GetFirst() const;
    T*                          GetLast() const;
};


Modellierung eines Körpers

Als erstes soll die verwendete Modellierung eines Körpers beschrieben werden. Der Körper wird hauptsächlich anhand seiner Kinematik modelliert. Dazu wird erfolgt eine Unterscheidung in Wurzel- (Root) und Unterelemente (Member). Wie sein Name andeutet, bildet die Wurzel das Element von dem weitere Elemente kinematisch abhängen können. Die Untergeordneten Elemente können selbstverständlich weitere untergeordnete Elemente besitzen.
Verbunden sind diese in der Körperhierarchie auf verschiedenen Ebenen befindlichen Elemente durch Gelenke (Joint). Das Gelenk bildet die kinematische Modellierung nach. Dazu kann es einen Freiheitsgrad nachbilden, der rotatorischer oder translatorischer Natur sein kann und eine bestimmte Achse verwendet.



Klassen


1. Klasse Time

Diese Klasse dient zur Speicherung und Abfrage von Zeiten.

1.1 Klassenableitung


1.2 Klassendefinition

class Time

1.3 Konstruktoren

1.4 Destruktor

1.5 Methoden

Übersicht


2. Klasse BoundBox

Durch diese Klasse wird eine Umgebungsquader definiert werden. Zu diesem Zweck werden zwei Vektoren verwendet, die den minimalen und den maximalen Punkt des Quaders angeben.

2.1 Klassenableitung

Die Klasse BoundBox ist von keiner Klasse abgeleitet.

2.2 Klassendefinition

class BoundBox

2.3 Konstruktoren

2.4 Destruktor

2.5 Methoden

Vector3D

Übersicht


3. Klasse Vertex

Die Klasse dient der Speicherung eines Flächeneck- oder Linienendpunktes. Dazu wird der Punkt in einem Vektor gespeichert.

3.1 Klassenableitung

Durch die Ableitung von dem Templateknoten ist die Klasse Vertex listenfähig.

3.2 Klassendefinition

class Vertex : public TNode<Vertex>

3.3 Konstruktoren

3.4 Destruktor

3.5 Methoden

Vector3D

Übersicht


4. Klasse gs_Face3D

gs_Face3D stellt eine Klasse dar, die 3-dimensionale, planare Flächen zur Verfügung stellt.

4.1 Klassenableitung

Die Klasse gs_Face3D ist zum einen von der Basisklasse Face3D und zum anderen von dem Templateknoten TNode<gs_Face3D> abgeleitet. Durch die Ableitung von dem Templateknoten erhält die Klasse die Listenfähigkeit.

4.2 Klassendefinition

class gs_Face3D : public Face3D,
                  public TNode<gs_Face3D>

4.3 Konstruktoren

4.4 Destruktor

4.5 Methoden

4.6 Operatoren

Vector3D Face3D TNode

Übersicht


5. Klasse gs_ObjFace3D

gs_ObjFace3D stellt ein spezielle Fläche dar, die automatisch eine Transformation der Eckpunkte innerhalb eines Objektes vollführt, falls dies notwendig ist.

5.1 Klassenableitung

Die Klasse gs_ObjFace3D ist von der Klasse gs_Face3D abgeleitet. Dadurch erhält die Klasse die gleiche Funktionalität wie gs_Face3D.

5.2 Klassendefinition

class gs_ObjFace3D : public gs_Face3D

5.3 Konstruktoren

5.4 Destruktor

5.5 Methoden

5.6 Operatoren

Vector3D Face3D TNode

Übersicht


6. Klasse gs_PreferredState

Diese Klasse dient zur Abspeicherung eines bevorzugten Zustandes eines Gelenks.

6.1 Klassenableitung

Für eine Listenfähigkeit ist gs_PreferredState von dem Templateknoten TNode<gs_PreferredState> abgeleitet.

6.2 Klassendefinition

class gs_PreferredState : public TNode<gs_PreferredState>

6.3 Konstruktoren

6.4 Destruktor

6.5 Methoden

TNode

Übersicht


7. Klasse gs_Feature


7.1 Klassenableitung

7.2 Klassendefinition

class gs_Feature : public TNode<gs_Feature>

7.3 Konstruktoren

7.4 Destruktor

7.5 Enum-Variablen

enum Sensor
{
  None=0; CCD, Laser, Radar, Abstrakt
};

7.6 Methoden

7.7 Operatoren


Vector3D TNode

Übersicht


8. Klasse gs_ObjFeature

8.1 Klassenableitung

8.2 Klassendefinition

class gs_ObjFeature : public gs_Feature

8.3 Konstruktoren

8.4 Destruktor

8.5 Enum-Variablen

enum Sensor
{
  None=0; CCD, Laser, Radar, Abstrakt
};

8.6 Methoden

8.7 Operatoren


Vector3D TNode gs_Feature

Übersicht


9. Klasse gs_ClassJoint

Klasse zur Implementierung eines Gelenkes mit verschiedenen Freiheitsgraden. Dient der Speicherung von prototypischen Daten.

9.1 Klassenableitung

9.2 Klassendefinition

class gs_ClassJoint

9.3 Konstruktoren

9.4 Destruktor

9.5 Enum-Variablen

enum Type
{
  Fixed=0, Rotation, Translation
};

9.6 Methoden

RotLat gs_PreferredState

Übersicht


10. Klasse gs_ObjectJoint

Klasse zur Implementierung von verschiedenen Freiheitsgraden eines untergeordneten Elements.

10.1 Klassenableitung

10.2 Klassendefinition

class gs_ObjectJoint

10.3 Konstruktoren

10.4 Destruktor

10.5 Methoden

RotLat Time gs_ClassJoint

Übersicht


11. Klasse gs_Solid

Die virtuelle abstrakte Basisklasse gs_Solid dient als Basis für die verschiedenen Elemente zur Nachbildung eines Körpers.

11.1 Klassenableitung

gs_Solid ist eine Basisklasse für Elemente die eine Listenfähigkeit besitzen sollen. Aus diesem Grund ist gs_Solid von dem Templateknoten TNode<gs_Solid> abgeleitet.

11.2 Klassendefinition

class gs_Solid : public TNode<gs_Solid>

11.3 Konstruktoren

11.4 Destruktor

11.5 Methoden

TNode Vector3D gs_Face3D gs_Feature

Übersicht


12. Klasse gs_Class

Klasse zur Zusammenfassung gemeinsamer Datenstrukturen von Member- und Rootklassen.

12.1 Klassenableitung

Die Klasse gs_Class ist direkt von der Basisklasse gs_Solid abgeleitet.

12.2 Klassendefinition

class gs_Class : public gs_Solid

12.3 Konstruktoren

12.4 Destruktor

12.5 Methoden

TNode Vector3D Face3D gs_Face3D gs_Feature gs_Solid gs_MemberClass

Übersicht


13. Klasse gs_MemberClass

gs_MemberClass implementiert eine untergeordnetes Klassenelement.

13.1 Klassenableitung

gs_MemberClass ist direkt von gs_Class abgeleitet.

13.2 Klassendefinition

class gs_MemberClass : public gs_Class

13.3 Konstruktoren

13.4 Destruktor

13.5 Öffentliche Daten

13.6 Methoden

TNode Vector3D Face3D gs_Face3D gs_Feature gs_Solid gs_MemberClass

Übersicht


14. Klasse gs_RootClass

14.1 Klassenableitung

gs_RootClass ist ebenfalls wie gs_MemberClass von gs_Class abgeleitet.

14.2 Klassendefinition

class gs_RootClass : public gs_Class

14.3 Konstruktoren

14.4 Destruktor

14.5 Methoden

TNode Vector3D Face3D gs_Face3D gs_Feature gs_Solid gs_MemberClass

Übersicht


15. Klasse gs_Object

Klasse zur Zusammenfassung von Gemeinsamkeiten von Objektelementen.

15.1 Klassenableitung

Die Klasse gs_Object ist von der Klasse gs_Solid abgeleitet.

15.2 Klassendefinition

class gs_Object : public gs_Solid

15.3 Konstruktoren

15.4 Destruktor

15.5 Methoden

TNode Vector3D gs_Face3D gs_Feature gs_Solid gs_Class

Übersicht


16. Klasse gs_MemberObject

16.1 Klassenableitung

16.2 Klassendefinition

class gs_MemberObject : public gs_Object

16.3 Konstruktoren

16.4 Destruktor

16.5 Öffentliche Daten

16.6 Methoden

TNode Vector3D Face3D gs_Face3D gs_Feature gs_ObjectJoint gs_Solid gs_Class gs_MemberClass gs_RootClass gs_Object

Übersicht


17. Klasse gs_RootObject

17.1 Klassenableitung

17.2 Klassendefinition

class gs_RootObject : public gs_Object

17.3 Konstruktoren

17.4 Destruktor

17.5 Methoden

TNode Vector3D Face3D BoundBox gs_Face3D gs_Feature gs_Solid gs_RootClass gs_Object

Übersicht


18. Klasse gs_GeoSym

Die Klasse gs_GeoSym ist der zentrale Knoten der Bibliothek geosym. Die Klasse gs_GeoSym verwaltet Klassen und Objekte und gewährt den Zugriff auf einzelne Klassen oder Objekte.

18.1 Klassenableitung

gs_GeoSym ist von keiner anderen Klasse abgeleitet

18.2 Klassendefinition

class gs_GeoSym

18.3 Konstruktoren

18.4 Destruktor

18.5 Enum-Variablen

enum State
{
  min=0, max=1, unknown=-1, cut=-2
};

18.6 Methoden

RotLat BoundBox gs_RootClass gs_RootObject

Übersicht



Stefan Unterholzner
Lehrstuhl für Prozessrechner
Technische Universität München

$Id: geosym.html,v 1.4 1996/06/07 10:15:29 uholzner Exp $