TRANSFRM.H

gehe zur Dokumentation dieser Datei

#ifndef __TRANSFRM_H
#define __TRANSFRM_H

// Definition von Konstanten zur Festlegung der Transformationsreihenfolge
const unsigned XYZ= REIHENFOLGE_XYZ;
const unsigned ZYX= REIHENFOLGE_ZYX;


// Aufzählungstyp zur komfortablen Angabe der Koordinatensystemdrehachse
// bei Benutzung wird angegeben, um welche Achse eine KS-Drehung
// durchgeführt werden soll
enum EDrehachse
{
        Drehachse_X= 1,
        Drehachse_Y,
        Drehachse_Z
};

// Aufzählungstyp zur komfortablen Angabe der Optimierungsachse
// bei Benutzung wird angegeben, auf welcher Achse der
// Optimierungsalgorithmus das Maximum der Intensität suchen soll
enum ELaufachse
{
        Laufachse_X= 1,
        Laufachse_Y,
        Laufachse_Z
};


// Transformationsklasse
// zur Durchführung von Koordinatentransformationen
class TransformationClass
{
private:

        // Listen zur Abspeicherung der Transformationsmatrizen
        TMatrizenListe trafo_hin;
        TMatrizenListe trafo_rueck;

        // Zähler für durchgeführte KS-Transformationen
        unsigned anzahl_koordinatentrafos;

        // Ursprungsmotorpositionen und -intervalle
        TMotorPositionsWerte Wertebereich;

        // Zeichenpuffer für Protokollierung
        char *buf, *buf1;

public:
        // Vektor der akt. Koordinatenpositionen
        TVektor PosVektor;
        // Größe des letzten Intervalls beim Goldenen Schnitt
        float toleranz;
        // gibt an, ob eine Überschreitung der
        // max. zulässigen Detektorintensität auftrat (100.000 Counts)
        bool bIntensityTooHigh;

        TransformationClass(void);
        // Kontruktor

        virtual  ~TransformationClass(void);
        // Destruktor

        bool Initialize(double MaxDF, double MaxTL, double MaxCC);
        // Initialisierung der Transformationsklasse
        // 1. Ermittlung der aktuellen Motorpositionen und
        // 2. Festlegen der Intervallgrenzen zur Justage

        TVektor translate_to_worldpoints(TVektor OrigVektor);
        // Berechnung der Weltkoordinaten eines Punktes im akt. KS
        // 1. vektor homogen machen
        // 2. (HIN-Transformation)
        //    Multiplikation des homog. Vektors mit den Trafo-Matrizen von Anfang an
        // 3. Rückgabe des Vektors in kartesischer Form

        TVektor translate_from_worldpoints(TVektor OrigVektor);
        // Umrechnung eines Punktes im Welt-KS in Koordinaten im akt. KS
        // 1. vektor homogen machen
        // 2. (RÜCK-Transformation)
        //    Multiplikation des homog. Vektors mit den Trafo-Matrizen
        //    vom Ende der Liste bis zum Anfang
        // 3. Rückgabe des Vektors in kartesischer Form

        TMotorPositionsWerte translate_PosBorders(void);
        // Übersetzung der Intervalle in akt. Koordinaten
        // unbedingt mit Vergleich der Softwareschranken !!!
        // d.h. notwendige Rückrechnung (translate_to_worldpoints)
        // der akt. Schranken in Weltkoordinaten
        // aktSchranke(x,y,z) -> weltkoord_aktSchranke(x_w,y_w,z_w)
        // x_w-Werte mit Wertebereich.Min/MaxTL bzw. Softwareschranke vergl. usw.

        float GetIntensityOnPosition(unsigned nMeasureCount);
        // fährt die zu übersetzenden (TRAFO Klasse) Motorpositionen des PosVektors an
        // und gibt Intensität zurück(Bestimmung der durch Medianbestimmung über
        // mehreren Messungen mgl. durch Übergabe von nMeasureCount)
        // muss alle 3 Motorachsen anfahren
        // 1. translate_to_worldpoints(akt.anzufahrenderPosVektor)
        // 2. worldkoordinaten-Vektor.get_XYZ(&x,&y,&z)
        // 3. nMotorTL mMoveToDistance (x + Wertebereich.OrigTL) weil Ursprung (0,0,0)
        //    nMotorDF mMoveToDistance (y + Wertebereich.OrigDF)
        //    nMotorCC mMoveToDistance (z + Wertebereich.OrigCC)
        // 4. Rückgabe der Intensität

        int Goldener_Schnitt(ELaufachse, double &intervall_li, double &intervall_re,
                                                 unsigned nMeasureCount);
        // bekommt aktuelle Koordinaten (Grenzen, akt. PosVektor)
        // und rechnet nur im akt. KS für eine bestimmte Achse (x,y,z)
        // erst der Aufruf von GetIntensityOnPosition(vektor) führt zu einer
        // Bestimmung der realen Positionen

        TMotorPositionsWerte GetOrigPosBorders(void)
        {
                return Wertebereich;
        }
        // gibt die Wertebereiche der Motoren zurück

        bool KoordinatenTransformation(EDrehachse, TVektor vVerschiebung);
        // 1. Berechnung des Winkels von vektor zur Dreh-Achse (Einheitsvektor)
        // 2. Aufruf der transformiere-Methode der Matrix-Klasse
        //    HIN : transformiere(XYZ, ... )
        //    RÜCK: transformiere(ZYX, ... )
        // 3. Matrizenliste.push(hin)
        //    Matrizenliste.push(rück)
        // 4. anzahl_koordinatentrafos ++

        unsigned get_koordinatentrafos(void)
        {
                return anzahl_koordinatentrafos;
        }
        // gibt die Anzahl der KS-Transformationen zurück

        float MeasureIntensity(unsigned nMeasureCount);
        // sicheres Auslesen der Intensität vom Detektor
        // Möglichkeit einer Mehrfachmessung mit Medianbestimmung, um
        // Messschwankungen auszugleichen


        void DFCorrection(unsigned nMeasureCount, double & fDFPos, float & fIntensity);
        // Korrektur für die Motorachse "Beugung Fein"
        // Grund: Wenn die Position der maximalen Intensität am Ende der Suche wieder
        //        angefahren wird, dann ist die Intensität nicht mehr die gleiche
        //        die gemessen wurde. Die Position ist leicht verschoben.
        // Lösung: DFCorrection soll in der näheren Umgebung das Maximum wieder finden

};


#endif

---