1 #ifndef __TRANSFRM_H
    2 #define __TRANSFRM_H
    3 
    4 // Definition von Konstanten zur Festlegung der Transformationsreihenfolge
    5 const unsigned XYZ= REIHENFOLGE_XYZ;
    6 const unsigned ZYX= REIHENFOLGE_ZYX;
    7 
    8 
    9 // Aufzählungstyp zur komfortablen Angabe der Koordinatensystemdrehachse
   10 // bei Benutzung wird angegeben, um welche Achse eine KS-Drehung
   11 // durchgeführt werden soll
   12 enum EDrehachse
   13 {
   14         Drehachse_X= 1,
   15         Drehachse_Y,
   16         Drehachse_Z
   17 };
   18 
   19 // Aufzählungstyp zur komfortablen Angabe der Optimierungsachse
   20 // bei Benutzung wird angegeben, auf welcher Achse der
   21 // Optimierungsalgorithmus das Maximum der Intensität suchen soll
   22 enum ELaufachse
   23 {
   24         Laufachse_X= 1,
   25         Laufachse_Y,
   26         Laufachse_Z
   27 };
   28 
   29 
   30 // Transformationsklasse
   31 // zur Durchführung von Koordinatentransformationen
   32 class TransformationClass
   33 {
   34 private:
   35 
   36         // Listen zur Abspeicherung der Transformationsmatrizen
   37         TMatrizenListe trafo_hin;
   38         TMatrizenListe trafo_rueck;
   39 
   40         // Zähler für durchgeführte KS-Transformationen
   41         unsigned anzahl_koordinatentrafos;
   42 
   43         // Ursprungsmotorpositionen und -intervalle
   44         TMotorPositionsWerte Wertebereich;
   45 
   46         // Zeichenpuffer für Protokollierung
   47         char *buf, *buf1;
   48 
   49 public:
   50         // Vektor der akt. Koordinatenpositionen
   51         TVektor PosVektor;
   52         // Größe des letzten Intervalls beim Goldenen Schnitt
   53         float toleranz;
   54         // gibt an, ob eine Überschreitung der
   55         // max. zulässigen Detektorintensität auftrat (100.000 Counts)
   56         bool bIntensityTooHigh;
   57 
   58         TransformationClass(void);
   59         // Kontruktor
   60 
   61         virtual  ~TransformationClass(void);
   62         // Destruktor
   63 
   64         bool Initialize(double MaxDF, double MaxTL, double MaxCC);
   65         // Initialisierung der Transformationsklasse
   66         // 1. Ermittlung der aktuellen Motorpositionen und
   67         // 2. Festlegen der Intervallgrenzen zur Justage
   68 
   69         TVektor translate_to_worldpoints(TVektor OrigVektor);
   70         // Berechnung der Weltkoordinaten eines Punktes im akt. KS
   71         // 1. vektor homogen machen
   72         // 2. (HIN-Transformation)
   73         //    Multiplikation des homog. Vektors mit den Trafo-Matrizen von Anfang an
   74         // 3. Rückgabe des Vektors in kartesischer Form
   75 
   76         TVektor translate_from_worldpoints(TVektor OrigVektor);
   77         // Umrechnung eines Punktes im Welt-KS in Koordinaten im akt. KS
   78         // 1. vektor homogen machen
   79         // 2. (RÜCK-Transformation)
   80         //    Multiplikation des homog. Vektors mit den Trafo-Matrizen
   81         //    vom Ende der Liste bis zum Anfang
   82         // 3. Rückgabe des Vektors in kartesischer Form
   83 
   84         TMotorPositionsWerte translate_PosBorders(void);
   85         // Übersetzung der Intervalle in akt. Koordinaten
   86         // unbedingt mit Vergleich der Softwareschranken !!!
   87         // d.h. notwendige Rückrechnung (translate_to_worldpoints)
   88         // der akt. Schranken in Weltkoordinaten
   89         // aktSchranke(x,y,z) -> weltkoord_aktSchranke(x_w,y_w,z_w)
   90         // x_w-Werte mit Wertebereich.Min/MaxTL bzw. Softwareschranke vergl. usw.
   91 
   92         float GetIntensityOnPosition(unsigned nMeasureCount);
   93         // fährt die zu übersetzenden (TRAFO Klasse) Motorpositionen des PosVektors an
   94         // und gibt Intensität zurück(Bestimmung der durch Medianbestimmung über
   95         // mehreren Messungen mgl. durch Übergabe von nMeasureCount)
   96         // muss alle 3 Motorachsen anfahren
   97         // 1. translate_to_worldpoints(akt.anzufahrenderPosVektor)
   98         // 2. worldkoordinaten-Vektor.get_XYZ(&x,&y,&z)
   99         // 3. nMotorTL mMoveToDistance (x + Wertebereich.OrigTL) weil Ursprung (0,0,0)
  100         //    nMotorDF mMoveToDistance (y + Wertebereich.OrigDF)
  101         //    nMotorCC mMoveToDistance (z + Wertebereich.OrigCC)
  102         // 4. Rückgabe der Intensität
  103 
  104         int Goldener_Schnitt(ELaufachse, double &intervall_li, double &intervall_re,
  105                                                  unsigned nMeasureCount);
  106         // bekommt aktuelle Koordinaten (Grenzen, akt. PosVektor)
  107         // und rechnet nur im akt. KS für eine bestimmte Achse (x,y,z)
  108         // erst der Aufruf von GetIntensityOnPosition(vektor) führt zu einer
  109         // Bestimmung der realen Positionen
  110 
  111         TMotorPositionsWerte GetOrigPosBorders(void)
  112         {
  113                 return Wertebereich;
  114         }
  115         // gibt die Wertebereiche der Motoren zurück
  116 
  117         bool KoordinatenTransformation(EDrehachse, TVektor vVerschiebung);
  118         // 1. Berechnung des Winkels von vektor zur Dreh-Achse (Einheitsvektor)
  119         // 2. Aufruf der transformiere-Methode der Matrix-Klasse
  120         //    HIN : transformiere(XYZ, ... )
  121         //    RÜCK: transformiere(ZYX, ... )
  122         // 3. Matrizenliste.push(hin)
  123         //    Matrizenliste.push(rück)
  124         // 4. anzahl_koordinatentrafos ++
  125 
  126         unsigned get_koordinatentrafos(void)
  127         {
  128                 return anzahl_koordinatentrafos;
  129         }
  130         // gibt die Anzahl der KS-Transformationen zurück
  131 
  132         float MeasureIntensity(unsigned nMeasureCount);
  133         // sicheres Auslesen der Intensität vom Detektor
  134         // Möglichkeit einer Mehrfachmessung mit Medianbestimmung, um
  135         // Messschwankungen auszugleichen
  136 
  137 
  138         void DFCorrection(unsigned nMeasureCount, double & fDFPos, float & fIntensity);
  139         // Korrektur für die Motorachse "Beugung Fein"
  140         // Grund: Wenn die Position der maximalen Intensität am Ende der Suche wieder
  141         //        angefahren wird, dann ist die Intensität nicht mehr die gleiche
  142         //        die gemessen wurde. Die Position ist leicht verschoben.
  143         // Lösung: DFCorrection soll in der näheren Umgebung das Maximum wieder finden
  144 
  145 };
  146 
  147 
  148 #endif
  149