File: DATAVISA\M_CURVE.CPP
1 //#############################################################################
2 // //
3 // M_CURVE.CPP //
4 // Subsystem: Utilities - Datenbank (Diffraktometrie/ Reflektometrie) //
5 // Benutzung durch andere Subsysteme erforderlich: JA //
6 // Deklaration: DATAVISA.H //
7 // //
8 //#############################################################################
9
10 #include "internls\evrythng.h" // GermanVersion
11 #include "datavisa\datavisa.h"
12
13 //#############################################################################
14 // sprachspezische Konstanten
15 //#############################################################################
16
17 #ifdef GermanVersion
18 static const char _FreeingDataBase[] = "Datenbasis wird freigegeben, bitte haben Sie etwas Geduld...";
19 static const char _NoMemory[] = "Fehler, nicht genuegend Speicher!";
20 #else
21 static const char _FreeingDataBase[] = "freeing database, please stand by...";
22 static const char _NoMemory[] = "Failure, not enough memory!"; 23 #endif
24
25 //##############################################################################
26 // TCurve
27 //##############################################################################
28
29 // -----------------------------------------------------------------------------
30 // hier werden die Messwerte eines Scans abgelegt
31 // x-Wert = Motorwinkel (standard/continuous)
32 // = Omegamotorwinkel (Omega2Theta)
33 // y-wert = gemessene Intensitaet des Detektors in dieser Position
34 // z-wert = 0 (standard/continuous) kein Monitor ausgewaehlt
35 // = Monitorintensitaet (standard) Monitor ausgewaehlt
36 // = Thetamotorwinkel (Omega2Theta)
37 // -----------------------------------------------------------------------------
38 // Konstruktor
39 TCurve::TCurve( void ) : m_PointList(0, 512), m_MinList(3, 1000000.0, 3), m_MaxList(3, -1000000.0, 3)
40 {
41 // m_bStreamOpen = FALSE;
42 m_ActualIdx = -1;
43 m_bEnd = FALSE;
44 };
45
46 // -----------------------------------------------------------------------------
47 // Destruktor
48 TCurve::~TCurve( void )
49 {
50 New();
51 };
52
53 // -----------------------------------------------------------------------------
54 // Kurve auf Initialwerte zuruecksetzen
55 BOOL TCurve::New( void )
56 {
57 m_ActualIdx = -1;
58 // m_bEnd = FALSE;
59 m_MaxList.SetAt(0, -1000000.0);
60 m_MaxList.SetAt(1, -1000000.0);
61 m_MaxList.SetAt(2, -1000000.0);
62
63 m_MinList.SetAt(0, 1000000.0);
64 m_MinList.SetAt(1, 1000000.0);
65 m_MinList.SetAt(2, 1000000.0);
66
67 m_PointList.Clear();
68 return TRUE;
69 };
70
71 // -----------------------------------------------------------------------------
72 // Index des aktuellen Punktes (Tripels) um 1 zuruecksetzen und 'Kurvenstatus' auf nicht fertig setzen
73 void TCurve::BackStep( void )
74 {
75 m_bEnd = FALSE;
76 if ( m_ActualIdx > 0 ) --m_ActualIdx;
77 };
78
79 // -----------------------------------------------------------------------------
80 // Zuweisungsoperator fuer Kurven
81 TCurve& TCurve::operator=( TCurve& crv )
82 {
83 // wenn Kurve sich selbst zugewiesen dann Pointer auf Kurve zurueckgeben
84 if ( this == &crv ) return *this;
85
86 // alle Parameter zuruecksetzen
87 m_bEnd = FALSE;
88 m_ActualIdx = -1;
89
90 m_MinList = crv.m_MinList;
91 m_MaxList = crv.m_MaxList;
92 m_PointList = crv.m_PointList;
93
94 return *this;
95 };
96
97 // -----------------------------------------------------------------------------
98 // 06.05.2004 redundant zu PGet, deshalb ueberall durch PGet ersetzt
99 // liest ein Wertetripel aus Kurve aus (am aktuellen Index)
100 // Funktion verzichtet auf allgem. Aufruf von FastOpen und FastClose und
101 // ermöglicht so schnelle Abfolge von Punktauslesungen
102 /* BOOL TCurve::FastPGet( float &x, float &y, float &z )
103 {
104 // Abbruch wenn Kurvenende erreicht oder Kurve keine Punkte hat oder
105 // wenn Kurve nicht offen und auch nicht zu oeffnen
106 if ( (m_bEnd) || ( m_PointList.GetCount() == 0 ) || ((!m_bStreamOpen) && (!FastOpen())) ) return FALSE;
107
108 x = y = z = 0.0; // bei Fehler wenigstens 0 zurueckliefern
109
110 // Abbruch wenn Kurvenende erreicht oder Kurve keine Punkte hat oder
111 // wenn Kurve nicht offen und auch nicht zu oeffnen
112 if ( (m_bEnd) || ( m_PointList.GetCount() == 0 ) || ((!m_bStreamOpen) && (!FastOpen())) ) return FALSE;
113
114 if ( !(m_PointList.GetAt(m_ActualIdx).Valid) ) return FALSE;
115 x = m_PointList.GetAt(m_ActualIdx).Pt.GetAt(0);
116 y = m_PointList.GetAt(m_ActualIdx).Pt.GetAt(1);
117 z = m_PointList.GetAt(m_ActualIdx).Pt.GetAt(2);
118
119 // ist Kurvenende bei naechstem Aufruf erreicht
120 m_bEnd = ( m_ActualIdx == ((m_PointList.GetCount())-1) );
121 if ( !m_bEnd ) m_ActualIdx++;
122 }; */
123
124 // -----------------------------------------------------------------------------
125 // gibt ein Wertetripel aus der Kurve zurueck
126 BOOL TCurve::PGet( float &x, float &y, float &z )
127 {
128 // merkt sich ob kurve bei aufruf geoeffnet war
129 // BOOL bWasOpen = m_bStreamOpen;
130 x = y = z = 0.0; // bei Fehler wenigstens 0 zurueckliefern
131
132 // Abbruch wenn Kurvenende erreicht oder Kurve keine Punkte hat oder
133 // wenn Kurve nicht offen und auch nicht zu oeffnen
134 if ( ( m_PointList.GetCount() == 0 ) || m_bEnd )
135 /* || ((!m_bStreamOpen) && (!FastOpen()))*/ return FALSE;
136
137 if ( !(m_PointList.GetAt(m_ActualIdx).Valid) ) return FALSE;
138 x = m_PointList.GetAt(m_ActualIdx).GetAt(0);
139 y = m_PointList.GetAt(m_ActualIdx).GetAt(1);
140 z = m_PointList.GetAt(m_ActualIdx).GetAt(2);
141
142
143 m_bEnd = ( m_ActualIdx == (m_PointList.GetCount()-1) );
144 if ( !m_bEnd ) m_ActualIdx++;
145
146 // kurve wieder schliessen wenn sie am anfang geoeffnet war
147 // if ( !bWasOpen ) FastClose();
148 return TRUE;
149 };
150
151 // -----------------------------------------------------------------------------
152 // 06.05.2004 nicht mehr benoetigt, da m_bStreamOpen aukommentiert
153 // 'oeffnet' Kurve, damit Auslesen oder Punkt anhaengen moeglich ist
154 /* BOOL TCurve::FastOpen( void )
155 {
156 // test ob Kurve schon geoeffnet wenn ja schliessen
157 // if ( m_bStreamOpen ) FastClose();
158
159 // m_bStreamOpen = TRUE;
160 return TRUE;
161 }; */
162
163 // -----------------------------------------------------------------------------
164 // 06.05.2004 nicht mehr benoetigt, da m_bStreamOpen aukommentiert
165 // 'schliesst' Kurve und Zugriffe auf Kurve nicht moeglich
166 /* BOOL TCurve::FastClose( void )
167 {
168 // m_bStreamOpen = FALSE;
169 return TRUE;
170 }; */
171
172 // -----------------------------------------------------------------------------
173 // 06.05.2004 redundant zu PAdd, deshalb ueberall durch PAdd ersetzt
174 // anhaengen eines Punktes(tripel) x,y,z an die Kurve
175 // diese Funktion verzichtet auf unbed. aufruf von FastOpen und FastClose und
176 // ist damit fuer eine schnelle Abfolge von Punkthinzufuegungen geeignet
177 /* BOOL TCurve::FastPAdd( float &x, float &y, float &z )
178 {
179 // wenn Punktanzahl der Kurve langsam die max. moegl. Punktanz. erreicht oder
180 // wenn Kurve nicht geoeffnet dann Versuch FastOpen() zu rufen
181 // Abbruch wenn dies nicht moeglich
182 // if ( ((m_MaxPointIdx > (m_MaxMemIdx - 5))
183 // if ((!m_bStreamOpen) && (!FastOpen()) ) return FALSE;
184
185 m_bEnd = FALSE;
186
187 TPoint pkt;
188 pkt.Pt.SetAt(0, x);
189 pkt.Pt.SetAt(1, y);
190 pkt.Pt.SetAt(2, z);
191 pkt.Valid= TRUE;
192 if (!m_PointList.Append(pkt)) {
193 MessageBox( GetFocus(), _NoMemory, "TCurve", MBSTOP );
194 return FALSE;
195 }
196 m_ActualIdx++;
197
198 // testen ob x,y,z wert des neuen Punktes ein m_Min bzw. m_Max sind wenn ja
199 // diese als neues min. bzw. max. uebernehmen
200
201 if ( m_MaxList.GetAt(0) < m_PointList.GetAt(m_ActualIdx).Pt.GetAt(0) )
202 m_MaxList.SetAt(0, m_PointList.GetAt(m_ActualIdx).Pt.GetAt(0) );
203 if ( m_MinList.GetAt(0) > m_PointList.GetAt(m_ActualIdx).Pt.GetAt(0) )
204 m_MinList.SetAt(0, m_PointList.GetAt(m_ActualIdx).Pt.GetAt(0) );
205 if ( m_MaxList.GetAt(1) < m_PointList.GetAt(m_ActualIdx).Pt.GetAt(1) )
206 m_MaxList.SetAt(1, m_PointList.GetAt(m_ActualIdx).Pt.GetAt(1) );
207 if ( m_MinList.GetAt(1) > m_PointList.GetAt(m_ActualIdx).Pt.GetAt(1) )
208 m_MinList.SetAt(1, m_PointList.GetAt(m_ActualIdx).Pt.GetAt(1) );
209 if ( m_MaxList.GetAt(2) < m_PointList.GetAt(m_ActualIdx).Pt.GetAt(2) )
210 m_MaxList.SetAt(2, m_PointList.GetAt(m_ActualIdx).Pt.GetAt(2) );
211 if ( m_MinList.GetAt(2) > m_PointList.GetAt(m_ActualIdx).Pt.GetAt(2) )
212 m_MinList.SetAt(2, m_PointList.GetAt(m_ActualIdx).Pt.GetAt(2) );
213
214 return TRUE;
215 }; */
216
217 // -----------------------------------------------------------------------------
218 // haengt ein Punkttripel an die Kurve an
219 BOOL TCurve::PAdd( float &x, float &y, float &z )
220 {
221 // kann Kurve geoeffnet werden, ggf. wird Kurve verlängert
222 // if ( !FastOpen() ) return FALSE;
223
224 m_bEnd = FALSE;
225
226 TPoint pkt;
227 pkt.SetAt(0, x);
228 pkt.SetAt(1, y);
229 pkt.SetAt(2, z);
230 pkt.Valid= TRUE;
231 if (!m_PointList.Append(pkt)) {
232 MessageBox( GetFocus(), _NoMemory, "TCurve", MBSTOP );
233 return FALSE;
234 }
235 m_ActualIdx++;
236
237 // testen ob x,y,z wert des neuen Punktes ein m_Min bzw. m_Max sind wenn ja
238 // diese als neues min. bzw. max. uebernehmen
239
240 if ( m_MaxList.GetAt(0) < m_PointList.GetAt(m_ActualIdx).GetAt(0) )
241 m_MaxList.SetAt(0, m_PointList.GetAt(m_ActualIdx).GetAt(0) );
242 if ( m_MinList.GetAt(0) > m_PointList.GetAt(m_ActualIdx).GetAt(0) )
243 m_MinList.SetAt(0, m_PointList.GetAt(m_ActualIdx).GetAt(0) );
244 if ( m_MaxList.GetAt(1) < m_PointList.GetAt(m_ActualIdx).GetAt(1) )
245 m_MaxList.SetAt(1, m_PointList.GetAt(m_ActualIdx).GetAt(1) );
246 if ( m_MinList.GetAt(1) > m_PointList.GetAt(m_ActualIdx).GetAt(1) )
247 m_MinList.SetAt(1, m_PointList.GetAt(m_ActualIdx).GetAt(1) );
248 if ( m_MaxList.GetAt(2) < m_PointList.GetAt(m_ActualIdx).GetAt(2) )
249 m_MaxList.SetAt(2, m_PointList.GetAt(m_ActualIdx).GetAt(2) );
250 if ( m_MinList.GetAt(2) > m_PointList.GetAt(m_ActualIdx).GetAt(2) )
251 m_MinList.SetAt(2, m_PointList.GetAt(m_ActualIdx).GetAt(2) );
252
253 // FastClose(); // Kurve schliessen
254 return TRUE;
255 };
256
257 // -----------------------------------------------------------------------------
258 // liefert den zu search naechsten X-Wert (den Indexwert) als Rueckgabewert
259 // und den zu X zugehoerigen Y-Wert sowie den Abstand zwischen X-wert und search
260 // 1.param (search): in Kurve soll nach einem X-punkt gesucht werden,
261 // der zu search den geringsten Abstand besitzt
262 // 2.Param (delta) : enthaelt nach Aufruf den Abstand von search zum X-wert
263 //
264 // 3.Param (value) : enthaelt den zum X-Wert gehoerigen Y-wert (Intensitaet)
265 // Rueckgabewert : ist der Index X[Index] des naehsten X-wert zu search
266 // wenn search im inneren des x-bereichs der Kurve ist,
267 // sonst 0
268 // Voraussetzung ist, das die X-werte der Kurve aufsteigend sortiert sind
269 int TCurve::GetValueByValue( float search, float &delta, float &y )
270 {
271 int Sign, Idx, NewIdx;
272
273 delta = y = 0.0; // bei Fehler 0
274
275 if ( (m_PointList.GetCount() == 0) || // hat Kurve ueberhaupt Punkte
276 ((search > m_MaxList.GetAt(0)) || ( search < m_MinList.GetAt(0) )) /* || // ist search im X-Bereich
277 (!FastOpen()) */ ) return 0; // laesst Kurve sich oeffnen
278
279 // binaere Suche in X-werten der kurve
280 Idx = NewIdx = m_PointList.GetCount() / 2;
281 while ( NewIdx )
282 {
283 NewIdx /= 2;
284 Sign = ( search > m_PointList.GetAt(Idx).GetAt(0) ) ? 0 : 1;
285 if ( Sign ) Idx -= NewIdx;
286 else Idx += NewIdx;
287 };
288 // wenn search zwischen zwei x-werten dann naeheren nehmen
289 if ( Sign )
290 if ( ( search - m_PointList.GetAt(Idx).GetAt(0) ) > ( m_PointList.GetAt(Idx+1).GetAt(0) - search ) )
291 Idx++;
292 else if ( ( search - m_PointList.GetAt(Idx-1).GetAt(0) ) > ( m_PointList.GetAt(Idx).GetAt(0) - search ) )
293 Idx++;
294 // ausgabeparameter belegen + kurve schliessen
295 y = m_PointList.GetAt(Idx).GetAt(1);
296 delta = search - m_PointList.GetAt(Idx).GetAt(0);
297 // FastClose();
298 return Idx;
299 };
300
301 // -----------------------------------------------------------------------------
302 // setzt den Index des aktuellen Tripels auf den angegebenen Wert
303 BOOL TCurve::SetPP( int aIdx )
304 {
305 // test ob Kurve punkte hat
306 if ( m_PointList.GetCount() == 0 ) return FALSE;
307
308 m_ActualIdx = min( m_PointList.GetCount()-1, max( aIdx, 0 ) );
309 m_bEnd = FALSE;
310 return TRUE;
311 };
312
313 BOOL TCurve::SetPPLast()
314 {
315 return SetPP( GetPNumber() - 1 );
316 }
317
318 // -----------------------------------------------------------------------------
319 // berechnet eine durch den letzen Parameter bestimmte Fkt
320 // entweder maximale Intensitaet oder Schwerpunkt
321 BOOL TCurve::GetGravityCenter( float &x, float &y, float &z )
322 {
323 int IdxMax;
324
325 if ( (m_PointList.GetCount()-1) < 2 ) return FALSE; // wenn zu wenig Punkte, Abbruch
326
327 // tripel mit max y-Werte bestimmen
328 IdxMax = 0;
329 for ( int Idx = 0; Idx < m_PointList.GetCount(); Idx++ )
330 {
331 if ( m_PointList.GetAt(Idx).GetAt(1) > m_PointList.GetAt(IdxMax).GetAt(1) ) IdxMax = Idx;
332 };
333 // uebergeben des max. y-werte und der zugehoerigen x,z werte
334 x = m_PointList.GetAt(IdxMax).GetAt(0);
335 y = m_PointList.GetAt(IdxMax).GetAt(1);
336 z = m_PointList.GetAt(IdxMax).GetAt(2);
337
338 // 13.04.2004 TOTER CODE
339 // Funktion hatte 4.Parameter (func) fuer ein switch
340 // mit func=2 x,y,z tripel ermitteln, mit y maximal
341 // mit func<>2 dann x,y,z Schwerpunkt der Kurve ermitteln
342 // die Schwerpunktberechnung wird aber nie benutzt
343 /*
344 default: // berechnet Schwerpunkt
345 integral = weigth = 0.0;
346 dx = m_lpPX[1].Pt[0] - m_lpPX[0].Pt[0];
347 for ( Idx = 0; Idx <= m_MaxPointIdx; Idx++ )
348 {
349 weigth += m_lpPX[Idx].Pt[1] * dx;
350 integral += m_lpPX[Idx].Pt[1] * (Idx * dx) * dx;
351 }
352 if (weigth) x = ( integral / weigth );
353
354 for ( idx = 0; idx <= m_MaxPointIdx; idx++ )
355 {
356 if ( m_lpPX[ idx ].Pt[0] >= x )
357 {
358 y = m_lpPX[ idx ].Pt[1];
359 z = m_lpPX[ idx ].Pt[2];
360 break;
361 }
362 }
363 break;
364 */
365 return TRUE;
366 };
367
368 // -----------------------------------------------------------------------------
369 // markiert alle Tripel der Kurve als ungueltig, deren Y-Wert(Intensitaet)
370 // kleiner als Level * Intensitaetsbereich (max.Y- min.Y) ist
371 // 1.Param: nur Werte 0 <= aLevel <= 1 sind sinnvoll
372
373 BOOL TCurve::DeleteUnderGround( float aLevel )
374 {
375 if ( m_PointList.GetCount() == 0 ) return FALSE; // hat die Kurve Punkte
376
377 // Schwellwert den Y ueberschreiten muss, muss gueltig sein
378 float PeakMin = ( m_MaxList.GetAt(1) - m_MinList.GetAt(1) ) * aLevel;
379
380 // Kurve durchlaufen und alle Tripel als ungueltig kennzeichnet
381 // deren Y-Werte den Schwellwert nicht ueberschreiten
382 for ( int Idx = 0; Idx < m_PointList.GetCount(); Idx++ )
383 {
384 if ( ( m_PointList.GetAt(Idx).GetAt(1) - m_MinList.GetAt(1) ) <= PeakMin )
385 {
386 m_PointList.GetAt(Idx).Valid = FALSE;
387 }
388 };
389 return TRUE;
390 };
391 // -----------------------------------------------------------------------------
392 // ANFANG TOTER CODE 21.4.04
393 // -----------------------------------------------------------------------------
394 // speichert Kurve in angegebener Datei unter angegebener Option
395 // 1.Param Name der Datei
396 // 2.Param type soll mehrere moeglichkeiten der art und weise wie und was von
397 // der der Kurve abgelegt werden soll spezifizieren
398 // (bisher nur type=100 implementiert=>legt nur die Y-werte der kurve
399 // in der Datei ab)
400 /*
401 BOOL TCurve::Save( LPCSTR filename, int type, int )
402 {
403 HANDLE hFile;
404 float x, y, z;
405 char buf[ MaxString ];
406 LPDWORD lpWritten;
407
408 lpWritten = 0;
409 // erstellen einer Datei mit angeg. namen
410 // 10.05.2004 hFile = OpenFile( filename, &of, OF_CREATE );
411 hFile = CreateFile( filename, GENERIC_WRITE|GENERIC_READ, 0, 0, CREATE_ALWAYS, 0, 0);
412 if ( hFile == INVALID_HANDLE_VALUE ) return FALSE;
413
414 // internen Index auf 1.Tripel der Kurve setzen + filepointer auf ende der
415 // Datei + Kurve oeffnen
416 SetPP();
417
418 // 10.05.2004 _llseek( hFile, 0, SEEK_END );
419 SetFilePointer( hFile, 0, 0, FILE_END);
420 FastOpen();
421 // abhaengig von gewaehlter Option (hier nur eine implem.)
422 if ( type==100 ) {
423 // ein tripel aus Kurve holen(incl. index erhoehen) solange bis fehler
424 // (Ende erreicht)
425 while ( FastPGet( x, y, z ) )
426 {
427 // einen Y-wert pro zeile in datei schreiben
428 sprintf( buf, "%.5f\n", y );
429
430 // 10.05.2004 _lwrite( hFile, ( LPSTR ) buf, strlen( buf ) );
431 WriteFile( hFile, (LPSTR)buf, strlen(buf), lpWritten, 0 );
432 }
433 }
434 // datei schliessen + kurve schliessen
435 CloseHandle( hFile );
436 // _lclose( hFile );
437 FastClose();
438 return TRUE;
439 };
440 */
441 // -----------------------------------------------------------------------------
442 // 07.04.2004 TOTER CODE da nicht benutzt
443 //! addiert den wert val zum Y-wert des Tripels x,y,z auf das der aktuelle
444 //! Index zeigt
445 //! 1.param val wird auf Y-wert aufaddiert
446 //! Rueckkehrcode false wenn Fehler sonst true
447 /*
448 BOOL TCurve::ValueAdd( float &val )
449 {
450 // Addiert val jeweils zu [1] des aktuellen Punktes
451 //! test ob kurve punkte hat wenn nicht abbruch
452 if ( m_MaxPointIdx == -1 )
453 return FALSE;
454 //! test ob am Kurven ende wenn ja dann abbruch
455 if ( m_bEnd )
456 return FALSE;
457 //! setzen ob im naechsten aufruf kurvenende erreicht
458 m_bEnd = ( m_ActualIdx == m_MaxPointIdx );
459 //! fixieren des speicherbereichs der y-werte (verschieben verhindern)
460 //! und wenn dies nicht moeglich kurvenparam. auf init. werte zuruecksetzen +
461 //! abbruch
462 m_lpPX = (CPoint*)m_hMemX;
463 if ( !m_lpPX )
464 {
465 m_ActualIdx = -1;
466 m_MaxPointIdx = -1;
467 return FALSE;
468 }
469 //! aufaddieren von val auf den akt.y-wert
470 m_lpPX[ m_ActualIdx ].Pt.SetAt(1, m_lpPX[ m_ActualIdx ].Pt[1]+val ); // vormals m_lpPX[ m_ActualIdx ].Pt[1]+= val
471 //! wenn noch nicht am ende der kurve angekommen dann akt.Index erhoehen
472 if ( !m_bEnd )
473 m_ActualIdx++;
474 //! verschieben von y-werte speicherbereich wieder zulassen
475 return TRUE;
476 };
477 */
478
479 // -----------------------------------------------------------------------------
480 // 07.04.2004 TOTER CODE da nicht benutzt
481 //! legt alle x,y,z werte einer Kurve in einer Datei ab
482 //! 1.Param filename ist der name der Datei in der die Kurve abgelegt werden
483 //! soll
484 //! Rueckkehrcode false wenn Fehler(Datei laesst sich nicht anlegen) sonst true
485 /*
486 BOOL TCurve::Save( LPCSTR filename )
487 {
488 OFSTRUCT of;
489 int hFile;
490 float x, y, z;
491 char buf[ MaxString ];
492
493 //! erstellen einer Datei mit angeg. namen
494 hFile = OpenFile( filename, &of, OF_CREATE );
495 //! wenn fehler dann abbruch
496 if ( hFile==HFILE_ERROR )
497 return FALSE;
498 //! internen Index auf 1.Tripel der Kurve setzen + filepointer auf ende der
499 //! Datei + Kurve oeffnen
500 SetPP();
501 _llseek( hFile, 0, SEEK_END );
502 FastOpen();
503 //! ein tripel aus Kurve holen(incl. index erhoehen) solange bis fehler(ende
504 //! erreicht)
505 while ( FastPGet( x, y, z ) )
506 {
507 //! ein tripel (x,y,z) als einer Zeile in datei schreiben
508 sprintf( buf, "%.3f %.3f %.3f\n", x, y, z );
509 _lwrite( hFile, ( LPSTR ) buf, strlen( buf ) );
510 }
511 //! datei schliessen + kurve schliessen
512 _lclose( hFile );
513 FastClose();
514 return TRUE;
515 };
516 */
517
518 // -----------------------------------------------------------------------------
519 // 07.04.2004 TOTER CODE da nicht benutzt
520 /*
521 BOOL TCurve::DeleteFlanks()
522 {
523 int MaxValIdx;
524 int Idx = 0;
525
526 // Flanken der Peaks beseitigen
527 // Es wird nur y bearbeitet
528 // Die gueltigen Punkte werden nach vorn geschoben + der Rest wird geloescht
529 if ( -1 == m_MaxPointIdx )
530 return FALSE;
531 m_lpPX = (CPoint*)m_hMemX;
532 if ( !m_lpPX )
533 return FALSE;
534 while ( Idx <= m_MaxPointIdx )
535 {
536 // Bis zum naechsten Peak
537 while ( !m_lpPX[ Idx ].Valid )
538 if ( Idx < m_MaxPointIdx )
539 Idx++;
540 else
541 break; // Ende erreicht
542 // Groessten Wert suchen
543 MaxValIdx = Idx;
544 if ( Idx < m_MaxPointIdx )
545 Idx++;
546 else
547 break; // Ende erreicht
548 while ( m_lpPX[ Idx ].Valid )
549 {
550 if ( m_lpPX[ Idx ].Pt[1] > m_lpPX[ MaxValIdx ].Pt[1] )
551 {
552 m_lpPX[ MaxValIdx ].Valid = FALSE;
553 MaxValIdx = Idx;
554 }
555 else
556 m_lpPX[ Idx ].Valid = FALSE;
557 if ( Idx < m_MaxPointIdx )
558 Idx++;
559 else
560 break; // Ende erreicht
561 }
562 // Peak nach vorn kopieren
563
564 //lpPnts[Idx] = lpPoints[MaxValIdx];
565
566 m_lpPX[ Idx ].Valid = TRUE;
567 m_lpPX[ MaxValIdx ].Valid = FALSE;
568 if ( Idx < m_MaxPointIdx )
569 Idx++;
570 }
571 // es wurden peaks gefunden
572 //! nicht von diffr.gruppe auskommentiert
573 //! Exit:
574 return TRUE;
575 };
576 */
577
578 // -----------------------------------------------------------------------------
579 //! nicht von diffr.gruppe auskommentiert
580 //! BOOL TCurve::GetReflection(int /*order*/,LPCPoint /*Peak*/)
581 /*
582 {
583 //! static BOOL bSorted = FALSE; // aendern
584 //! BOOL bChange = FALSE; //wird nur im auskomm. Teil benutzt
585 BOOL Ok = FALSE;
586 // int Idx, MaxValIdx;
587 // CPoint merker;
588
589 // Alle Peak-Maxima werden der Groesse nach sortiert
590 // Der groesste Peak hat die Ordnung 0 usw.
591 // Es sind mit weniger als 20 Peaks zu rechnen
592 if(-1 == m_MaxPointIdx)
593 return FALSE;
594 m_lpPX = (float*)GlobalLock(m_hMemX);
595 lpPY = (float*)GlobalLock(hMemY);
596 lpPZ = (float*)GlobalLock(hMemZ);
597 lpPV = (BOOL*)GlobalLock(hMemV);
598 if(!m_lpPX || !lpPY || !lpPZ || !lpPV)
599 goto Exit;
600 //Kommentarbeginn
601 if(!lpPV[0])
602 goto Exit;
603 if(0 < m_MaxPointIdx)
604 Idx = 1;
605 else
606 {
607 bSorted = TRUE;
608 //*Peak = lpPoints[0];
609 if(order == 0)
610 Ok = TRUE;
611 else
612 Ok = FALSE;
613 goto Exit;
614 }
615 if(!bSorted)
616 {
617 // Sortieren (Bubblesort)
618 Idx = 0;
619 // naechsten groessten Wert suchen
620 while(Idx < m_MaxPointIdx)
621 {
622 while(Idx <= m_MaxPointIdx)
623 {
624 if(lpPY[Idx] > lpPY[m_ActualIdx])
625 {
626 MaxValIdx = Idx;
627 bChange = TRUE;
628 }
629 Idx++;
630 }
631 if(bChange)
632 {
633 // Mit ersten Punkt austauschen
634 merker = lpPoints[m_ActualIdx];
635 lpPoints[m_ActualIdx] = lpPoints[MaxValIdx];
636 lpPoints[MaxValIdx] = merker;
637 bChange = FALSE;
638 // point geht weiter als ThisPoint
639 if(m_ActualIdx < m_MaxPointIdx)
640 m_ActualIdx++;
641 Idx = m_ActualIdx+1;
642 }
643 }
644 bSorted = TRUE;
645 }
646 m_ActualIdx = 0;
647 while(order--)
648 if(m_ActualIdx < m_MaxPointIdx)
649 m_ActualIdx++;
650 else
651 // Peak der angegebenen Ordnung ist nicht vorhanden
652 Ok = FALSE;
653 // Werte kopieren
654 (*Peak) = lpPoints[m_ActualIdx];
655 //Kommentarende
656 Exit:
657 GlobalUnlock(m_hMemX);
658 GlobalUnlock(hMemY);
659 GlobalUnlock(hMemZ);
660 GlobalUnlock(hMemV);
661 if(Ok)
662 return TRUE;
663 else
664 return FALSE;
665 };
666 */
667
668 // -----------------------------------------------------------------------------
669 // 07.04.2004 TOTER CODE da nicht benutzt
670 //! liefert die Breite des 1.Bereiches, in dem alle y-werte des Tripels die
671 //! Haelfte des Intensitaetbereichs(Y(max)-Y(min)) uebersteigen, sowie aus
672 //! diesem Bereich x-wert,y-wert des Tripels fuer das Y-wert(Intensitaet)
673 //! maximal ist
674 //! 1. bereich bedeutet der am weitesten links liegende Bereich der obige
675 //! Eigenschaften erfuellt
676 //! 1.Param(ausgabe) hw enthaelt nach aufruf breite des Bereichs
677 //! 2.Param(ausgabe) pos enthaelt nach aufruf X-wert an der max. y-wert
678 //! (Intensitaet) in diesem Bereich
679 //! 3.Param(ausgabe) intens enthaelt nach aufruf max.y-wert(intensitaet) in
680 //! diesem Bereich
681 //! Rueckkehrcode false wenn fehler sonst true
682 //! anmerkung: dieser Bereich darf nicht bis ans ende der Kurve reichen
683 //! d.h. kurve darf nicht monoton wachsend sein (sonst return false)
684 /*
685 BOOL TCurve::GetPeakProperties( float &hw, float &pos, float &intens )
686 {
687 int LeftPIdx, RightPIdx, MaxPIdx, Idx;
688 BOOL retval = FALSE;
689
690 //! test ob kurve punkte hat wenn nicht abbruch
691 if ( -1 == m_MaxPointIdx )
692 return FALSE;
693 //! ermitteln der Bereiche, die obige bedingung erfuellen und bei fehler
694 //! Abbruch
695 if ( !DeleteUnderGround( 0.5 ) )
696 return FALSE;
697 // 000001111111100000
698 // Bis zum naechsten Peak
699 Idx = 0;
700 //! speicherbereiche fixieren + test ob erfolgreich wenn nicht dann abbruch
701 m_lpPX = (CPoint*)m_hMemX;
702 if ( !m_lpPX )
703 goto Exit;
704 //! ueberspringen eines event. vorhandenen ungueltigen Bereichs gleich am
705 //! anfang der kurve + abbruch falls die gesamte kurve ungueltig ist
706 while ( !m_lpPX[ Idx ].Valid )
707 if ( Idx < m_MaxPointIdx )
708 Idx++;
709 else
710 goto Exit; // Ende erreicht
711 // linke Flanke
712 LeftPIdx = MaxPIdx = Idx;
713 //! ermitteln des max. y-wertes in diesem Bereich + abbruch falls auf diesen
714 //! gueltigen bereich nicht ein ungueltiger folgt
715 while ( m_lpPX[ Idx ].Valid )
716 {
717 if ( m_lpPX[ Idx ].Pt[1] > m_lpPX[ MaxPIdx ].Pt[1] )
718 MaxPIdx = Idx;
719 if ( Idx < m_MaxPointIdx )
720 Idx++;
721 else
722 goto Exit; // Ende erreicht
723 }
724 // rechte Flanke
725
726 RightPIdx = Idx - 1;
727 //! berechnen und uebergeben der ausgabeparameter
728 hw = fabs( m_lpPX[ RightPIdx ].Pt[0] - m_lpPX[ LeftPIdx ].Pt[0] );
729 pos = m_lpPX[ MaxPIdx ].Pt[0];
730 intens = m_lpPX[ MaxPIdx ].Pt[1];
731 //! funktion erfolgreich
732 retval = TRUE;
733 Exit:
734 //! verschieben der speicherbereiche wieder zulassen
735 return retval;
736 };
737 */
738
739 //##############################################################################
740 // TDataBase
741 //##############################################################################
742
743 // -----------------------------------------------------------------------------
744 // Konstruktor der Datenbasis
745 TDataBase::TDataBase( void ) : TBaseList(true, false, true, false, cDefaultSize)
746 {
747 m_ActualIdx = 0;
748 Append(new TCurve);
749 };
750
751 // -----------------------------------------------------------------------------
752 // Destruktor
753 TDataBase::~TDataBase( void )
754 {
755 // loeschen aller Kurven der Datenbasis
756 Clear(); // nicht TBaseList::~TIndList() verwenden, sonst wird TBaseList::FreeData() statt TDataBase::FreeData() verwendet
757 };
758
759 // -----------------------------------------------------------------------------
760 // alle Kurven der Datenbasis loeschen und alle Indizes auf ini.werte
761 BOOL TDataBase::New( void )
762 {
763 SetInfo( _FreeingDataBase );
764 // Kurven beginnend von der Letzten bis zur Ersten loeschen
765 if ( GetCount()>1 ) CutList(1);
766
767 // 1 neue.Kurve erzeugen
768 m_ActualIdx = 0;
769 if ( GetCount()==0 && !Append(new TCurve) ) return FALSE;
770
771 ( (TCurve*)GetAt(0) )->New(); //17.11.2002
772 // Scanreportkurve auf ini.werte zuruecksetzen
773 m_ScanReport.New(); //17.11.2002
774 SetInfo( " " );
775 return TRUE;
776 };
777
778 // -----------------------------------------------------------------------------
779 // fuegt eine Kurve der angegebenen Groesse(1.Param.) zur Datenbasis hinzu
780 // true, wenn erfolgreich
781 BOOL TDataBase::AddCurve( void )
782 {
783 // wenn erfolgreich Abbruch sonst Fehler setzen
784 if ( !Append(new TCurve) ) return FALSE;
785
786 // m_eFault = NoMemory; // 24.03.2004
787 return TRUE;
788 };
789
790 // -----------------------------------------------------------------------------
791 // entfernt die letze Kurve (dem Index nach) in der Datenbasis
792 // true, wenn erfolgreich
793 BOOL TDataBase::DelCurve( void )
794 {
795 // immer eine Kurve übrig behalten
796 if ( GetCount() <= 1 ) return FALSE;
797
798 if (m_ActualIdx == GetCount()-1) m_ActualIdx--;
799 Remove( GetCount()-1 );
800 return TRUE;
801 }
802
803 // -----------------------------------------------------------------------------
804 // setzt Kurvenindex auf angegebenen Wert (1.Param.) wenn möglich, dann true
805 // ansonsten auf den entsprechenden Grenzwert
806 BOOL TDataBase::SetCurveIdx( int aIndex )
807 {
808 m_ActualIdx = max( 0, min( GetCount()-1, aIndex ) );
809 if ( m_ActualIdx != aIndex ) return FALSE;
810 return TRUE;
811 };
812
813 // -----------------------------------------------------------------------------
814 // liefert Kurve mit angegebenen Index (1.Param.) zurueck
815 // wenn moeglich ansonsten naechstgelegene gueltige Kurve
816 TCurve *TDataBase::GetCurve( int aIndex )
817 {
818 aIndex = max( 0, min( GetCount()-1, aIndex ) );
819 return (TCurve*)GetAt( aIndex );
820 };
821
822 TCurve *TDataBase::GetLastCurve()
823 {
824 return GetCurve( GetCount()-1 );
825 };
826
827 void TDataBase::FreeData(void *aData) const {
828 TCurve *cast= (TCurve*)aData;
829 _FREEOBJ(cast); // sonst wird TCurve::~TCurve() nicht gerufen
830 }
831
832 // __LastLine__
833
834
835
836
837