DATAVISA.H

gehe zur Dokumentation dieser Datei

//#############################################################################
//                                                                           //
// DATAVISA.H                                                                //
// Subsystem: Utilities - Datenbank (Diffraktometrie/ Reflektometrie)        //
// Benutzung durch andere Subsysteme erforderlich: JA                        //
// Implementation: M_CURVE.CPP, M_DATA.CPP                                   //
//                                                                           //
//#############################################################################

#ifndef   __DATAVISA_H
#define   __DATAVISA_H

#include "internls\evrythng.h" // TScaleType


//##############################################################################
// globale Deklarationen
//##############################################################################

// gibt an nach welchem Kriterium die Kurve sortiert ist
/* enum TOrder 
{
        X_Sorted = 1, Y_Sorted = 2, Z_Sorted = 3, Incoming = 4
}; 

// Fehlertype bei DatenBasis
enum TCFault 
{
        // max. Anzahl speicherbarer Kurven ist erreicht
        MaxScanExceeded = 1,
        // kein ausreich. Speicherplatz verfuegbar
        NoMemory = 2
};
*/

// Struktur eines Elements der Kurve
struct CPoint 
{
        float Pt[3];
        BOOL Valid;
};

const int MAXCURVE = 5000; // maximal speicherbare Kurven
// const int GROWUNIT = 50; // Punkte, um die die Kurve erweitert wird


//##############################################################################
// TCurve
//##############################################################################

// Klasse zum Verwalten einer Folge von Messwerten und zugehoeriger Parametern
class _CURVECLASS TCurve
{
public:
        // Konstruktor 
        TCurve( void );
        ~TCurve( void );

        // haengt einen Punkt(Tripel) an Kurve an
        // false wenn Fehler, sonst true
        BOOL PAdd( float &x, float &y, float &z );

        // liest ein Wertetripel der Kurve aus
        // false wenn nicht moeglich, sonst true
        BOOL PGet( float &x, float &y, float &z );

        // wie PAdd (um schneller hintereinander Punkte anzuhaengen)
        // false bei Fehler, sonst true
        // BOOL FastPAdd( float &x, float &y, float &z );

        // wie PGet (fuer schnellen Zugriff)
        // Rueckkehrcode false bei Fehler,
        // z.B. Kurve hat keine Punkte, Speicherfehler, usw,
        // sonst true
        // BOOL FastPGet( float &x, float &y, float &z );

        // 'oeffnet' Kurve, macht Zugriffe auf Punkte erst moeglich
        // Rueckkehrcode false bei Fehler sonst true
        // BOOL FastOpen( void );

        // 'schliesst' Kurve, kein Zugriff auf die Punkte moeglich
        // Rueckkehrcode immer true
        // BOOL FastClose( void );

        // geht in der Kurve einen Punkt zurueck (Index zurück setzen)
        void BackStep( void );

        // setzt Kurve auf Initialwerte zurueck
        // Rueckkehrcode gibt an, ob neuer Speicher alloziert wurde
        BOOL New( void );

        // markiert alle Punkte der Kurve als ungueltig, deren Y-wert <= (Level*100)
        // Prozent von maximaler intensitaet der Kurve sind
        // Rueckkehrcode false bei fehler sonst true
        // (nur von GetPeakProperties benutzt)
        BOOL DeleteUnderGround( float Level );

        // setzt achse, nach welcher die Kurve geordnet ist
        // (x,y,z oder messreihenf.)
        // void SetOrder( TOrder order ) {      m_eOrder = order;       };

        // setzt internen zeiger auf den (pos). Wert der Kurve falls moeglich
        // bei unzulaess. pos auf 1. bzw. letzten Wert
        // Rueckkehrcode false wenn Kurve keine Punkte hat sonst true
        BOOL SetPP( int pos= 0 );
        BOOL SetPPLast(); // auf letzten Eintrag setzen

        // liefert die Anzahl der Punkte der Kurve als Rueckkehrcode
        int GetPNumber( void ) { return m_PointList.GetCount(); };

        // berechnet eine durch den letzen Param. bestimmte Fkt
        // (max. Intensitaet/Schwerpunkt)
        // 1.Param(ausg.) x enthaelt nach aufruf je nach funktion berechneten Wert
        // 2.Param(ausg.) y enthaelt nach aufruf je nach funktion berechneten Wert
        // 3.Param(ausg.) z enthaelt nach aufruf je nach funktion berechneten Wert
        // 4.Param(eing.) func ermoeglicht verschieden funktionen aufzurufen
        //                (nur 2 implementiert)
        //                  func=2  dann x,y,z tripel ermitteln, fuer das y (die
        //                          Intensitaet) maximal ist
        //                  func<>2 dann x,y,z Schwerpunkt der Kurve ermitteln
        //                          (wird scheinbar nicht benutzt)
        // Rueckkehrcode false wenn Fehler sonst true
        BOOL GetGravityCenter( float&, float&, float& );
        
        // liefert den in der Kurve vorhandenen dem Param 'search' naehsten X-wert
        // (den indexwert) als Rueckkehrcode zurueck und den zugehoerigen Y-Wert
        // sowie den abstand zwischen X-wert und search
        // 1.param (eingabe) search in Kurve soll nach einem X-punkt gesucht
        //                   werden, der zu search den geringsten abstand besitzt
        // 2.Param (ausgabe) delta enthaelt nach aufruf den Abstand von search
        //                   zum naehsten X-wert
        // 3.Param (ausgabe) value enthaelt nach aufruf den zum naehsten X-wert
        //                   gehoerigen Y-wert(Intensitaet)
        // Rueckkehrcode ist der Index fuer den gilt X[Index] ist naehster X-wert
        // zu search, wenn search im inneren des x-bereichs der Kurve ist sonst
        // (wenn ausserhalb dieses bereiches oder bei fehler) den Wert 0
        // voraussetzung ist, dass die X-werte der kurve von klein nach gross
        // sortiert sind
        int GetValueByValue( float, float&, float& );

        // Zuweisungsoperator fuer Kurven
        // alle x,y,z,v werte sowie max und min werden kopiert
        TCurve& operator=( const TCurve& );

        float GetMax( int Idx ) { return m_MaxList.GetAt(Idx); };
        float GetMin( int Idx ) { return m_MinList.GetAt(Idx); };

        // markiert alle Punkte der Kurve als ungueltig, 
        // laesst nur lokal. Maxima uebrig 
        // Rueckkehrcode false bei Fehler, sonst true
        // 07.04.2004 ToterCode da nicht benutzt und scheinbar nicht fertig impl.
        // BOOL DeleteFlanks();

        // speichert alle Punkte der Kurve in Datei (Parameter) ab
        // Rueckkehrcode false bei fehler, sonst true
        // 07.04.2004 ToterCode da nicht benutzt
        // BOOL Save( LPCSTR );

        // speichert Kurve in Datei (1.Parameter), 2. Param. gibt Art der
        // Speicherung an (nur eine Option impl., diese speichert y-werte),
        // 3. Param. nicht benutzt
        // 07.04.2004 ToterCode da nicht benutzt
        // BOOL Save( LPCSTR, int, int );

        // 07.04.2004 ToterCode da nicht impl.
        // void SetLastPoint( void );

        // addiert val zum Y-wert des akt. Punktes der Kurve
        // Rueckkehrcode false bei Fehler, sonst true
        // 07.04.2004 ToterCode, da nicht benutzt
        // BOOL ValueAdd( float &val ); 

        // liefert akt. Pos. des internen Zeiger der Kurve als Rueckkehrcode
        // 07.04.2004 ToterCode da nicht benutzt
        // int GetPP( void ) {  return ActualIdx; };

        // 07.04.2004 ToterCode da nicht benutzt
        // BOOL       GetReflection( int order, LPCPoint );

        // liefert die Breite des 1.Bereiches, in dem alle y-werte des Tripels
        // die Haelfte des Intensitaetbereichs(Y(max)-Y(min)) uebersteigen, sowie
        // aus diesem Bereich x-wert,y-wert des Tripels fuer das Y-wert
        // (Intensitaet) maximal ist
        // 1. bereich bedeutet der am weitesten links liegende Bereich der obige
        //     Eigenschaften erfuellt
        // 1.Param(ausgabe) hw enthaelt nach aufruf breite des Bereichs
        // 2.Param(ausgabe) pos enthaelt nach aufruf X-wert an der max. y-wert
        //                      (intensitaet) in diesem Bereich
        // 3.Param(ausgabe) intens enthaelt nach aufruf max.y-wert(intensitaet)
        //                         in diesem Bereich
        // Rueckkehrcode false wenn fehler sonst true
        // anmerkung: dieser Bereich darf nicht bis ans ende der Kurve reichen
        // d.h. kurve darf nicht monoton wachsend sein (sonst return false)
        // 07.04.2004 ToterCode da nicht benutzt
        // BOOL GetPeakProperties( float&, float&, float& );

private:

        // enthalten die min und max Werte der 3 Achsen [0=x,1=y,2=z]
        TFloatList m_MinList;
        TFloatList m_MaxList;

        TPointList m_PointList;

        int m_ActualIdx;      // indiziert den aktuellen Eintrag
        BOOL m_bEnd;        // Ende-Erkennung

        // HGLOBAL m_hMemX; // handle auf globales speicherobjekt (x-werte)

        // Ordnung der Kurve  X_sorted, Y_sorted, Z_sorted oder Incoming
        // TOrder m_eOrder;

        // zeigt an ob kurve gerade im speicher fix. und somit zugriffe moeglich
        // BOOL m_bStreamOpen;
        
        // int m_MaxPointIdx;    // indiziert den letzten Eintrag
        // int m_MaxMemIdx;      // indiziert den maximal moeglichen Eintrag
        // CPoint FAR *m_lpPX;  // Zeiger auf Datenfeld von X
};

typedef TCurve FAR *LPCurve;

//##############################################################################
// TDataBase
//##############################################################################

// Klasse zum Verwalten von mehreren Kurven (Areascan)
class _CURVECLASS TDataBase : protected TIndList {
public:
        TDataBase( void );
        ~TDataBase( void );

        // setzt internen Kurvenindex auf 0
        void Reset( void ) { m_ActualIdx = 0; };

        // liefert die Kurve als Rueckkehrcode deren Nummer gleich dem
        // uebergebenen Param. ist
        TCurve *GetCurve( int );
        TCurve *GetLastCurve(); // letzte Curve

        // liefert als Rueckkehrcode akt. Kurvenindex
        int GetCurveIdx( void ) { return m_ActualIdx; };

        // setzt Kurvenindex auf angegebenen Wert (Parameter)
        BOOL SetCurveIdx( int );

        // Rueckkehrcode = Anzahl der Kurven
        int GetCNumber( void ) { 
                return GetCount();
        };

        // liefert als Rueckkehrcode die Scanreportcurve
        TCurve *GetScanReport( void ) { return m_ScanReport; };

        // fuegt eine Kurve der angegebenen Groesse zur Datenbasis hinzu
        // Rueckkehrcode true wenn erfolgreich
        BOOL AddCurve( void );

        // loescht alle Kurven der Datenbasis und setzt Indizes zurueck
        BOOL New( void );

        // liefert als Rueckkehrcode die Anzahl maximal speicherbarer Kurven pro Datenbasis 
        int GetMaxScanNumber( void ) 
        { 
                return MAXCURVE - 1; // eigentlich unbegrenzt, soll aber sicherstellen, dass im AreaScan nicht nahezu unendliche viele Schritte durchgeführt werden
        };

        // liefert als Rueckkehrcode den zuletzt aufgetretenen Fehler
        //24.03.2004 TCFault GetFault( void ) { return m_eFault; };

        // neu akk
        // entfernt die letzte Kurve in der Datenbasis
        // Rueckkehrcode FALSE wenn Datenbasis leer
        // sonst TRUE
        BOOL DelCurve( void);

private:
        //  zuletzt aufgetretenen Fehler
        //24.03.2004 TCFault m_eFault;
        int m_ActualIdx;     // indiziert die aktuelle Kurve

        // Kurve enthaelt Werte zu jeder Kurve der Datenbasis
        // Omegawinkel,Thetawinkel(absoluten winkel) und je nach modus einen
        // dritten wert (monitorintens., absorberpos.,integrale intens. ,...)
        TCurve *m_ScanReport;
};

typedef TDataBase FAR * LPDataBase;

#endif 
//DATAVISA_H
// __LastLine__

---