summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorErich Eckner <git@eckner.net>2016-02-04 14:46:40 +0100
committerErich Eckner <git@eckner.net>2016-02-04 14:46:40 +0100
commit7b784d17de7002aa656832944083b70f40b12350 (patch)
tree01fd83db2299f30c78eefe2eec7b552d4a1d9e4a
parentb40828e98bef8529855afa50d32b7f695bd31f5d (diff)
downloadepost-7b784d17de7002aa656832944083b70f40b12350.tar.xz
ich fühl mich unwohl, wenn die Arbeit nicht im git liegt
Diffstat
-rw-r--r--epost.lpr900
-rw-r--r--epost.lps131
-rw-r--r--epostunit.pas5696
-rw-r--r--typenunit.pas2495
-rw-r--r--werteunit.pas1015
5 files changed, 5407 insertions, 4830 deletions
diff --git a/epost.lpr b/epost.lpr
index b53b6e6..2d95c48 100644
--- a/epost.lpr
+++ b/epost.lpr
@@ -12,467 +12,469 @@ uses
{ you can add units after this }
sysutils, epostunit, mystringlistunit, typenunit, lowlevelunit;
-var maxthreads,i,j,k: longint;
- inf: tMyStringlist;
- s: string;
- b,syntaxtest,parallelLesen: boolean;
- wertes: tWerteArray;
- Konturen: tKonturenArray;
- Warnstufe: tWarnstufe;
+var
+ maxthreads,i,j,k: longint;
+ inf: tMyStringlist;
+ s: string;
+ b,syntaxtest,parallelLesen: boolean;
+ wertes: tWerteArray;
+ Konturen: tKonturenArray;
+ Warnstufe: tWarnstufe;
procedure werte_aufraeumen;
-var i: integer;
+var
+ i: integer;
begin
- for i:=0 to length(wertes)-1 do
- if assigned(wertes[i]) then
- wertes[i].free;
- setlength(wertes,0);
- for i:=0 to length(Konturen)-1 do
- if assigned(Konturen[i]) then
- Konturen[i].free;
- setlength(Konturen,0);
+ for i:=0 to length(wertes)-1 do
+ if assigned(wertes[i]) then
+ wertes[i].free;
+ setlength(wertes,0);
+ for i:=0 to length(Konturen)-1 do
+ if assigned(Konturen[i]) then
+ Konturen[i].free;
+ setlength(Konturen,0);
end;
procedure aufraeumen;
begin
- warte_auf_externeBefehle;
- werte_aufraeumen;
- inf.free;
+ warte_auf_externeBefehle;
+ werte_aufraeumen;
+ inf.free;
end;
begin
- cleanupLogs;
- if (not (paramcount in [1,2])) or
+ cleanupLogs;
+ if (not (paramcount in [1,2])) or
((paramcount=2) and (paramstr(2)<>'-L')) or
not fileexists(paramstr(1)) then begin
- gibAus('Verwendung: '+paramstr(0)+' input.epost',3);
- gibAus('oder: '+paramstr(0)+' input.epost -L',3);
- halt(1);
- end;
- maxthreads:=1;
- Warnstufe:=wsStreng;
- parallelLesen:=false;
- setlength(wertes,0);
- setlength(Konturen,0);
- behalteLogs:=(paramcount=2) and (paramstr(2)='-L');
- inf:=tMyStringlist.create(nil,'');
- inf.nichtInSubRoutine('^lösche Werte '); // Zeilen, die hierauf passen, werden nicht an subRoutinen-Aufrufe
- inf.nichtInSubRoutine('^lösche Kontur '); // von metaReadln gegeben, sondern nach hinten ans Hauptprogramm verschoben
- inf.loadFromFile(paramstr(1));
- if not inf.unfoldMacros then begin
- gibAus('Fehlerhafte input-Datei '''+paramstr(1)+'''!',3);
- halt(1);
- end;
+ gibAus('Verwendung: '+paramstr(0)+' input.epost',3);
+ gibAus('oder: '+paramstr(0)+' input.epost -L',3);
+ halt(1);
+ end;
+ maxthreads:=1;
+ Warnstufe:=wsStreng;
+ parallelLesen:=false;
+ setlength(wertes,0);
+ setlength(Konturen,0);
+ behalteLogs:=(paramcount=2) and (paramstr(2)='-L');
+ inf:=tMyStringlist.create(nil,'');
+ inf.nichtInSubRoutine('^lösche Werte '); // Zeilen, die hierauf passen, werden nicht an subRoutinen-Aufrufe
+ inf.nichtInSubRoutine('^lösche Kontur '); // von metaReadln gegeben, sondern nach hinten ans Hauptprogramm verschoben
+ inf.loadFromFile(paramstr(1));
+ if not inf.unfoldMacros then begin
+ gibAus('Fehlerhafte input-Datei '''+paramstr(1)+'''!',3);
+ halt(1);
+ end;
- for syntaxtest:=true downto false do begin
- if not syntaxtest then
- gibAus('Syntaxtest bestanden!',3);
- inf.rewind;
- while inf.metaReadln(s,false) do begin
- for i:=0 to length(wertes)-1 do
- wertes[i].beendeLeseThreadWennFertig;
- beendeExterneBefehleWennFertig;
- if s='streng warnen' then begin
- Warnstufe:=wsStreng;
- continue;
- end;
- if s='lasch warnen' then begin
- Warnstufe:=wsLasch;
- continue;
- end;
- if s='parallel lesen' then begin
- parallelLesen:=true;
- continue;
- end;
- if s='sequentiell lesen' then begin
- parallelLesen:=false;
- continue;
- end;
- if s='ohne Logdateien' then begin
- __ausgabenMaske:=__ausgabenMaske or 1;
- continue;
- end;
- if s='mit Logdateien' then begin
- __ausgabenMaske:=__ausgabenMaske and not 1;
- continue;
- end;
- if s='ohne Bildschirmausgaben' then begin
- __ausgabenMaske:=__ausgabenMaske or 2;
- continue;
- end;
- if s='mit Bildschirmausgaben' then begin
- __ausgabenMaske:=__ausgabenMaske and not 2;
- continue;
- end;
- if startetMit('externer Befehl:',s) then begin
- if externerBefehl(syntaxtest,s) then continue;
- aufraeumen;
- halt(1);
- end;
- if s='warte auf externe Befehle' then begin
- if not syntaxtest then begin
- warte_auf_externeBefehle;
- for i:=0 to length(wertes)-1 do
- wertes[i].warteAufBeendigungDesLeseThreads;
- end;
- continue;
- end;
- if startetMit('exprtofloat-Test:',s) then begin
- gibAus('exprtofloat-Test: '+s+'='+floattostr(wertes[length(wertes)-1].exprtofloat(syntaxtest,s)),3);
- continue;
- end;
- if startetMit('dupliziere ',s) then begin
- i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- if not startetMit('zu ',s) then begin
- gibAus('Fehlende Parameter, erwartet: ''dupliziere $Original zu $Kopie''',3);
- aufraeumen;
- halt(1);
- end;
- j:=findeWerte(s,inf,@wertes,@Konturen,true);
- if j<0 then begin
- aufraeumen;
- halt(1);
- end;
- wertes[j].kopiereVon(syntaxtest,wertes[i]);
- continue;
- end;
- if startetMit('erzeuge Dummy-Werte ',s) then begin
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- wertes[i].free;
- wertes[i]:=tWerte.create(@Konturen,@wertes);
- wertes[i].bezeichner:=s;
- continue;
- end;
- if startetMit('Daten einlesen ',s) then begin
- b:=not startetMit('(ohne Ausgaben)',s);
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- if wertes[i].ladeDateien(syntaxtest,inf,parallelLesen,b) then begin
- continue;
- end;
- aufraeumen;
- halt(1);
- end;
- if startetMit('Ascii laden ',s) then begin
- i:=findeWerte(erstesArgument(s),inf,@wertes,@Konturen,true);
- if wertes[i].ladeAscii(syntaxtest,s) then
- continue;
- aufraeumen;
- halt(1);
- end;
- if startetMit('Linearkombination ',s) then begin
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- if wertes[i].berechneLiKo(syntaxtest,inf,maxthreads) then
- continue;
- aufraeumen;
- halt(1);
- end;
- if startetMit('Agglomeration ',s) then begin
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- if wertes[i].berechneAgglomeration(syntaxtest,inf) then
- continue;
- aufraeumen;
- halt(1);
- end;
- if startetMit('teile ',s) then begin
- i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- if not startetMit('durch ',s) then begin
- gibAus('Fehlende Parameter, erwartet: ''teile $Dividend durch $Divisor zu $Quotient''',3);
- aufraeumen;
- halt(1);
- end;
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
- if j<0 then begin
- aufraeumen;
- halt(1);
- end;
- if not startetMit('zu ',s) then begin
- gibAus('Fehlende Parameter, erwartet: ''teile $Dividend durch $Divisor zu $Quotient''',3);
- aufraeumen;
- halt(1);
- end;
- k:=findeWerte(s,inf,@wertes,@Konturen,true);
- if k<0 then begin
- aufraeumen;
- halt(1);
- end;
- if wertes[k].berechneQuotient(syntaxtest,inf,maxthreads,i,j) then
- continue;
- aufraeumen;
- halt(1);
- end;
- if startetMit('multipliziere ',s) then begin
- i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- if not startetMit('mal ',s) then begin
- gibAus('Fehlende Parameter, erwartet: ''multipliziere $Faktor mal $Faktor zu $Produkt''',3);
- aufraeumen;
- halt(1);
- end;
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
- if j<0 then begin
- aufraeumen;
- halt(1);
- end;
- if not startetMit('zu ',s) then begin
- gibAus('Fehlende Parameter, erwartet: ''multipliziere $Faktor mal $Faktor zu $Produkt''',3);
- aufraeumen;
- halt(1);
- end;
- k:=findeWerte(s,inf,@wertes,@Konturen,true);
- if k<0 then begin
- aufraeumen;
- halt(1);
- end;
- if wertes[k].berechneProdukt(syntaxtest,inf,maxthreads,i,j) then
- continue;
- aufraeumen;
- halt(1);
- end;
- if startetMit('FFT2d ',s) then begin
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- if wertes[i].berechneFFT2d(syntaxtest,inf,maxthreads,Warnstufe) then
- continue;
- aufraeumen;
- halt(1);
- end;
- if startetMit('FFT ',s) then begin
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- if wertes[i].berechneFFT(syntaxtest,inf,maxthreads,Warnstufe) then
- continue;
- aufraeumen;
- halt(1);
- end;
- if startetMit('Zeitfrequenzanalyse ',s) then begin
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
- if j<0 then begin
- aufraeumen;
- halt(1);
- end;
- if not startetMit('zu ',s) then begin
- gibAus('Fehlende Parameter, erwartet: ''Zeitfrequenzanalyse $Original zu $Analyse''',3);
- aufraeumen;
- halt(1);
- end;
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- if wertes[i].berechneZeitfrequenzanalyse(syntaxtest,inf,maxthreads,wertes[j],Warnstufe) then
- continue;
- aufraeumen;
- halt(1);
- end;
- if startetMit('Verzerrung ',s) then begin
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
- if j<0 then begin
- aufraeumen;
- halt(1);
- end;
- if not startetMit('zu ',s) then begin
- gibAus('Fehlende Parameter, erwartet: ''Verzerrung $Original zu $Bild''',3);
- aufraeumen;
- halt(1);
- end;
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- if wertes[i].berechneVerzerrung(syntaxtest,inf,maxthreads,wertes[j],Warnstufe) then
- continue;
- aufraeumen;
- halt(1);
- end;
- if startetMit('integriere ',s) then begin
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
- if j<0 then begin
- aufraeumen;
- halt(1);
- end;
- if not startetMit('zu ',s) then begin
- gibAus('Fehlende Parameter, erwartet: ''integriere $Funktion zu $Stammfunktion''',3);
- aufraeumen;
- halt(1);
- end;
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- if wertes[i].berechneIntegral(syntaxtest,inf,maxthreads,wertes[j]) then
- continue;
- aufraeumen;
- halt(1);
- end;
- if startetMit('korreliere ',s) then begin
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
- if j<0 then begin
- aufraeumen;
- halt(1);
- end;
- if not startetMit('zu ',s) then begin
- gibAus('Fehlende Parameter, erwartet: ''korreliere $Original zu $Korrelation''',3);
- aufraeumen;
- halt(1);
- end;
- i:=findeWerte(s,inf,@wertes,@Konturen,true);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- if wertes[i].berechneKorrelation(syntaxtest,inf,maxthreads,wertes[j]) then
- continue;
- aufraeumen;
- halt(1);
- end;
- if startetMit('Threadanzahl:',s) then begin
- maxThreads:=strtoint(s);
- continue;
- end;
- if startetMit('maximale und minimale Dichten bestimmen ',s) then begin
- b:=startetMit('(symmetrisch) ',s);
- i:=findeWerte(s,nil,@wertes,@Konturen,false);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- wertes[i].ermittleMinMaxDichten(syntaxtest,maxThreads,b);
- continue;
- end;
- if startetMit('maximale und minimale Dichten angleichen ',s) then begin
- b:=startetMit('(symmetrisch) ',s);
- i:=findeWerte(s,nil,@wertes,@Konturen,false);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- wertes[i].gleicheMinMaxDichtenAn(syntaxtest,inf,b);
- continue;
- end;
- if startetMit('lineares Bild ',s) then begin
- i:=findeWerte(s,nil,@wertes,@Konturen,false);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- if not wertes[i].erzeugeLinearesBild(syntaxtest,inf,maxthreads) then begin
- aufraeumen;
- halt(1);
- end;
- continue;
- end;
- if startetMit('Ascii ',s) then begin
- i:=findeWerte(s,nil,@wertes,@Konturen,false);
- if i<0 then begin
- aufraeumen;
- halt(1);
- end;
- if not wertes[i].erzeugeAscii(syntaxtest,inf) then begin
- aufraeumen;
- halt(1);
- end;
- continue;
- end;
- if startetMit('Lineout ',s) then begin
- i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
- if (i<0) or not wertes[i].erzeugeLineout(syntaxtest,s) then begin
- aufraeumen;
- halt(1);
- end;
- continue;
- end;
- if startetMit('Binning ',s) then begin
- i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
- if (i<0) or not wertes[i].erzeugeBinning(syntaxtest,s) then begin
- aufraeumen;
- halt(1);
- end;
- continue;
- end;
- if startetMit('lösche Werte ',s) then begin
- while s<>'' do begin
- j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
- if j<0 then begin
- aufraeumen;
- halt(1);
- end;
- wertes[j].free;
- for i:=j+1 to length(wertes)-1 do
- wertes[i-1]:=wertes[i];
- setlength(wertes,length(wertes)-1);
- end;
- continue;
- end;
- if startetMit('lösche Kontur ',s) then begin
- while s<>'' do begin
- j:=findeKontur(erstesArgument(s),nil,@Konturen,false);
- if j<0 then begin
- aufraeumen;
- halt(1);
- end;
- konturen[j].free;
- for i:=j+1 to length(konturen)-1 do
- konturen[i-1]:=konturen[i];
- setlength(konturen,length(konturen)-1);
- end;
- continue;
- end;
- if s='Palette' then begin
- if neuePalette(inf) then continue;
- aufraeumen;
- halt(1);
- end;
- if startetMit('Kontur',s) then begin
- i:=findeKontur(s,inf,@Konturen,true);
- if (i>=0) and Konturen[i].Init(syntaxtest,inf,@wertes,maxthreads) then continue;
- aufraeumen;
- halt(1);
- end;
- if s='Dateiende' then
- break;
- gibAus('Befehl '''+s+''' ist unverständlich in '''+paramstr(1)+'''!',3);
- aufraeumen;
- halt(1);
- end;
- werte_aufraeumen;
- end;
- aufraeumen;
- if not behalteLogs then cleanupLogs;
+ for syntaxtest:=true downto false do begin
+ if not syntaxtest then
+ gibAus('Syntaxtest bestanden!',3);
+ inf.rewind;
+ while inf.metaReadln(s,false) do begin
+ for i:=0 to length(wertes)-1 do
+ wertes[i].beendeLeseThreadWennFertig;
+ beendeExterneBefehleWennFertig;
+ if s='streng warnen' then begin
+ Warnstufe:=wsStreng;
+ continue;
+ end;
+ if s='lasch warnen' then begin
+ Warnstufe:=wsLasch;
+ continue;
+ end;
+ if s='parallel lesen' then begin
+ parallelLesen:=true;
+ continue;
+ end;
+ if s='sequentiell lesen' then begin
+ parallelLesen:=false;
+ continue;
+ end;
+ if s='ohne Logdateien' then begin
+ __ausgabenMaske:=__ausgabenMaske or 1;
+ continue;
+ end;
+ if s='mit Logdateien' then begin
+ __ausgabenMaske:=__ausgabenMaske and not 1;
+ continue;
+ end;
+ if s='ohne Bildschirmausgaben' then begin
+ __ausgabenMaske:=__ausgabenMaske or 2;
+ continue;
+ end;
+ if s='mit Bildschirmausgaben' then begin
+ __ausgabenMaske:=__ausgabenMaske and not 2;
+ continue;
+ end;
+ if startetMit('externer Befehl:',s) then begin
+ if externerBefehl(syntaxtest,s) then continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if s='warte auf externe Befehle' then begin
+ if not syntaxtest then begin
+ warte_auf_externeBefehle;
+ for i:=0 to length(wertes)-1 do
+ wertes[i].warteAufBeendigungDesLeseThreads;
+ end;
+ continue;
+ end;
+ if startetMit('exprtofloat-Test:',s) then begin
+ gibAus('exprtofloat-Test: '+s+'='+floattostr(wertes[length(wertes)-1].exprtofloat(syntaxtest,s)),3);
+ continue;
+ end;
+ if startetMit('dupliziere ',s) then begin
+ i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if not startetMit('zu ',s) then begin
+ gibAus('Fehlende Parameter, erwartet: ''dupliziere $Original zu $Kopie''',3);
+ aufraeumen;
+ halt(1);
+ end;
+ j:=findeWerte(s,inf,@wertes,@Konturen,true);
+ if j<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ wertes[j].kopiereVon(syntaxtest,wertes[i]);
+ continue;
+ end;
+ if startetMit('erzeuge Dummy-Werte ',s) then begin
+ i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ wertes[i].free;
+ wertes[i]:=tWerte.create(@Konturen,@wertes);
+ wertes[i].bezeichner:=s;
+ continue;
+ end;
+ if startetMit('Daten einlesen ',s) then begin
+ b:=not startetMit('(ohne Ausgaben)',s);
+ i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if wertes[i].ladeDateien(syntaxtest,inf,parallelLesen,b) then begin
+ continue;
+ end;
+ aufraeumen;
+ halt(1);
+ end;
+ if startetMit('Ascii laden ',s) then begin
+ i:=findeWerte(erstesArgument(s),inf,@wertes,@Konturen,true);
+ if wertes[i].ladeAscii(syntaxtest,s) then
+ continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if startetMit('Linearkombination ',s) then begin
+ i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if wertes[i].berechneLiKo(syntaxtest,inf,maxthreads) then
+ continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if startetMit('Agglomeration ',s) then begin
+ i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if wertes[i].berechneAgglomeration(syntaxtest,inf) then
+ continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if startetMit('teile ',s) then begin
+ i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if not startetMit('durch ',s) then begin
+ gibAus('Fehlende Parameter, erwartet: ''teile $Dividend durch $Divisor zu $Quotient''',3);
+ aufraeumen;
+ halt(1);
+ end;
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ if j<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if not startetMit('zu ',s) then begin
+ gibAus('Fehlende Parameter, erwartet: ''teile $Dividend durch $Divisor zu $Quotient''',3);
+ aufraeumen;
+ halt(1);
+ end;
+ k:=findeWerte(s,inf,@wertes,@Konturen,true);
+ if k<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if wertes[k].berechneQuotient(syntaxtest,inf,maxthreads,i,j) then
+ continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if startetMit('multipliziere ',s) then begin
+ i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if not startetMit('mal ',s) then begin
+ gibAus('Fehlende Parameter, erwartet: ''multipliziere $Faktor mal $Faktor zu $Produkt''',3);
+ aufraeumen;
+ halt(1);
+ end;
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ if j<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if not startetMit('zu ',s) then begin
+ gibAus('Fehlende Parameter, erwartet: ''multipliziere $Faktor mal $Faktor zu $Produkt''',3);
+ aufraeumen;
+ halt(1);
+ end;
+ k:=findeWerte(s,inf,@wertes,@Konturen,true);
+ if k<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if wertes[k].berechneProdukt(syntaxtest,inf,maxthreads,i,j) then
+ continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if startetMit('FFT2d ',s) then begin
+ i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if wertes[i].berechneFFT2d(syntaxtest,inf,maxthreads,Warnstufe) then
+ continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if startetMit('FFT ',s) then begin
+ i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if wertes[i].berechneFFT(syntaxtest,inf,maxthreads,Warnstufe) then
+ continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if startetMit('Zeitfrequenzanalyse ',s) then begin
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ if j<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if not startetMit('zu ',s) then begin
+ gibAus('Fehlende Parameter, erwartet: ''Zeitfrequenzanalyse $Original zu $Analyse''',3);
+ aufraeumen;
+ halt(1);
+ end;
+ i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if wertes[i].berechneZeitfrequenzanalyse(syntaxtest,inf,maxthreads,wertes[j],Warnstufe) then
+ continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if startetMit('Verzerrung ',s) then begin
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ if j<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if not startetMit('zu ',s) then begin
+ gibAus('Fehlende Parameter, erwartet: ''Verzerrung $Original zu $Bild''',3);
+ aufraeumen;
+ halt(1);
+ end;
+ i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if wertes[i].berechneVerzerrung(syntaxtest,inf,maxthreads,wertes[j],Warnstufe) then
+ continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if startetMit('integriere ',s) then begin
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ if j<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if not startetMit('zu ',s) then begin
+ gibAus('Fehlende Parameter, erwartet: ''integriere $Funktion zu $Stammfunktion''',3);
+ aufraeumen;
+ halt(1);
+ end;
+ i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if wertes[i].berechneIntegral(syntaxtest,inf,maxthreads,wertes[j]) then
+ continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if startetMit('korreliere ',s) then begin
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ if j<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if not startetMit('zu ',s) then begin
+ gibAus('Fehlende Parameter, erwartet: ''korreliere $Original zu $Korrelation''',3);
+ aufraeumen;
+ halt(1);
+ end;
+ i:=findeWerte(s,inf,@wertes,@Konturen,true);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if wertes[i].berechneKorrelation(syntaxtest,inf,maxthreads,wertes[j]) then
+ continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if startetMit('Threadanzahl:',s) then begin
+ maxThreads:=strtoint(s);
+ continue;
+ end;
+ if startetMit('maximale und minimale Dichten bestimmen ',s) then begin
+ b:=startetMit('(symmetrisch) ',s);
+ i:=findeWerte(s,nil,@wertes,@Konturen,false);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ wertes[i].ermittleMinMaxDichten(syntaxtest,maxThreads,b);
+ continue;
+ end;
+ if startetMit('maximale und minimale Dichten angleichen ',s) then begin
+ b:=startetMit('(symmetrisch) ',s);
+ i:=findeWerte(s,nil,@wertes,@Konturen,false);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ wertes[i].gleicheMinMaxDichtenAn(syntaxtest,inf,b);
+ continue;
+ end;
+ if startetMit('lineares Bild ',s) then begin
+ i:=findeWerte(s,nil,@wertes,@Konturen,false);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if not wertes[i].erzeugeLinearesBild(syntaxtest,inf,maxthreads) then begin
+ aufraeumen;
+ halt(1);
+ end;
+ continue;
+ end;
+ if startetMit('Ascii ',s) then begin
+ i:=findeWerte(s,nil,@wertes,@Konturen,false);
+ if i<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ if not wertes[i].erzeugeAscii(syntaxtest,inf) then begin
+ aufraeumen;
+ halt(1);
+ end;
+ continue;
+ end;
+ if startetMit('Lineout ',s) then begin
+ i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ if (i<0) or not wertes[i].erzeugeLineout(syntaxtest,s) then begin
+ aufraeumen;
+ halt(1);
+ end;
+ continue;
+ end;
+ if startetMit('Binning ',s) then begin
+ i:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ if (i<0) or not wertes[i].erzeugeBinning(syntaxtest,s) then begin
+ aufraeumen;
+ halt(1);
+ end;
+ continue;
+ end;
+ if startetMit('lösche Werte ',s) then begin
+ while s<>'' do begin
+ j:=findeWerte(erstesArgument(s),nil,@wertes,@Konturen,false);
+ if j<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ wertes[j].free;
+ for i:=j+1 to length(wertes)-1 do
+ wertes[i-1]:=wertes[i];
+ setlength(wertes,length(wertes)-1);
+ end;
+ continue;
+ end;
+ if startetMit('lösche Kontur ',s) then begin
+ while s<>'' do begin
+ j:=findeKontur(erstesArgument(s),nil,@Konturen,false);
+ if j<0 then begin
+ aufraeumen;
+ halt(1);
+ end;
+ konturen[j].free;
+ for i:=j+1 to length(konturen)-1 do
+ konturen[i-1]:=konturen[i];
+ setlength(konturen,length(konturen)-1);
+ end;
+ continue;
+ end;
+ if s='Palette' then begin
+ if neuePalette(inf) then continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if startetMit('Kontur',s) then begin
+ i:=findeKontur(s,inf,@Konturen,true);
+ if (i>=0) and Konturen[i].Init(syntaxtest,inf,@wertes,maxthreads) then continue;
+ aufraeumen;
+ halt(1);
+ end;
+ if s='Dateiende' then
+ break;
+ gibAus('Befehl '''+s+''' ist unverständlich in '''+paramstr(1)+'''!',3);
+ aufraeumen;
+ halt(1);
+ end;
+ werte_aufraeumen;
+ end;
+ aufraeumen;
+ if not behalteLogs then cleanupLogs;
end.
diff --git a/epost.lps b/epost.lps
index d68027d..d60b270 100644
--- a/epost.lps
+++ b/epost.lps
@@ -3,12 +3,11 @@
<ProjectSession>
<Version Value="9"/>
<BuildModes Active="Default"/>
- <Units Count="13">
+ <Units Count="14">
<Unit0>
<Filename Value="epost.lpr"/>
<IsPartOfProject Value="True"/>
- <TopLine Value="72"/>
- <CursorPos Y="185"/>
+ <CursorPos X="3" Y="26"/>
<UsageCount Value="202"/>
<Loaded Value="True"/>
</Unit0>
@@ -23,8 +22,8 @@
<Filename Value="epostunit.pas"/>
<IsPartOfProject Value="True"/>
<EditorIndex Value="1"/>
- <TopLine Value="1885"/>
- <CursorPos X="5" Y="1905"/>
+ <TopLine Value="788"/>
+ <CursorPos X="3" Y="809"/>
<UsageCount Value="201"/>
<Loaded Value="True"/>
</Unit2>
@@ -38,9 +37,9 @@
<Unit4>
<Filename Value="werteunit.pas"/>
<IsPartOfProject Value="True"/>
- <EditorIndex Value="4"/>
- <TopLine Value="210"/>
- <CursorPos X="60" Y="219"/>
+ <EditorIndex Value="2"/>
+ <TopLine Value="152"/>
+ <CursorPos X="3" Y="173"/>
<UsageCount Value="200"/>
<Loaded Value="True"/>
</Unit4>
@@ -48,9 +47,9 @@
<Filename Value="typenunit.pas"/>
<IsPartOfProject Value="True"/>
<IsVisibleTab Value="True"/>
- <EditorIndex Value="5"/>
- <TopLine Value="214"/>
- <CursorPos Y="216"/>
+ <EditorIndex Value="3"/>
+ <TopLine Value="1980"/>
+ <CursorPos X="3" Y="2001"/>
<UsageCount Value="200"/>
<Loaded Value="True"/>
</Unit5>
@@ -59,27 +58,26 @@
<EditorIndex Value="-1"/>
<TopLine Value="1612"/>
<CursorPos X="2" Y="1675"/>
- <UsageCount Value="7"/>
+ <UsageCount Value="6"/>
</Unit6>
<Unit7>
<Filename Value="../units/mystringlistunit.pas"/>
<EditorIndex Value="-1"/>
- <TopLine Value="344"/>
- <CursorPos X="17" Y="344"/>
- <UsageCount Value="19"/>
+ <TopLine Value="356"/>
+ <CursorPos X="43" Y="378"/>
+ <UsageCount Value="18"/>
</Unit7>
<Unit8>
<Filename Value="../units/lowlevelunit.pas"/>
- <EditorIndex Value="3"/>
- <TopLine Value="17"/>
- <CursorPos X="3" Y="37"/>
- <UsageCount Value="28"/>
- <Loaded Value="True"/>
+ <EditorIndex Value="-1"/>
+ <TopLine Value="23"/>
+ <CursorPos X="51" Y="44"/>
+ <UsageCount Value="27"/>
</Unit8>
<Unit9>
<Filename Value="../units/randomunit.pas"/>
<EditorIndex Value="-1"/>
- <UsageCount Value="7"/>
+ <UsageCount Value="6"/>
</Unit9>
<Unit10>
<Filename Value="../units/matheunit.pas"/>
@@ -87,143 +85,150 @@
<TopLine Value="544"/>
<CursorPos X="53" Y="567"/>
<FoldState Value=" T3q50{m012A"/>
- <UsageCount Value="19"/>
+ <UsageCount Value="18"/>
</Unit10>
<Unit11>
<Filename Value="../units/systemunit.pas"/>
- <EditorIndex Value="2"/>
+ <EditorIndex Value="-1"/>
<TopLine Value="65"/>
<CursorPos X="26" Y="80"/>
- <UsageCount Value="20"/>
- <Loaded Value="True"/>
+ <UsageCount Value="19"/>
</Unit11>
<Unit12>
<Filename Value="../fpGUI/src/corelib/render/software/agg_2D.pas"/>
<EditorIndex Value="-1"/>
<TopLine Value="807"/>
<CursorPos Y="818"/>
- <UsageCount Value="10"/>
+ <UsageCount Value="9"/>
</Unit12>
+ <Unit13>
+ <Filename Value="../units/protokollunit.pas"/>
+ <EditorIndex Value="-1"/>
+ <TopLine Value="82"/>
+ <CursorPos X="15" Y="30"/>
+ <UsageCount Value="9"/>
+ </Unit13>
</Units>
<JumpHistory Count="30" HistoryIndex="29">
<Position1>
- <Filename Value="werteunit.pas"/>
- <Caret Line="251" TopLine="211"/>
+ <Filename Value="epostunit.pas"/>
+ <Caret Line="6035" Column="3" TopLine="5949"/>
</Position1>
<Position2>
<Filename Value="epostunit.pas"/>
- <Caret Line="1926" Column="16" TopLine="1906"/>
+ <Caret Line="6041" TopLine="6021"/>
</Position2>
<Position3>
<Filename Value="epostunit.pas"/>
- <Caret Line="1947" Column="33" TopLine="1912"/>
+ <Caret Line="5452" Column="3" TopLine="5444"/>
</Position3>
<Position4>
<Filename Value="epostunit.pas"/>
- <Caret Line="1927" Column="36" TopLine="1912"/>
+ <Caret Line="5342" Column="3" TopLine="5320"/>
</Position4>
<Position5>
<Filename Value="epostunit.pas"/>
+ <Caret Line="5165" Column="3" TopLine="5141"/>
</Position5>
<Position6>
<Filename Value="epostunit.pas"/>
- <Caret Line="122" Column="25" TopLine="90"/>
+ <Caret Line="5108" Column="3" TopLine="5084"/>
</Position6>
<Position7>
<Filename Value="epostunit.pas"/>
- <Caret Line="123" Column="25" TopLine="91"/>
+ <Caret Line="5073" Column="3" TopLine="5050"/>
</Position7>
<Position8>
<Filename Value="epostunit.pas"/>
- <Caret Line="407" Column="29" TopLine="375"/>
+ <Caret Line="4504" Column="10" TopLine="4487"/>
</Position8>
<Position9>
<Filename Value="epostunit.pas"/>
- <Caret Line="442" Column="32" TopLine="403"/>
+ <Caret Line="4307" Column="3" TopLine="4286"/>
</Position9>
<Position10>
<Filename Value="epostunit.pas"/>
- <Caret Line="1803" Column="26" TopLine="1780"/>
+ <Caret Line="4099" Column="3" TopLine="4077"/>
</Position10>
<Position11>
<Filename Value="epostunit.pas"/>
- <Caret Line="1929" Column="35" TopLine="1910"/>
+ <Caret Line="4013" Column="3" TopLine="3991"/>
</Position11>
<Position12>
<Filename Value="epostunit.pas"/>
- <Caret Line="1941" Column="14" TopLine="1920"/>
+ <Caret Line="4011" TopLine="3991"/>
</Position12>
<Position13>
- <Filename Value="epostunit.pas"/>
- <Caret Line="1904" Column="33" TopLine="1885"/>
+ <Filename Value="typenunit.pas"/>
+ <Caret Line="863" Column="3" TopLine="842"/>
</Position13>
<Position14>
<Filename Value="epostunit.pas"/>
- <Caret Line="151" Column="14" TopLine="132"/>
+ <Caret Line="3834" Column="128" TopLine="3828"/>
</Position14>
<Position15>
<Filename Value="epostunit.pas"/>
- <Caret Line="1903" Column="5" TopLine="1897"/>
+ <Caret Line="3166" Column="3" TopLine="3132"/>
</Position15>
<Position16>
<Filename Value="epostunit.pas"/>
- <Caret Line="153" Column="14" TopLine="134"/>
+ <Caret Line="2860" Column="3" TopLine="2836"/>
</Position16>
<Position17>
<Filename Value="epostunit.pas"/>
- <Caret Line="82" Column="22" TopLine="61"/>
+ <Caret Line="2727" Column="3" TopLine="2706"/>
</Position17>
<Position18>
<Filename Value="epostunit.pas"/>
- <Caret Line="153" Column="57" TopLine="121"/>
+ <Caret Line="2410" Column="3" TopLine="2386"/>
</Position18>
<Position19>
- <Filename Value="typenunit.pas"/>
- <Caret Line="350" Column="19" TopLine="342"/>
+ <Filename Value="epostunit.pas"/>
+ <Caret Line="2368" Column="3" TopLine="2344"/>
</Position19>
<Position20>
- <Filename Value="typenunit.pas"/>
- <Caret Line="377" Column="20" TopLine="345"/>
+ <Filename Value="epostunit.pas"/>
+ <Caret Line="2197" Column="3" TopLine="2167"/>
</Position20>
<Position21>
- <Filename Value="typenunit.pas"/>
- <Caret Line="831" Column="42" TopLine="820"/>
+ <Filename Value="epostunit.pas"/>
+ <Caret Line="2105" Column="3" TopLine="2080"/>
</Position21>
<Position22>
<Filename Value="epostunit.pas"/>
- <Caret Line="475" Column="8" TopLine="394"/>
+ <Caret Line="2012" Column="3" TopLine="1987"/>
</Position22>
<Position23>
- <Filename Value="typenunit.pas"/>
- <Caret Line="1935" TopLine="1912"/>
+ <Filename Value="epostunit.pas"/>
+ <Caret Line="1718" Column="3" TopLine="1692"/>
</Position23>
<Position24>
- <Filename Value="typenunit.pas"/>
- <Caret Line="408" Column="59" TopLine="391"/>
+ <Filename Value="epostunit.pas"/>
+ <Caret Line="1584" Column="3" TopLine="1560"/>
</Position24>
<Position25>
- <Filename Value="typenunit.pas"/>
- <Caret Line="1937" Column="22" TopLine="1917"/>
+ <Filename Value="epostunit.pas"/>
+ <Caret Line="1525" Column="3" TopLine="1507"/>
</Position25>
<Position26>
<Filename Value="epostunit.pas"/>
- <Caret Line="1904" Column="71" TopLine="1883"/>
+ <Caret Line="1370" Column="3" TopLine="1356"/>
</Position26>
<Position27>
<Filename Value="epostunit.pas"/>
- <Caret Line="1901" Column="37" TopLine="1882"/>
+ <Caret Line="1036" Column="3" TopLine="1006"/>
</Position27>
<Position28>
<Filename Value="typenunit.pas"/>
- <Caret Line="1943" Column="7" TopLine="1918"/>
+ <Caret Line="413" Column="5" TopLine="393"/>
</Position28>
<Position29>
<Filename Value="typenunit.pas"/>
- <Caret Line="400" Column="96" TopLine="374"/>
+ <Caret Line="2136" Column="3" TopLine="2084"/>
</Position29>
<Position30>
<Filename Value="typenunit.pas"/>
- <Caret Line="1514" Column="15" TopLine="1494"/>
+ <Caret Line="200" TopLine="180"/>
</Position30>
</JumpHistory>
</ProjectSession>
diff --git a/epostunit.pas b/epostunit.pas
index 45cdb26..81bdaf7 100644
--- a/epostunit.pas
+++ b/epostunit.pas
@@ -36,8 +36,8 @@ type
pTPalettenArray = array of pTPalette;
tWerte = class;
tLiKo = array of record
- alpha: extended;
- werte: tWerte;
+ alpha: extended;
+ werte: tWerte;
end;
pTLiKo = ^tLiKo;
pTWerteArray = ^tWerteArray;
@@ -77,7 +77,9 @@ type
function findeAlleDateien(nam: string; var dat: tGenerischeInputDateiInfoArray; Vorlage: tGenerischeInputDateiInfo): boolean;
function ermittleExterneInputParameter(var f: tMyStringlist; out dateien: tGenerischeInputDateiInfoArray): boolean;
function ermittleInterneInputParameter(var dateien: tGenerischeInputDateiInfoArray): boolean;
- procedure initVerzerrung(quelle: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,mt: longint; oberst: boolean; epsilon: extended; verzerrung: tTransformationen; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; Warn: tWarnstufe);
+ procedure initVerzerrung(quelle: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,mt: longint; oberst: boolean; epsilon: extended; verzerrung: tTransformation; verzerrAnzahl: longint; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; Warn: tWarnstufe);
+ function rTransformationen: tTransformation;
+ procedure wTransformationen(tr: tTransformation);
function rXsteps: longint;
procedure wXsteps(xs: longint);
function rTsiz: longint;
@@ -148,8 +150,8 @@ type
procedure schreibeWert(var f: textfile; x,y: longint);
function exprtofloat(st: boolean; s: string): extended;
function paramsdump: string;
- function Transformationen: tTransformationen;
procedure beendeLeseThreadWennFertig;
+ property Transformationen: tTransformation read rTransformationen write wTransformationen;
property _xsteps: longint read rXsteps write wXsteps;
property _tsiz: longint read rTsiz write wTsiz;
// property _xstart: extended read rXstart write wXstart;
@@ -214,14 +216,14 @@ type
ws: tWerteArray;
xmi,xma,tmi,tma,xpmi,xpma: Longint;
xz,yz: extended;
- nbs: tTransformationenArray;
+ nbs: tTransformationArray;
farben: trgbArray;
wertes: array of tExtendedArray;
anzahlens: array of tLongintArray;
pals: tRGBArrayArray;
rahmen: boolean;
beschr: pTBeschriftungen;
- constructor create(i,maxthreads,ibreite,ihoehe,lo,oo,ro,uo: longint; const wes: tWerteArray; xmin,xmax,tmin,tmax: Longint; xzoom,yzoom: extended; Nachbearbeitungen: tTransformationenArray; paletten: pTPalettenArray; beschri: pTBeschriftungen; rm: boolean);
+ constructor create(i,maxthreads,ibreite,ihoehe,lo,oo,ro,uo: longint; const wes: tWerteArray; xmin,xmax,tmin,tmax: Longint; xzoom,yzoom: extended; Nachbearbeitungen: tTransformationArray; paletten: pTPalettenArray; beschri: pTBeschriftungen; rm: boolean);
destructor destroy; override;
procedure stExecute; override;
end;
@@ -308,15 +310,15 @@ type
procedure stExecute; override;
end;
tVerzerrInitThread = class(tLogThread)
- qu,zi: tWerte;
- ZPs: tIntPointArray;
- ZGs: tExtPointArray;
- ZAs: tExtendedArray;
- xMi,xMa,tMi,tMa,x0,t0,mt: longint; // bzgl. Ziel
- eps: extended;
- verz: tTransformationen;
- Warnstufe: tWarnstufe;
- constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tTransformationen; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; Warn: tWarnstufe);
+ qu,zi: tWerte;
+ ZPs: tIntPointArray;
+ ZGs: tExtPointArray;
+ ZAs: tExtendedArray;
+ xMi,xMa,tMi,tMa,x0,t0,mt,va: longint; // bzgl. Ziel
+ eps: extended;
+ verz: tTransformation;
+ Warnstufe: tWarnstufe;
+ constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tTransformation; verzerrAnz: longint; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; Warn: tWarnstufe);
destructor destroy; override;
procedure stExecute; override;
end;
@@ -326,8 +328,9 @@ type
ZGs: tExtPointArray;
ZAs: tExtendedArray;
xMi,xMa,tMi,tMa: longint; // bzgl. Ziel
- vb,nb: tTransformationen;
- constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tTransformationen);
+ vb,nb: tTransformation;
+ va,na: longint;
+ constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tTransformation; vorAnz,nachAnz: longint);
destructor destroy; override;
procedure stExecute; override;
end;
@@ -336,7 +339,7 @@ function neuePalette(var f: tMyStringlist): boolean;
function initBmpHeader(w,h: longint): tBmpHeader;
procedure schreibeBmpHeader(var f: file; w,h: longint);
function findePalette(out Palette: pTPalette; name: string): boolean;
-function erzeugeLegende(st: boolean; var f: tMyStringlist; datei: string; Qu: tWerte; minDichte,maxDichte: extended; nb: tTransformationen; pal: pTPalette): boolean;
+function erzeugeLegende(st: boolean; var f: tMyStringlist; datei: string; Qu: tWerte; minDichte,maxDichte: extended; nb: tTransformation; pal: pTPalette): boolean;
function strToFftDo(out fftDo: tFFTDatenordnung; s: string): boolean;
function findeWerte(s: String; f: tMyStringlist; pws: pTWerteArray; Kont: pTKonturenArray; darfErstellen: boolean): integer;
function findeKontur(s: String; f: tMyStringlist; pks: pTKonturenArray; darfErstellen: boolean): integer;
@@ -356,82 +359,84 @@ uses math, systemunit;
// tWerte **********************************************************************
constructor tWerte.create(Kont: pTKonturenArray; wert: pTWerteArray);
-var ps: tExtrainfos;
+var
+ ps: tExtrainfos;
begin
- inherited create;
- ps:=tExtrainfos.create;
- Genauigkeit:=gSingle;
- leseThread:=nil;
- sWerte:=tLLWerteSingle.create(ps);
- dWerte:=tLLWerteDouble.create(ps);
- eWerte:=tLLWerteExtended.create(ps);
- Konturen:=Kont;
- wertes:=wert;
- bezeichner:='';
+ inherited create;
+ ps:=tExtrainfos.create;
+ Genauigkeit:=gSingle;
+ leseThread:=nil;
+ sWerte:=tLLWerteSingle.create(ps);
+ dWerte:=tLLWerteDouble.create(ps);
+ eWerte:=tLLWerteExtended.create(ps);
+ Konturen:=Kont;
+ wertes:=wert;
+ bezeichner:='';
end;
constructor tWerte.create(original: tWerte; xmin,xmax: longint);
-var ps: tExtrainfos;
- pSi: pTLLWerteSingle;
- pDo: pTLLWerteDouble;
- pEx: pTLLWerteExtended;
-begin
- inherited create;
- original.warteAufBeendigungDesLeseThreads;
- ps:=tExtrainfos.create;
- leseThread:=nil;
- Genauigkeit:=original.Genauigkeit;
- Konturen:=original.Konturen;
- case Genauigkeit of
- gSingle: begin
- pSi:=@(original.sWerte);
- sWerte:=tLLWerteSingle.create(pSi,ps,xmin,xmax);
- dWerte:=tLLWerteDouble.create(ps);
- eWerte:=tLLWerteExtended.create(ps);
- end;
- gDouble: begin
- pDo:=@(original.dWerte);
- sWerte:=tLLWerteSingle.create(ps);
- dWerte:=tLLWerteDouble.create(pDo,ps,xmin,xmax);
- eWerte:=tLLWerteExtended.create(ps);
- end;
- gExtended: begin
- sWerte:=tLLWerteSingle.create(ps);
- dWerte:=tLLWerteDouble.create(ps);
- pEx:=@(original.eWerte);
- eWerte:=tLLWerteExtended.create(pEx,ps,xmin,xmax);
- end;
- end{of case};
- if original.bezeichner='' then bezeichner:=''
- else bezeichner:=original.bezeichner+'''';
- Transformationen.kopiereVon(original.Transformationen);
- wertes:=original.wertes;
+var
+ ps: tExtrainfos;
+ pSi: pTLLWerteSingle;
+ pDo: pTLLWerteDouble;
+ pEx: pTLLWerteExtended;
+begin
+ inherited create;
+ original.warteAufBeendigungDesLeseThreads;
+ ps:=tExtrainfos.create;
+ leseThread:=nil;
+ Genauigkeit:=original.Genauigkeit;
+ Konturen:=original.Konturen;
+ case Genauigkeit of
+ gSingle: begin
+ pSi:=@(original.sWerte);
+ sWerte:=tLLWerteSingle.create(pSi,ps,xmin,xmax);
+ dWerte:=tLLWerteDouble.create(ps);
+ eWerte:=tLLWerteExtended.create(ps);
+ end;
+ gDouble: begin
+ pDo:=@(original.dWerte);
+ sWerte:=tLLWerteSingle.create(ps);
+ dWerte:=tLLWerteDouble.create(pDo,ps,xmin,xmax);
+ eWerte:=tLLWerteExtended.create(ps);
+ end;
+ gExtended: begin
+ sWerte:=tLLWerteSingle.create(ps);
+ dWerte:=tLLWerteDouble.create(ps);
+ pEx:=@(original.eWerte);
+ eWerte:=tLLWerteExtended.create(pEx,ps,xmin,xmax);
+ end;
+ end{of case};
+ if original.bezeichner='' then bezeichner:=''
+ else bezeichner:=original.bezeichner+'''';
+ Transformationen:=original.Transformationen;
+ wertes:=original.wertes;
end;
destructor tWerte.destroy;
begin
- warteAufBeendigungDesLeseThreads;
- if eWerte.params<>sWerte.params then begin
- eWerte.params.free;
- gibAus('Die Werteparameter sind verschieden instaziiert!!!',3);
- end;
- sWerte.params.free;
- eWerte.free;
- dWerte.free;
- sWerte.free;
- inherited destroy;
+ warteAufBeendigungDesLeseThreads;
+ if eWerte.params<>sWerte.params then begin
+ eWerte.params.free;
+ gibAus('Die Werteparameter sind verschieden instaziiert!!!',3);
+ end;
+ sWerte.params.free;
+ eWerte.free;
+ dWerte.free;
+ sWerte.free;
+ inherited destroy;
end;
procedure tWerte.warteAufBeendigungDesLeseThreads;
begin
- if assigned(leseThread) then begin
- gibAus('Warte auf Beendigung des Lesethreads von '''+bezeichner+''' ...',3);
- while not leseThread.fertig do
- sleep(10);
- leseThread.free;
- leseThread:=nil;
- gibAus('... ist fertig',3);
- end;
+ if assigned(leseThread) then begin
+ gibAus('Warte auf Beendigung des Lesethreads von '''+bezeichner+''' ...',3);
+ while not leseThread.fertig do
+ sleep(10);
+ leseThread.free;
+ leseThread:=nil;
+ gibAus('... ist fertig',3);
+ end;
end;
procedure tWerte.kopiereVon(st: boolean; original: tWerte); overload;
@@ -440,27 +445,47 @@ begin
end;
procedure tWerte.kopiereVon(st: boolean; original: tWerte; xmin,xmax: longint); overload;
-var pSi: pTLLWerteSingle;
- pDo: pTLLWerteDouble;
- pEx: pTLLWerteExtended;
-begin
- original.warteAufBeendigungDesLeseThreads;
- Transformationen.kopiereVon(original.Transformationen);
- Genauigkeit:=original.Genauigkeit;
- case Genauigkeit of
- gSingle: begin
- pSi:=@(original.sWerte);
- sWerte.kopiereVon(st,pSi,xmin,xmax);
- end;
- gDouble: begin
- pDo:=@(original.dWerte);
- dWerte.kopiereVon(st,pDo,xmin,xmax);
- end;
- gExtended: begin
- pEx:=@(original.eWerte);
- eWerte.kopiereVon(st,pEx,xmin,xmax);
- end;
- end{of case};
+var
+ pSi: pTLLWerteSingle;
+ pDo: pTLLWerteDouble;
+ pEx: pTLLWerteExtended;
+begin
+ original.warteAufBeendigungDesLeseThreads;
+ Transformationen:=original.Transformationen;
+ Genauigkeit:=original.Genauigkeit;
+ case Genauigkeit of
+ gSingle: begin
+ pSi:=@(original.sWerte);
+ sWerte.kopiereVon(st,pSi,xmin,xmax);
+ end;
+ gDouble: begin
+ pDo:=@(original.dWerte);
+ dWerte.kopiereVon(st,pDo,xmin,xmax);
+ end;
+ gExtended: begin
+ pEx:=@(original.eWerte);
+ eWerte.kopiereVon(st,pEx,xmin,xmax);
+ end;
+ end{of case};
+end;
+
+
+function tWerte.rTransformationen: tTransformation;
+begin
+ case genauigkeit of
+ gSingle: result:=sWerte.params.transformationen;
+ gDouble: result:=dWerte.params.transformationen;
+ gExtended: result:=eWerte.params.transformationen;
+ end{of case};
+end;
+
+procedure tWerte.wTransformationen(tr: tTransformation);
+begin
+ case genauigkeit of
+ gSingle: sWerte.params.transformationen:=tr;
+ gDouble: dWerte.params.transformationen:=tr;
+ gExtended: eWerte.params.transformationen:=tr;
+ end{of case};
end;
function tWerte.rXsteps: longint;
@@ -484,11 +509,11 @@ end;
function tWerte.rTsiz: longint;
begin
- case genauigkeit of
- gSingle: result:=sWerte.params.tsiz;
- gDouble: result:=dWerte.params.tsiz;
- gExtended: result:=eWerte.params.tsiz;
- end{of case};
+ case genauigkeit of
+ gSingle: result:=sWerte.params.tsiz;
+ gDouble: result:=dWerte.params.tsiz;
+ gExtended: result:=eWerte.params.tsiz;
+ end{of case};
end;
procedure tWerte.wTsiz(ts: longint);
@@ -503,1059 +528,1075 @@ end;
function tWerte.rXstart: extended;
begin
- case genauigkeit of
- gSingle: result:=sWerte.params.xstart;
- gDouble: result:=dWerte.params.xstart;
- gExtended: result:=eWerte.params.xstart;
- end{of case};
+ case genauigkeit of
+ gSingle: result:=sWerte.params.xstart;
+ gDouble: result:=dWerte.params.xstart;
+ gExtended: result:=eWerte.params.xstart;
+ end{of case};
end;
procedure tWerte.wXstart(xs: extended);
begin
- case genauigkeit of
- gSingle: begin
- sWerte.params.transformationen.xstart:=xs;
- sWerte.params.refreshKnownValues;
- end;
- gDouble: begin
- dWerte.params.transformationen.xstart:=xs;
- dWerte.params.refreshKnownValues;
- end;
- gExtended: begin
- eWerte.params.transformationen.xstart:=xs;
- eWerte.params.refreshKnownValues;
- end;
- end{of case};
+ case genauigkeit of
+ gSingle: begin
+ sWerte.params.transformationen.xstart:=xs;
+ sWerte.params.refreshKnownValues;
+ end;
+ gDouble: begin
+ dWerte.params.transformationen.xstart:=xs;
+ dWerte.params.refreshKnownValues;
+ end;
+ gExtended: begin
+ eWerte.params.transformationen.xstart:=xs;
+ eWerte.params.refreshKnownValues;
+ end;
+ end{of case};
end;
function tWerte.rXstop: extended;
begin
- case genauigkeit of
- gSingle: result:=sWerte.params.xstop;
- gDouble: result:=dWerte.params.xstop;
- gExtended: result:=eWerte.params.xstop;
- end{of case};
+ case genauigkeit of
+ gSingle: result:=sWerte.params.xstop;
+ gDouble: result:=dWerte.params.xstop;
+ gExtended: result:=eWerte.params.xstop;
+ end{of case};
end;
procedure tWerte.wXstop(xs: extended);
begin
- case genauigkeit of
- gSingle: begin
- sWerte.params.transformationen.xstop:=xs;
- sWerte.params.refreshKnownValues;
- end;
- gDouble: begin
- dWerte.params.transformationen.xstop:=xs;
- dWerte.params.refreshKnownValues;
- end;
- gExtended: begin
- eWerte.params.transformationen.xstop:=xs;
- eWerte.params.refreshKnownValues;
- end;
- end{of case};
+ case genauigkeit of
+ gSingle: begin
+ sWerte.params.transformationen.xstop:=xs;
+ sWerte.params.refreshKnownValues;
+ end;
+ gDouble: begin
+ dWerte.params.transformationen.xstop:=xs;
+ dWerte.params.refreshKnownValues;
+ end;
+ gExtended: begin
+ eWerte.params.transformationen.xstop:=xs;
+ eWerte.params.refreshKnownValues;
+ end;
+ end{of case};
end;
function tWerte.rTstart: extended;
begin
- case genauigkeit of
- gSingle: result:=sWerte.params.tstart;
- gDouble: result:=dWerte.params.tstart;
- gExtended: result:=eWerte.params.tstart;
- end{of case};
+ case genauigkeit of
+ gSingle: result:=sWerte.params.tstart;
+ gDouble: result:=dWerte.params.tstart;
+ gExtended: result:=eWerte.params.tstart;
+ end{of case};
end;
procedure tWerte.wTstart(ts: extended);
begin
- case genauigkeit of
- gSingle: begin
- sWerte.params.transformationen.tstart:=ts;
- sWerte.params.refreshKnownValues;
- end;
- gDouble: begin
- dWerte.params.transformationen.tstart:=ts;
- dWerte.params.refreshKnownValues;
- end;
- gExtended: begin
- eWerte.params.transformationen.tstart:=ts;
- eWerte.params.refreshKnownValues;
- end;
- end{of case};
+ case genauigkeit of
+ gSingle: begin
+ sWerte.params.transformationen.tstart:=ts;
+ sWerte.params.refreshKnownValues;
+ end;
+ gDouble: begin
+ dWerte.params.transformationen.tstart:=ts;
+ dWerte.params.refreshKnownValues;
+ end;
+ gExtended: begin
+ eWerte.params.transformationen.tstart:=ts;
+ eWerte.params.refreshKnownValues;
+ end;
+ end{of case};
end;
function tWerte.rTstop: extended;
begin
- case genauigkeit of
- gSingle: result:=sWerte.params.tstop;
- gDouble: result:=dWerte.params.tstop;
- gExtended: result:=eWerte.params.tstop;
- end{of case};
+ case genauigkeit of
+ gSingle: result:=sWerte.params.tstop;
+ gDouble: result:=dWerte.params.tstop;
+ gExtended: result:=eWerte.params.tstop;
+ end{of case};
end;
procedure tWerte.wTstop(ts: extended);
begin
- case genauigkeit of
- gSingle: begin
- sWerte.params.transformationen.tstop:=ts;
- sWerte.params.refreshKnownValues;
- end;
- gDouble: begin
- dWerte.params.transformationen.tstop:=ts;
- dWerte.params.refreshKnownValues;
- end;
- gExtended: begin
- eWerte.params.transformationen.tstop:=ts;
- eWerte.params.refreshKnownValues;
- end;
- end{of case};
+ case genauigkeit of
+ gSingle: begin
+ sWerte.params.transformationen.tstop:=ts;
+ sWerte.params.refreshKnownValues;
+ end;
+ gDouble: begin
+ dWerte.params.transformationen.tstop:=ts;
+ dWerte.params.refreshKnownValues;
+ end;
+ gExtended: begin
+ eWerte.params.transformationen.tstop:=ts;
+ eWerte.params.refreshKnownValues;
+ end;
+ end{of case};
end;
function tWerte.rNp: extended;
begin
- case genauigkeit of
- gSingle: result:=sWerte.params.np;
- gDouble: result:=dWerte.params.np;
- gExtended: result:=eWerte.params.np;
- end{of case};
+ case genauigkeit of
+ gSingle: result:=sWerte.params.np;
+ gDouble: result:=dWerte.params.np;
+ gExtended: result:=eWerte.params.np;
+ end{of case};
end;
procedure tWerte.wNp(np: extended);
begin
- case genauigkeit of
- gSingle: begin
- sWerte.params.np:=np;
- sWerte.params.refreshKnownValues;
- end;
- gDouble: begin
- dWerte.params.np:=np;
- dWerte.params.refreshKnownValues;
- end;
- gExtended: begin
- eWerte.params.np:=np;
- eWerte.params.refreshKnownValues;
- end;
- end{of case};
+ case genauigkeit of
+ gSingle: begin
+ sWerte.params.np:=np;
+ sWerte.params.refreshKnownValues;
+ end;
+ gDouble: begin
+ dWerte.params.np:=np;
+ dWerte.params.refreshKnownValues;
+ end;
+ gExtended: begin
+ eWerte.params.np:=np;
+ eWerte.params.refreshKnownValues;
+ end;
+ end{of case};
end;
function tWerte.rBeta: extended;
begin
- case genauigkeit of
- gSingle: result:=sWerte.params.beta;
- gDouble: result:=dWerte.params.beta;
- gExtended: result:=eWerte.params.beta;
- end{of case};
+ case genauigkeit of
+ gSingle: result:=sWerte.params.beta;
+ gDouble: result:=dWerte.params.beta;
+ gExtended: result:=eWerte.params.beta;
+ end{of case};
end;
procedure tWerte.wBeta(beta: extended);
begin
- case genauigkeit of
- gSingle: begin
- sWerte.params.beta:=beta;
- sWerte.params.refreshKnownValues;
- end;
- gDouble: begin
- dWerte.params.beta:=beta;
- dWerte.params.refreshKnownValues;
- end;
- gExtended: begin
- eWerte.params.beta:=beta;
- eWerte.params.refreshKnownValues;
- end;
- end{of case};
+ case genauigkeit of
+ gSingle: begin
+ sWerte.params.beta:=beta;
+ sWerte.params.refreshKnownValues;
+ end;
+ gDouble: begin
+ dWerte.params.beta:=beta;
+ dWerte.params.refreshKnownValues;
+ end;
+ gExtended: begin
+ eWerte.params.beta:=beta;
+ eWerte.params.refreshKnownValues;
+ end;
+ end{of case};
end;
function tWerte.rMinw: extended;
begin
- case genauigkeit of
- gSingle: result:=sWerte.params.minw;
- gDouble: result:=dWerte.params.minw;
- gExtended: result:=eWerte.params.minw;
- end{of case};
+ case genauigkeit of
+ gSingle: result:=sWerte.params.minw;
+ gDouble: result:=dWerte.params.minw;
+ gExtended: result:=eWerte.params.minw;
+ end{of case};
end;
procedure tWerte.wMinw(miw: extended);
begin
- Transformationen.wmin:=miw;
- case genauigkeit of
- gSingle: begin
- sWerte.params.minw:=miw;
- sWerte.params.refreshKnownValues;
- end;
- gDouble: begin
- dWerte.params.minw:=miw;
- dWerte.params.refreshKnownValues;
- end;
- gExtended: begin
- eWerte.params.minw:=miw;
- eWerte.params.refreshKnownValues;
- end;
- end{of case};
+ Transformationen.wmin:=miw;
+ case genauigkeit of
+ gSingle: begin
+ sWerte.params.minw:=miw;
+ sWerte.params.refreshKnownValues;
+ end;
+ gDouble: begin
+ dWerte.params.minw:=miw;
+ dWerte.params.refreshKnownValues;
+ end;
+ gExtended: begin
+ eWerte.params.minw:=miw;
+ eWerte.params.refreshKnownValues;
+ end;
+ end{of case};
end;
function tWerte.rMaxw: extended;
begin
- case genauigkeit of
- gSingle: result:=sWerte.params.maxw;
- gDouble: result:=dWerte.params.maxw;
- gExtended: result:=eWerte.params.maxw;
- end{of case};
+ case genauigkeit of
+ gSingle: result:=sWerte.params.maxw;
+ gDouble: result:=dWerte.params.maxw;
+ gExtended: result:=eWerte.params.maxw;
+ end{of case};
end;
procedure tWerte.wMaxw(maw: extended);
begin
- Transformationen.wmax:=maw;
- case genauigkeit of
- gSingle: begin
- sWerte.params.maxw:=maw;
- sWerte.params.refreshKnownValues;
- end;
- gDouble: begin
- dWerte.params.maxw:=maw;
- dWerte.params.refreshKnownValues;
- end;
- gExtended: begin
- eWerte.params.maxw:=maw;
- eWerte.params.refreshKnownValues;
- end;
- end{of case};
+ Transformationen.wmax:=maw;
+ case genauigkeit of
+ gSingle: begin
+ sWerte.params.maxw:=maw;
+ sWerte.params.refreshKnownValues;
+ end;
+ gDouble: begin
+ dWerte.params.maxw:=maw;
+ dWerte.params.refreshKnownValues;
+ end;
+ gExtended: begin
+ eWerte.params.maxw:=maw;
+ eWerte.params.refreshKnownValues;
+ end;
+ end{of case};
end;
function tWerte.findeAlleDateien(nam: string; var dat: tGenerischeInputDateiInfoArray; Vorlage: tGenerischeInputDateiInfo): boolean;
-var err: longint;
- s,prae,post: string;
- i,mi,ma: longint;
- sr: tSearchRec;
-begin
- result:=false;
- if pos('{',nam)>0 then begin
- s:=copy(nam,pos('{',nam)+1,pos('}',nam)-pos('{',nam)-1);
- if pos('..',s)=0 then begin
- gibAus('Syntaxfehler im Dateinamen!',3);
- exit;
- end;
- mi:=strtoint(copy(s,1,pos('..',s)-1));
- ma:=strtoint(copy(s,pos('..',s)+length('..'),length(s)));
- prae:=copy(nam,1,pos('{',nam)-1);
- post:=copy(nam,pos('}',nam)+1,length(nam));
- for i:=mi to ma do
- result:=findeAlleDateien(prae+inttostr(i)+post,dat,Vorlage) or result;
- if not result then begin
- gibAus('Keine Datei passt zum Muster '''+nam+'''!',3);
- exit;
- end;
- end
- else begin
- err:=findfirst(nam,$3f,sr);
- if err<>0 then begin
- findclose(sr);
- gibAus('Keine Datei passt zum Muster '''+nam+'''!',3);
- exit;
- end;
- while err=0 do begin
- setlength(dat,length(dat)+1);
- if Vorlage is tTraceInputDateiInfo then
- dat[length(dat)-1]:=tTraceInputDateiInfo.create(Vorlage);
- if Vorlage is tPhaseSpaceInputDateiInfo then
- dat[length(dat)-1]:=tPhaseSpaceInputDateiInfo.create(Vorlage);
- if Vorlage is tSpaceTimeInputDateiInfo then
- dat[length(dat)-1]:=tSpaceTimeInputDateiInfo.create(Vorlage);
- if Vorlage is tPipeInputDateiInfo then
- dat[length(dat)-1]:=tPipeInputDateiInfo.create(Vorlage);
- dat[length(dat)-1].Name:=extractfilepath(nam)+extractfilename(sr.Name);
- err:=findnext(sr);
- end;
- findclose(sr);
- result:=true;
- end;
+var
+ err: longint;
+ s,prae,post: string;
+ i,mi,ma: longint;
+ sr: tSearchRec;
+begin
+ result:=false;
+ if pos('{',nam)>0 then begin
+ s:=copy(nam,pos('{',nam)+1,pos('}',nam)-pos('{',nam)-1);
+ if pos('..',s)=0 then begin
+ gibAus('Syntaxfehler im Dateinamen!',3);
+ exit;
+ end;
+ mi:=strtoint(copy(s,1,pos('..',s)-1));
+ ma:=strtoint(copy(s,pos('..',s)+length('..'),length(s)));
+ prae:=copy(nam,1,pos('{',nam)-1);
+ post:=copy(nam,pos('}',nam)+1,length(nam));
+ for i:=mi to ma do
+ result:=findeAlleDateien(prae+inttostr(i)+post,dat,Vorlage) or result;
+ if not result then begin
+ gibAus('Keine Datei passt zum Muster '''+nam+'''!',3);
+ exit;
+ end;
+ end
+ else begin
+ err:=findfirst(nam,$3f,sr);
+ if err<>0 then begin
+ findclose(sr);
+ gibAus('Keine Datei passt zum Muster '''+nam+'''!',3);
+ exit;
+ end;
+ while err=0 do begin
+ setlength(dat,length(dat)+1);
+ if Vorlage is tTraceInputDateiInfo then
+ dat[length(dat)-1]:=tTraceInputDateiInfo.create(Vorlage);
+ if Vorlage is tPhaseSpaceInputDateiInfo then
+ dat[length(dat)-1]:=tPhaseSpaceInputDateiInfo.create(Vorlage);
+ if Vorlage is tSpaceTimeInputDateiInfo then
+ dat[length(dat)-1]:=tSpaceTimeInputDateiInfo.create(Vorlage);
+ if Vorlage is tPipeInputDateiInfo then
+ dat[length(dat)-1]:=tPipeInputDateiInfo.create(Vorlage);
+ dat[length(dat)-1].Name:=extractfilepath(nam)+extractfilename(sr.Name);
+ err:=findnext(sr);
+ end;
+ findclose(sr);
+ result:=true;
+ end;
end;
function tWerte.ermittleExterneInputParameter(var f: tMyStringlist; out dateien: tGenerischeInputDateiInfoArray): boolean;
// Parameter ermitteln, die in der Config-Datei stehen
-var s: string;
- ne,be,maxAmp: extended;
- Vorlagen: tInputDateiInfoVorlagen;
- g: textfile;
- erfolg: Word;
- i: Longint;
- mitGewalt: boolean;
+var
+ s: string;
+ ne,be,maxAmp: extended;
+ Vorlagen: tInputDateiInfoVorlagen;
+ g: textfile;
+ erfolg: Word;
+ i: Longint;
+ mitGewalt: boolean;
procedure aufraeumen;
-var ii: longint;
-begin
- if assigned(Vorlagen) then Vorlagen.free;
- for ii:=0 to length(dateien)-1 do
- if assigned(dateien[ii]) then
- dateien[ii].free;
- setlength(dateien,0);
-end;
-
-begin
- result:=false;
- setlength(dateien,0);
- Vorlagen:=tInputDateiInfoVorlagen.create;
- Vorlagen.params:=sWerte.params;
- ne:=0;
- maxAmp:=0;
- sWerte.params.beta:=-1;
- sWerte.params.maxW:=0;
- sWerte.params.minW:=0;
- sWerte.params.np:=0;
- sWerte.params.transformationen.tstart:=0;
- sWerte.params.transformationen.tstop:=0;
- sWerte.params.transformationen.xstart:=0;
- sWerte.params.transformationen.xstop:=0;
- mitGewalt:=false;
- repeat
- if not f.metaReadln(s,true) then begin
- gibAus('Unerwartetes Dateiende!',3);
- aufraeumen;
- exit;
- end;
- if s='Ende' then
- break;
- if s='mit Gewalt' then begin
- mitGewalt:=true;
- continue;
- end;
- if startetMit('Genauigkeit:',s) then begin
- if not Vorlagen.GenauigkeitFromStr(s) then begin
- aufraeumen;
- exit;
- end;
- if (Genauigkeit < Vorlagen.Genauigkeit) then
- Genauigkeit:=Vorlagen.Genauigkeit;
- continue;
- end;
- if startetMit('Gamma:',s) then begin
- Vorlagen.Gamma:=exprtofloat(false,s);
- continue;
- end;
- if startetMit('tmin:',s) then begin
- Vorlagen.tstart:=exprtofloat(false,s);
- continue;
- end;
- if startetMit('tmax:',s) then begin
- Vorlagen.tstop:=exprtofloat(false,s);
- continue;
- end;
- if startetMit('xmin:',s) then begin
- Vorlagen.xstart:=exprtofloat(false,s);
- continue;
- end;
- if startetMit('xmax:',s) then begin
- Vorlagen.xstop:=exprtofloat(false,s);
- continue;
- end;
- if startetMit('Inputparameterdatei:',s) then begin
- if (not mitGewalt) and (not fileexists(extractfilepath(s)+'times-1')) and
+var
+ ii: longint;
+begin
+ if assigned(Vorlagen) then Vorlagen.free;
+ for ii:=0 to length(dateien)-1 do
+ if assigned(dateien[ii]) then
+ dateien[ii].free;
+ setlength(dateien,0);
+end;
+
+begin
+ result:=false;
+ setlength(dateien,0);
+ Vorlagen:=tInputDateiInfoVorlagen.create;
+ Vorlagen.params:=sWerte.params;
+ ne:=0;
+ maxAmp:=0;
+ sWerte.params.beta:=-1;
+ sWerte.params.maxW:=0;
+ sWerte.params.minW:=0;
+ sWerte.params.np:=0;
+ sWerte.params.transformationen.tstart:=0;
+ sWerte.params.transformationen.tstop:=0;
+ sWerte.params.transformationen.xstart:=0;
+ sWerte.params.transformationen.xstop:=0;
+ mitGewalt:=false;
+ repeat
+ if not f.metaReadln(s,true) then begin
+ gibAus('Unerwartetes Dateiende!',3);
+ aufraeumen;
+ exit;
+ end;
+ if s='Ende' then
+ break;
+ if s='mit Gewalt' then begin
+ mitGewalt:=true;
+ continue;
+ end;
+ if startetMit('Genauigkeit:',s) then begin
+ if not Vorlagen.GenauigkeitFromStr(s) then begin
+ aufraeumen;
+ exit;
+ end;
+ if (Genauigkeit < Vorlagen.Genauigkeit) then
+ Genauigkeit:=Vorlagen.Genauigkeit;
+ continue;
+ end;
+ if startetMit('Gamma:',s) then begin
+ Vorlagen.Gamma:=exprtofloat(false,s);
+ continue;
+ end;
+ if startetMit('tmin:',s) then begin
+ Vorlagen.tstart:=exprtofloat(false,s);
+ continue;
+ end;
+ if startetMit('tmax:',s) then begin
+ Vorlagen.tstop:=exprtofloat(false,s);
+ continue;
+ end;
+ if startetMit('xmin:',s) then begin
+ Vorlagen.xstart:=exprtofloat(false,s);
+ continue;
+ end;
+ if startetMit('xmax:',s) then begin
+ Vorlagen.xstop:=exprtofloat(false,s);
+ continue;
+ end;
+ if startetMit('Inputparameterdatei:',s) then begin
+ if (not mitGewalt) and (not fileexists(extractfilepath(s)+'times-1')) and
((Vorlagen.Fehlerbehebungskommando='') or
- (sysutils.ExecuteProcess(Vorlagen.Fehlerbehebungsprogramm,Vorlagen.Fehlerbehebungsparameter,[])<>0) or
- not fileexists(extractfilepath(s)+'times-1')) then begin
- gibAus('Die Simulation in '''+extractfilepath(s)+''' ist nicht abgeschlossen!',3);
- aufraeumen;
- exit;
- end;
- assignfile(g,s);
- reset(g);
- erfolg:=0;
- while not eof(g) do begin
- readln(g,s);
- s:=erstesArgument(s,'#');
- if startetMit('Gamma :',s) then begin
- Vorlagen.Gamma:=strtofloat(s);
- erfolg:=erfolg or 1;
- continue;
- end;
- if startetMit('Beta :',s) then begin
- be:=strtofloat(s);
- erfolg:=erfolg or 2;
- continue;
- end;
- if startetMit('n_el_over_nc :',s) then begin
- ne:=strtofloat(s);
- erfolg:=erfolg or 4;
- continue;
- end;
- if startetMit('.a0 :',s) then begin
- if strtofloat(s)>maxAmp then begin
- maxAmp:=strtofloat(s);
- erfolg:=erfolg or 8;
- end;
- continue;
- end;
- if startetMit('pulse component # ',s) then begin
- erfolg:=erfolg and (not 8);
- continue;
- end;
- if odd(erfolg shr 3) and startetMit('.frequency :',s) then begin
- Vorlagen.groeszenFaktor:=strtofloat(s);
- erfolg:=erfolg and (not 8);
- continue;
- end;
- end;
- close(g);
- if erfolg<>7 then begin
- gibAus('Die Inputparameterdatei enthält die gesuchten Parameter nicht!',3);
- aufraeumen;
- exit;
- end;
- ne:=sqrt(ne)/Vorlagen.groeszenFaktor;
- if (sWerte.params.np<>0) and (ne<>sWerte.params.np) then begin
- gibAus('Die Plasmafrequenzen in den Eingangsdateien unterscheiden sich ('+floattostr(sWerte.params.np)+' vs. '+floattostr(ne)+')!',3);
- aufraeumen;
- exit;
- end;
- sWerte.params.np:=ne;
- if (sWerte.params.beta<>-1) and (be<>sWerte.params.beta) then begin
- gibAus('Die Bezugssystemgeschwindigkeiten in den Eingangsdateien unterscheiden sich ('+floattostr(sWerte.params.beta)+' vs. '+floattostr(be)+')!',3);
- aufraeumen;
- exit;
- end;
- sWerte.params.beta:=be;
- continue;
- end;
- if startetMit('Fehlerbehebungskommando:',s) then begin
- Vorlagen.Fehlerbehebungskommando:=s;
- continue;
- end;
- if startetMit('Spurnummer:',s) then begin
- Vorlagen.SpurNummer:=strtoint(s);
- continue;
- end;
- if startetMit('Feldnummer:',s) then begin
- Vorlagen.FeldNummer:=strtoint(s);
- continue;
- end;
- if startetMit('Feld:',s) then begin
- Vorlagen.FeldNummer:=-1;
- for i:=0 to length(FeldgroeszenNamen)-1 do
- if uppercase(s)=FeldgroeszenNamen[i] then begin
- Vorlagen.FeldNummer:=i;
- break;
- end;
- if Vorlagen.FeldNummer>=0 then continue;
- gibAus('Unbekannte Feldgröße '''+s+'''!',3);
- aufraeumen;
- exit;
- end;
- if startetMit('Analysator:',s) then begin
- Vorlagen.Analysator:=s;
- continue;
- end;
- if startetMit('PhaseSpace-Datei:',s) then begin
- if fileexists(s) then begin
- setlength(dateien,length(dateien)+1);
- dateien[length(dateien)-1]:=tPhaseSpaceInputDateiInfo.create(Vorlagen.PhaseSpaceVorlage);
- dateien[length(dateien)-1].Name:=s;
- continue;
- end;
- if not findeAlleDateien(s,dateien,Vorlagen.PhaseSpaceVorlage) then begin
- aufraeumen;
- exit;
- end;
- continue;
- end;
- if startetMit('SpaceTime-Datei:',s) then begin
- if fileexists(s) then begin
- setlength(dateien,length(dateien)+1);
- dateien[length(dateien)-1]:=tSpaceTimeInputDateiInfo.create(Vorlagen.SpaceTimeVorlage);
- dateien[length(dateien)-1].Name:=s;
- continue;
- end;
- if not findeAlleDateien(s,dateien,Vorlagen.SpaceTimeVorlage) then begin
- aufraeumen;
- exit;
- end;
- continue;
- end;
- if startetMit('Trace-Datei:',s) then begin
- if fileexists(s) then begin
- setlength(dateien,length(dateien)+1);
- dateien[length(dateien)-1]:=tTraceInputDateiInfo.create(Vorlagen.TraceVorlage);
- dateien[length(dateien)-1].Name:=s;
- continue;
- end;
- if not findeAlleDateien(s,dateien,Vorlagen.TraceVorlage) then begin
- aufraeumen;
- exit;
- end;
- continue;
- end;
- if startetMit('Pipe:',s) then begin
- setlength(dateien,length(dateien)+1);
- dateien[length(dateien)-1]:=tPipeInputDateiInfo.create(Vorlagen.PipeVorlage);
- dateien[length(dateien)-1].Name:=s;
- continue;
- end;
- gibAus('Verstehe Parameter '''+s+''' nicht beim Einlesen!',3);
- aufraeumen;
- exit;
- until false;
- sWerte.params.refreshKnownValues;
- Vorlagen.free;
- result:=true;
+ (sysutils.ExecuteProcess(Vorlagen.Fehlerbehebungsprogramm,Vorlagen.Fehlerbehebungsparameter,[])<>0) or
+ not fileexists(extractfilepath(s)+'times-1')) then begin
+ gibAus('Die Simulation in '''+extractfilepath(s)+''' ist nicht abgeschlossen!',3);
+ aufraeumen;
+ exit;
+ end;
+ assignfile(g,s);
+ reset(g);
+ erfolg:=0;
+ while not eof(g) do begin
+ readln(g,s);
+ s:=erstesArgument(s,'#');
+ if startetMit('Gamma :',s) then begin
+ Vorlagen.Gamma:=strtofloat(s);
+ erfolg:=erfolg or 1;
+ continue;
+ end;
+ if startetMit('Beta :',s) then begin
+ be:=strtofloat(s);
+ erfolg:=erfolg or 2;
+ continue;
+ end;
+ if startetMit('n_el_over_nc :',s) then begin
+ ne:=strtofloat(s);
+ erfolg:=erfolg or 4;
+ continue;
+ end;
+ if startetMit('.a0 :',s) then begin
+ if strtofloat(s)>maxAmp then begin
+ maxAmp:=strtofloat(s);
+ erfolg:=erfolg or 8;
+ end;
+ continue;
+ end;
+ if startetMit('pulse component # ',s) then begin
+ erfolg:=erfolg and (not 8);
+ continue;
+ end;
+ if odd(erfolg shr 3) and startetMit('.frequency :',s) then begin
+ Vorlagen.groeszenFaktor:=strtofloat(s);
+ erfolg:=erfolg and (not 8);
+ continue;
+ end;
+ end;
+ close(g);
+ if erfolg<>7 then begin
+ gibAus('Die Inputparameterdatei enthält die gesuchten Parameter nicht!',3);
+ aufraeumen;
+ exit;
+ end;
+ ne:=sqrt(ne)/Vorlagen.groeszenFaktor;
+ if (sWerte.params.np<>0) and (ne<>sWerte.params.np) then begin
+ gibAus('Die Plasmafrequenzen in den Eingangsdateien unterscheiden sich ('+floattostr(sWerte.params.np)+' vs. '+floattostr(ne)+')!',3);
+ aufraeumen;
+ exit;
+ end;
+ sWerte.params.np:=ne;
+ if (sWerte.params.beta<>-1) and (be<>sWerte.params.beta) then begin
+ gibAus('Die Bezugssystemgeschwindigkeiten in den Eingangsdateien unterscheiden sich ('+floattostr(sWerte.params.beta)+' vs. '+floattostr(be)+')!',3);
+ aufraeumen;
+ exit;
+ end;
+ sWerte.params.beta:=be;
+ continue;
+ end;
+ if startetMit('Fehlerbehebungskommando:',s) then begin
+ Vorlagen.Fehlerbehebungskommando:=s;
+ continue;
+ end;
+ if startetMit('Spurnummer:',s) then begin
+ Vorlagen.SpurNummer:=strtoint(s);
+ continue;
+ end;
+ if startetMit('Feldnummer:',s) then begin
+ Vorlagen.FeldNummer:=strtoint(s);
+ continue;
+ end;
+ if startetMit('Feld:',s) then begin
+ Vorlagen.FeldNummer:=-1;
+ for i:=0 to length(FeldgroeszenNamen)-1 do
+ if uppercase(s)=FeldgroeszenNamen[i] then begin
+ Vorlagen.FeldNummer:=i;
+ break;
+ end;
+ if Vorlagen.FeldNummer>=0 then continue;
+ gibAus('Unbekannte Feldgröße '''+s+'''!',3);
+ aufraeumen;
+ exit;
+ end;
+ if startetMit('Analysator:',s) then begin
+ Vorlagen.Analysator:=s;
+ continue;
+ end;
+ if startetMit('PhaseSpace-Datei:',s) then begin
+ if fileexists(s) then begin
+ setlength(dateien,length(dateien)+1);
+ dateien[length(dateien)-1]:=tPhaseSpaceInputDateiInfo.create(Vorlagen.PhaseSpaceVorlage);
+ dateien[length(dateien)-1].Name:=s;
+ continue;
+ end;
+ if not findeAlleDateien(s,dateien,Vorlagen.PhaseSpaceVorlage) then begin
+ aufraeumen;
+ exit;
+ end;
+ continue;
+ end;
+ if startetMit('SpaceTime-Datei:',s) then begin
+ if fileexists(s) then begin
+ setlength(dateien,length(dateien)+1);
+ dateien[length(dateien)-1]:=tSpaceTimeInputDateiInfo.create(Vorlagen.SpaceTimeVorlage);
+ dateien[length(dateien)-1].Name:=s;
+ continue;
+ end;
+ if not findeAlleDateien(s,dateien,Vorlagen.SpaceTimeVorlage) then begin
+ aufraeumen;
+ exit;
+ end;
+ continue;
+ end;
+ if startetMit('Trace-Datei:',s) then begin
+ if fileexists(s) then begin
+ setlength(dateien,length(dateien)+1);
+ dateien[length(dateien)-1]:=tTraceInputDateiInfo.create(Vorlagen.TraceVorlage);
+ dateien[length(dateien)-1].Name:=s;
+ continue;
+ end;
+ if not findeAlleDateien(s,dateien,Vorlagen.TraceVorlage) then begin
+ aufraeumen;
+ exit;
+ end;
+ continue;
+ end;
+ if startetMit('Pipe:',s) then begin
+ setlength(dateien,length(dateien)+1);
+ dateien[length(dateien)-1]:=tPipeInputDateiInfo.create(Vorlagen.PipeVorlage);
+ dateien[length(dateien)-1].Name:=s;
+ continue;
+ end;
+ gibAus('Verstehe Parameter '''+s+''' nicht beim Einlesen!',3);
+ aufraeumen;
+ exit;
+ until false;
+ sWerte.params.refreshKnownValues;
+ Vorlagen.free;
+ result:=true;
end;
function tWerte.ermittleInterneInputParameter(var Dateien: tGenerischeInputDateiInfoArray): boolean;
// Parameter ermitteln, die aus der einzulesenden Datei hervorgehen
-var i,j,k,num,tmpi,br,SpAnz: longint;
- tmps: single;
- tmpd: double;
- tmpe: extended;
- f: file;
- Positionen: tLongintArray;
- Sortiert: tGenerischeInputDateiInfoArray;
- ipp,ipap: tProcess;
- buf: array of byte;
- s,t: string;
-begin
- result:=false;
- if length(Dateien)=0 then begin
- gibAus('Keine Dateien zum Einlesen!',3);
- exit;
- end;
-
- genauigkeit:=gSingle;
- for i:=0 to length(dateien)-1 do
- genauigkeit:=tGenauigkeit(max(genauigkeit,dateien[i].genauigkeit));
- tmpi:=0;
- num:=0;
- tmps:=0;
- tmpd:=0;
- SpAnz:=-1;
- setlength(Positionen,length(dateien));
- for i:=0 to length(Positionen)-1 do
- Positionen[i]:=-1;
- for i:=0 to length(dateien)-1 do begin
- if dateien[i] is tPipeInputDateiInfo then begin
- ipp:=tProcess.create(nil); // dieser Prozess generiert die Daten
- ipp.Executable:=(dateien[i] as tPipeInputDateiInfo).Executable;
- ipp.Parameters.Text:=(dateien[i] as tPipeInputDateiInfo).ParametersText;
- ipp.Options:=ipp.Options + [poUsePipes];
- ipap:=tProcess.create(nil); // dieser Prozess analysiert die Daten
- ipap.Executable:=(dateien[i] as tPipeInputDateiInfo).AnalysatorExecutable;
- ipap.Parameters.Text:=(dateien[i] as tPipeInputDateiInfo).AnalysatorParametersText;
- ipap.Options:=ipp.Options + [poUsePipes];
- ipp.execute;
- ipap.execute;
- s:='';
- br:=0;
- while (ipp.running or (ipp.Output.NumBytesAvailable > 0)) and ipap.running do begin
- if ipap.Output.NumBytesAvailable>0 then begin
- setlength(s,br+ipap.Output.NumBytesAvailable);
- br:=br+ipap.Output.Read(s[br+1],length(s)-br);
- continue;
- end;
- if ipp.Output.NumBytesAvailable > 0 then begin
- setlength(buf,ipp.Output.NumBytesAvailable);
- setlength(buf,ipp.Output.Read(buf[0],length(buf)));
- j:=0;
- k:=-1;
- while (j<length(buf)) and (k<>0) do begin
- k:=ipap.Input.Write(buf[j],length(buf)-j);
- j:=j+k;
- end;
- sleep(100); // SEHR DRECKIG !!!
- continue;
- end;
- sleep(10);
- end;
-
- if not ipap.running then
- ipp.CloseOutput;
- if not ipp.running then
- ipap.CloseInput;
-
- setlength(buf,0);
-
- while ipap.running or (ipap.Output.NumBytesAvailable>0) do begin
- setlength(s,br+ipap.Output.NumBytesAvailable);
- br:=br+ipap.Output.Read(s[br+1],length(s)-br);
- if ipap.running then
- sleep(10);
- end;
-
- if not ipp.waitOnExit then begin
- gibAus('ErmittleInterneInputParameter hat ohne Erfolg auf Ende von ipp gewartet!',3);
- exit;
- end;
- if not ipap.waitOnExit then begin
- gibAus('ErmittleInterneInputParameter hat ohne Erfolg auf Ende von ipap gewartet!',3);
- exit;
- end;
-
- ipp.free;
- ipap.free;
-
- dateien[i].groeszenFaktor:=1;
-
- s:=s+#10;
- while (pos(#13,s)>0) or (pos(#10,s)>0) do begin
- t:=copy(s,1,max(pos(#13,s),pos(#10,s))-1);
- if pos(#13,t)>0 then t:=copy(t,1,pos(#13,t)-1);
- if pos(#10,t)>0 then t:=copy(t,1,pos(#10,t)-1);
- delete(s,1,length(t)+1);
- t:=trim(t);
- if startetMit('Channels',t) and startetMit(':',t) then begin
- dateien[i].xsteps:=strtoint(t);
- continue;
- end;
- if startetMit('Sample Rate',t) and startetMit(':',t) then begin
- dateien[i].groeszenFaktor:=dateien[i].groeszenFaktor/strtofloat(t);
- continue;
- end;
- if startetMit('Precision',t) and startetMit(':',t) then begin
- if rightStr(t,4)<>'-bit' then begin
- gibAus('Ich verstehe die Genauigkeitsangabe '''+t+''' nicht bei einer Pipe!',3);
- exit;
- end;
- delete(t,length(t)-3,4);
- (dateien[i] as tPipeInputDateiInfo).bytesPerSample:=ceil(strtofloat(trim(t))/8);
- continue;
- end;
- if startetMit('Duration',t) and startetMit(':',t) then begin
- erstesArgument(t,'=');
- t:=erstesArgument(t);
- dateien[i].tsiz:=strtoint(t);
- dateien[i].groeszenFaktor:=dateien[i].groeszenFaktor*dateien[i].tsiz;
- continue;
- end;
- if startetMit('Sample Encoding',t) and startetMit(':',t) then begin
- if t='32-bit Signed Integer PCM' then begin
- (dateien[i] as tPipeInputDateiInfo).Kodierung:=k32BitSignedInteger;
- continue;
- end;
- gibAus('Ich kenne die Kodierung '''+t+''' nicht bei einer Pipe!',3);
- exit;
- end;
- end;
- num:=0;
- repeat
- k:=-1;
- for j:=0 to i-1 do
- if Positionen[j]=num then begin
- inc(k);
- inc(num);
- end;
- until k=-1;
- Positionen[i]:=num;
- end;
- if (dateien[i] is tSpaceTimeInputDateiInfo) or
+var
+ i,j,k,num,tmpi,br,SpAnz: longint;
+ tmps: single;
+ tmpd: double;
+ tmpe: extended;
+ f: file;
+ Positionen: tLongintArray;
+ Sortiert: tGenerischeInputDateiInfoArray;
+ ipp,ipap: tProcess;
+ buf: array of byte;
+ s,t: string;
+begin
+ result:=false;
+ if length(Dateien)=0 then begin
+ gibAus('Keine Dateien zum Einlesen!',3);
+ exit;
+ end;
+
+ genauigkeit:=gSingle;
+ for i:=0 to length(dateien)-1 do
+ genauigkeit:=tGenauigkeit(max(genauigkeit,dateien[i].genauigkeit));
+ tmpi:=0;
+ num:=0;
+ tmps:=0;
+ tmpd:=0;
+ SpAnz:=-1;
+ setlength(Positionen,length(dateien));
+ for i:=0 to length(Positionen)-1 do
+ Positionen[i]:=-1;
+ for i:=0 to length(dateien)-1 do begin
+ if dateien[i] is tPipeInputDateiInfo then begin
+ ipp:=tProcess.create(nil); // dieser Prozess generiert die Daten
+ ipp.Executable:=(dateien[i] as tPipeInputDateiInfo).Executable;
+ ipp.Parameters.Text:=(dateien[i] as tPipeInputDateiInfo).ParametersText;
+ ipp.Options:=ipp.Options + [poUsePipes];
+ ipap:=tProcess.create(nil); // dieser Prozess analysiert die Daten
+ ipap.Executable:=(dateien[i] as tPipeInputDateiInfo).AnalysatorExecutable;
+ ipap.Parameters.Text:=(dateien[i] as tPipeInputDateiInfo).AnalysatorParametersText;
+ ipap.Options:=ipp.Options + [poUsePipes];
+ ipp.execute;
+ ipap.execute;
+ s:='';
+ br:=0;
+ while (ipp.running or (ipp.Output.NumBytesAvailable > 0)) and ipap.running do begin
+ if ipap.Output.NumBytesAvailable>0 then begin
+ setlength(s,br+ipap.Output.NumBytesAvailable);
+ br:=br+ipap.Output.Read(s[br+1],length(s)-br);
+ continue;
+ end;
+ if ipp.Output.NumBytesAvailable > 0 then begin
+ setlength(buf,ipp.Output.NumBytesAvailable);
+ setlength(buf,ipp.Output.Read(buf[0],length(buf)));
+ j:=0;
+ k:=-1;
+ while (j<length(buf)) and (k<>0) do begin
+ k:=ipap.Input.Write(buf[j],length(buf)-j);
+ j:=j+k;
+ end;
+ sleep(100); // SEHR DRECKIG !!!
+ continue;
+ end;
+ sleep(10);
+ end;
+
+ if not ipap.running then
+ ipp.CloseOutput;
+ if not ipp.running then
+ ipap.CloseInput;
+
+ setlength(buf,0);
+
+ while ipap.running or (ipap.Output.NumBytesAvailable>0) do begin
+ setlength(s,br+ipap.Output.NumBytesAvailable);
+ br:=br+ipap.Output.Read(s[br+1],length(s)-br);
+ if ipap.running then
+ sleep(10);
+ end;
+
+ if not ipp.waitOnExit then begin
+ gibAus('ErmittleInterneInputParameter hat ohne Erfolg auf Ende von ipp gewartet!',3);
+ exit;
+ end;
+ if not ipap.waitOnExit then begin
+ gibAus('ErmittleInterneInputParameter hat ohne Erfolg auf Ende von ipap gewartet!',3);
+ exit;
+ end;
+
+ ipp.free;
+ ipap.free;
+
+ dateien[i].groeszenFaktor:=1;
+
+ s:=s+#10;
+ while (pos(#13,s)>0) or (pos(#10,s)>0) do begin
+ t:=copy(s,1,max(pos(#13,s),pos(#10,s))-1);
+ if pos(#13,t)>0 then t:=copy(t,1,pos(#13,t)-1);
+ if pos(#10,t)>0 then t:=copy(t,1,pos(#10,t)-1);
+ delete(s,1,length(t)+1);
+ t:=trim(t);
+ if startetMit('Channels',t) and startetMit(':',t) then begin
+ dateien[i].xsteps:=strtoint(t);
+ continue;
+ end;
+ if startetMit('Sample Rate',t) and startetMit(':',t) then begin
+ dateien[i].groeszenFaktor:=dateien[i].groeszenFaktor/strtofloat(t);
+ continue;
+ end;
+ if startetMit('Precision',t) and startetMit(':',t) then begin
+ if rightStr(t,4)<>'-bit' then begin
+ gibAus('Ich verstehe die Genauigkeitsangabe '''+t+''' nicht bei einer Pipe!',3);
+ exit;
+ end;
+ delete(t,length(t)-3,4);
+ (dateien[i] as tPipeInputDateiInfo).bytesPerSample:=ceil(strtofloat(trim(t))/8);
+ continue;
+ end;
+ if startetMit('Duration',t) and startetMit(':',t) then begin
+ erstesArgument(t,'=');
+ t:=erstesArgument(t);
+ dateien[i].tsiz:=strtoint(t);
+ dateien[i].groeszenFaktor:=dateien[i].groeszenFaktor*dateien[i].tsiz;
+ continue;
+ end;
+ if startetMit('Sample Encoding',t) and startetMit(':',t) then begin
+ if t='32-bit Signed Integer PCM' then begin
+ (dateien[i] as tPipeInputDateiInfo).Kodierung:=k32BitSignedInteger;
+ continue;
+ end;
+ gibAus('Ich kenne die Kodierung '''+t+''' nicht bei einer Pipe!',3);
+ exit;
+ end;
+ end;
+ num:=0;
+ repeat
+ k:=-1;
+ for j:=0 to i-1 do
+ if Positionen[j]=num then begin
+ inc(k);
+ inc(num);
+ end;
+ until k=-1;
+ Positionen[i]:=num;
+ end;
+ if (dateien[i] is tSpaceTimeInputDateiInfo) or
(dateien[i] is tTraceInputDateiInfo) then begin
- assign(f,dateien[i].Name);
- reset(f,1);
- blockread(f,num,sizeof(longint));
- dec(num);
- if dateien[i] is tTraceInputDateiInfo then begin
- dateien[i].xsteps:=1;
- dateien[i].xstop:=dateien[i].xstart;
- blockread(f,tmpi,sizeof(longint));
- if spAnz<0 then spAnz:=tmpi;
- if spAnz<>tmpi then begin
- gibAus('Falsche Anzahl an Spuren ('+inttostr(tmpi)+' statt '+inttostr(spAnz)+') in Datei '''+dateien[i].Name+'''!',3);
- close(f);
- exit;
- end;
- if ((dateien[i] as TTraceInputDateiInfo).Spurnummer<0) or ((dateien[i] as TTraceInputDateiInfo).Spurnummer>=spAnz) then begin
- gibAus('Ausgewählte Spurnummer ('+inttostr((dateien[i] as TTraceInputDateiInfo).Spurnummer)+') liegt außerhalb des verfügbaren Bereiches (0..'+inttostr(spAnz-1)+')!',3);
- close(f);
- exit;
- end;
- if ((dateien[i] as TTraceInputDateiInfo).Feldnummer<0) or ((dateien[i] as TTraceInputDateiInfo).Feldnummer>=length(FeldgroeszenNamen)) then begin
- gibAus('Ausgewählte Feldnummer ('+inttostr((dateien[i] as TTraceInputDateiInfo).Feldnummer)+') liegt außerhalb des verfügbaren Bereiches (0..'+inttostr(length(FeldgroeszenNamen)-1)+')!',3);
- close(f);
- exit;
- end;
- end;
- blockread(f,tmpi,sizeof(longint));
- dateien[i].tsiz:=tmpi;
- if dateien[i] is tSpaceTimeInputDateiInfo then begin
- case dateien[i].Genauigkeit of
- gSingle: begin
- blockread(f,tmps,sizeof(single));
- tmpe:=tmps;
- end;
- gDouble: begin
- blockread(f,tmpd,sizeof(double));
- tmpe:=tmpd;
- end;
- gExtended: blockread(f,tmpe,sizeof(extended));
- end{of case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- if i=0 then Transformationen.xstart:=tmpe;
- if tmpe<>Transformationen.xstart then begin
- gibAus('Falscher linker Rand in '''+dateien[i].Name+''', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(Transformationen.xstart)+'.',3);
- close(f);
- exit;
- end;
- case dateien[i].Genauigkeit of
- gSingle: begin
- blockread(f,tmps,sizeof(single));
- tmpe:=tmps;
- end;
- gDouble: begin
- blockread(f,tmpd,sizeof(double));
- tmpe:=tmpd;
- end;
- gExtended: blockread(f,tmpe,sizeof(extended));
- end{of case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- if i=0 then Transformationen.xstop:=tmpe;
- if tmpe<>Transformationen.xstop then begin
- gibAus('Falscher rechter Rand in '''+dateien[i].Name+''', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(Transformationen.xstop)+'.',3);
- close(f);
- exit;
- end;
- blockread(f,tmpi,sizeof(longint));
- dateien[i].xsteps:=tmpi;
- end;
- close(f);
- for j:=0 to i-1 do
- if Positionen[j]=num then begin
- gibAus('Datei '''+dateien[i].Name+''' ist redundant zu '''+dateien[j].Name+'''.',3);
- exit;
- end;
- Positionen[i]:=num;
- end;
- if dateien[i] is tPhaseSpaceInputDateiInfo then begin
- if (i<>0) or (length(dateien)<>1) then begin
- gibAus('Ich kann Phasenraumdateien nicht kaskadieren!',3);
- close(f);
- exit;
- end;
- assign(f,dateien[i].Name);
- reset(f,1);
- case dateien[i].Genauigkeit of
- gSingle: begin
- blockread(f,tmps,sizeof(single));
- tmpe:=tmps;
- end;
- gDouble: begin
- blockread(f,tmpd,sizeof(double));
- tmpe:=tmpd;
- end;
- gExtended: blockread(f,tmpe,sizeof(extended));
- end{of case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- Transformationen.tstart:=tmpe;
- case dateien[i].Genauigkeit of
- gSingle: begin
- blockread(f,tmps,sizeof(single));
- tmpe:=tmps;
- end;
- gDouble: begin
- blockread(f,tmpd,sizeof(double));
- tmpe:=tmpd;
- end;
- gExtended: blockread(f,tmpe,sizeof(extended));
- end{of case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- Transformationen.tstop:=tmpe;
- blockread(f,tmpi,sizeof(longint));
- dateien[i].tsiz:=tmpi;
- case dateien[i].Genauigkeit of
- gSingle: begin
- blockread(f,tmps,sizeof(single));
- tmpe:=tmps;
- end;
- gDouble: begin
- blockread(f,tmpd,sizeof(double));
- tmpe:=tmpd;
- end;
- gExtended: blockread(f,tmpe,sizeof(extended));
- end{of case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- Transformationen.xstart:=tmpe;
- case dateien[i].Genauigkeit of
- gSingle: begin
- blockread(f,tmps,sizeof(single));
- tmpe:=tmps;
- end;
- gDouble: begin
- blockread(f,tmpd,sizeof(double));
- tmpe:=tmpd;
- end;
- gExtended: blockread(f,tmpe,sizeof(extended));
- end{of case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- Transformationen.xstop:=tmpe;
- blockread(f,tmpi,sizeof(longint));
- dateien[i].xsteps:=tmpi;
- close(f);
- Positionen[i]:=0;
- end;
- end;
-
- _tsiz:=0;
- _xsteps:=dateien[0].xsteps;
- for i:=0 to length(dateien)-1 do begin
- if dateien[i].xsteps<>_xsteps then begin
- gibAus('Falsche Anzahl an x-Werten in '''+dateien[i].Name+''', nämlich '+inttostr(dateien[i].xsteps)+' statt '+inttostr(_xsteps)+'.',3);
- exit;
- end;
- _tsiz:=_tsiz+dateien[i].tsiz;
- if dateien[i].groeszenFaktor<>dateien[0].groeszenFaktor then begin
- gibAus('Die Dateien haben nicht alle den gleichen Größenfaktor!',3);
- exit;
- end;
- end;
-
- if not (dateien[0] is tPhaseSpaceInputDateiInfo) then begin
- Transformationen.tstart:=Positionen[0]*dateien[0].groeszenFaktor;
- Transformationen.tstop:=(Positionen[0]+1)*dateien[0].groeszenFaktor;
- for i:=1 to length(Positionen)-1 do begin
- Transformationen.tstart:=min(Transformationen.tstart,Positionen[i]*dateien[i].groeszenFaktor);
- Transformationen.tstop:=max(Transformationen.tstop,(Positionen[i]+1)*dateien[i].groeszenFaktor);
- end;
- if 0<>round(Transformationen.tstart+length(dateien)*dateien[0].groeszenFaktor-Transformationen.tstop) then begin
- gibAus('Die Dateien decken nicht den kompletten Zeitbereich von '+inttostr(round(Transformationen.tstart))+'T bis '+inttostr(round(Transformationen.tstop))+'T ab!',3);
- exit;
- end;
- setlength(sortiert,length(dateien));
- for i:=0 to length(Positionen)-1 do
- sortiert[Positionen[i]-round(Transformationen.tstart/dateien[i].groeszenFaktor)]:=dateien[i];
- for i:=0 to length(Positionen)-1 do begin
- dateien[i]:=sortiert[i];
- if i=0 then begin
- dateien[i].t0abs:=0;
- sWerte.params.tsiz_:=dateien[i].tmax-dateien[i].tmin+1;
- sWerte.params.xsteps_:=dateien[i].xmax-dateien[i].xmin+1;
- end
- else begin
- dateien[i].t0abs:=
- dateien[i-1].t0abs + dateien[i-1].tsiz;
- sWerte.params.tsiz_:=
- sWerte.params.tsiz_ + dateien[i].tmax-dateien[i].tmin+1;
- if sWerte.params.xsteps_<>dateien[i].xmax-dateien[i].xmin+1 then begin
- gibAus('Die Dateien haben unterschiedliche Anzahlen an x-Werten im ausgewählten Bereich!',3);
- exit;
- end;
- end;
- end;
- end;
-
- sWerte.params.refreshKnownValues;
- result:=true;
-end;
-
-procedure tWerte.initVerzerrung(quelle: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,mt: longint; oberst: boolean; epsilon: extended; verzerrung: tTransformationen; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; Warn: tWarnstufe);
-var i,j: longint;
- vits: array[boolean] of tVerzerrInitThread;
- b: boolean;
-begin
- if mt<=1 then begin
- for i:=0 to _tsiz-1 do
- for j:=0 to _xsteps-1 do
- ZAs[j + i*_xsteps]:=0;
- for i:=tMin to tMax do
- for j:=xMin to xMax do begin
- ZGs[j+i*quelle._xsteps]:=verzerrung.transformiereKoordinaten(j,i);
- ZPs[j+i*quelle._xsteps]['x']:=floor(ZGs[j+i*quelle._xsteps]['x']);
- ZPs[j+i*quelle._xsteps]['y']:=floor(ZGs[j+i*quelle._xsteps]['y']);
- ZGs[j+i*quelle._xsteps]['x']:=
- ZGs[j+i*quelle._xsteps]['x'] - ZPs[j+i*quelle._xsteps]['x'];
- ZGs[j+i*quelle._xsteps]['y']:=
- ZGs[j+i*quelle._xsteps]['y'] - ZPs[j+i*quelle._xsteps]['y'];
- ZPs[j+i*quelle._xsteps]['x']:=ZPs[j+i*quelle._xsteps]['x'] - x0Abs; // Zielpositionen um die Nullposition verschieben
- ZPs[j+i*quelle._xsteps]['y']:=ZPs[j+i*quelle._xsteps]['y'] - t0Abs;
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + ZPs[j+i*quelle._xsteps]['y']*_xsteps]:=
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + ZPs[j+i*quelle._xsteps]['y']*_xsteps] + (1-ZGs[j+i*quelle._xsteps]['x'])*(1-ZGs[j+i*quelle._xsteps]['y']);
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + ZPs[j+i*quelle._xsteps]['y']*_xsteps]:=
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + ZPs[j+i*quelle._xsteps]['y']*_xsteps] + ZGs[j+i*quelle._xsteps]['x']*(1-ZGs[j+i*quelle._xsteps]['y']);
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps]:=
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps] + (1-ZGs[j+i*quelle._xsteps]['x'])*ZGs[j+i*quelle._xsteps]['y'];
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps]:=
- ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps] + ZGs[j+i*quelle._xsteps]['x']*ZGs[j+i*quelle._xsteps]['y'];
- end;
- end
- else begin
- for b:=false to true do
- vits[b]:=
- tVerzerrInitThread.create(
- quelle,
- self,
- byte(not b)*xMin + byte(b)*((xMax+xMin) div 2 + 1),
- byte(not b)*((xMax+xMin) div 2) + byte(b)*xMax,
- tMin,
- tMax,
- x0Abs,
- t0Abs,
- mt div 2 + byte(odd(mt) and b),
- epsilon,
- verzerrung,
- ZPs,
- ZGs,
- Warn);
- while not (vits[false].fertig and vits[true].fertig) do
- sleep(10);
- for i:=0 to length(ZAs)-1 do
- ZAs[i]:=
- vits[false].ZAs[i] +
- vits[true].ZAs[i];
- for b:=false to true do
- vits[b].free;
- end;
- if oberst then
- for i:=0 to length(ZAs)-1 do
- if ZAs[i]<epsilon then begin
- if Warn=wsStreng then
- gibAus('Warnung: Erhöhe Divisor ['+inttostr(i)+':'+inttostr(i mod _xsteps)+','+inttostr(i div _xsteps)+'] von '+floattostr(ZAs[i])+' auf epsilon='+floattostr(epsilon)+'.',1);
- ZAs[i]:=epsilon;
- end;
+ assign(f,dateien[i].Name);
+ reset(f,1);
+ blockread(f,num,sizeof(longint));
+ dec(num);
+ if dateien[i] is tTraceInputDateiInfo then begin
+ dateien[i].xsteps:=1;
+ dateien[i].xstop:=dateien[i].xstart;
+ blockread(f,tmpi,sizeof(longint));
+ if spAnz<0 then spAnz:=tmpi;
+ if spAnz<>tmpi then begin
+ gibAus('Falsche Anzahl an Spuren ('+inttostr(tmpi)+' statt '+inttostr(spAnz)+') in Datei '''+dateien[i].Name+'''!',3);
+ close(f);
+ exit;
+ end;
+ if ((dateien[i] as TTraceInputDateiInfo).Spurnummer<0) or ((dateien[i] as TTraceInputDateiInfo).Spurnummer>=spAnz) then begin
+ gibAus('Ausgewählte Spurnummer ('+inttostr((dateien[i] as TTraceInputDateiInfo).Spurnummer)+') liegt außerhalb des verfügbaren Bereiches (0..'+inttostr(spAnz-1)+')!',3);
+ close(f);
+ exit;
+ end;
+ if ((dateien[i] as TTraceInputDateiInfo).Feldnummer<0) or ((dateien[i] as TTraceInputDateiInfo).Feldnummer>=length(FeldgroeszenNamen)) then begin
+ gibAus('Ausgewählte Feldnummer ('+inttostr((dateien[i] as TTraceInputDateiInfo).Feldnummer)+') liegt außerhalb des verfügbaren Bereiches (0..'+inttostr(length(FeldgroeszenNamen)-1)+')!',3);
+ close(f);
+ exit;
+ end;
+ end;
+ blockread(f,tmpi,sizeof(longint));
+ dateien[i].tsiz:=tmpi;
+ if dateien[i] is tSpaceTimeInputDateiInfo then begin
+ case dateien[i].Genauigkeit of
+ gSingle: begin
+ blockread(f,tmps,sizeof(single));
+ tmpe:=tmps;
+ end;
+ gDouble: begin
+ blockread(f,tmpd,sizeof(double));
+ tmpe:=tmpd;
+ end;
+ gExtended: blockread(f,tmpe,sizeof(extended));
+ end{of case};
+ tmpe:=tmpe*dateien[i].groeszenFaktor;
+ if i=0 then Transformationen.xstart:=tmpe;
+ if tmpe<>Transformationen.xstart then begin
+ gibAus('Falscher linker Rand in '''+dateien[i].Name+''', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(Transformationen.xstart)+'.',3);
+ close(f);
+ exit;
+ end;
+ case dateien[i].Genauigkeit of
+ gSingle: begin
+ blockread(f,tmps,sizeof(single));
+ tmpe:=tmps;
+ end;
+ gDouble: begin
+ blockread(f,tmpd,sizeof(double));
+ tmpe:=tmpd;
+ end;
+ gExtended: blockread(f,tmpe,sizeof(extended));
+ end{of case};
+ tmpe:=tmpe*dateien[i].groeszenFaktor;
+ if i=0 then Transformationen.xstop:=tmpe;
+ if tmpe<>Transformationen.xstop then begin
+ gibAus('Falscher rechter Rand in '''+dateien[i].Name+''', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(Transformationen.xstop)+'.',3);
+ close(f);
+ exit;
+ end;
+ blockread(f,tmpi,sizeof(longint));
+ dateien[i].xsteps:=tmpi;
+ end;
+ close(f);
+ for j:=0 to i-1 do
+ if Positionen[j]=num then begin
+ gibAus('Datei '''+dateien[i].Name+''' ist redundant zu '''+dateien[j].Name+'''.',3);
+ exit;
+ end;
+ Positionen[i]:=num;
+ end;
+ if dateien[i] is tPhaseSpaceInputDateiInfo then begin
+ if (i<>0) or (length(dateien)<>1) then begin
+ gibAus('Ich kann Phasenraumdateien nicht kaskadieren!',3);
+ close(f);
+ exit;
+ end;
+ assign(f,dateien[i].Name);
+ reset(f,1);
+ case dateien[i].Genauigkeit of
+ gSingle: begin
+ blockread(f,tmps,sizeof(single));
+ tmpe:=tmps;
+ end;
+ gDouble: begin
+ blockread(f,tmpd,sizeof(double));
+ tmpe:=tmpd;
+ end;
+ gExtended: blockread(f,tmpe,sizeof(extended));
+ end{of case};
+ tmpe:=tmpe*dateien[i].groeszenFaktor;
+ Transformationen.tstart:=tmpe;
+ case dateien[i].Genauigkeit of
+ gSingle: begin
+ blockread(f,tmps,sizeof(single));
+ tmpe:=tmps;
+ end;
+ gDouble: begin
+ blockread(f,tmpd,sizeof(double));
+ tmpe:=tmpd;
+ end;
+ gExtended: blockread(f,tmpe,sizeof(extended));
+ end{of case};
+ tmpe:=tmpe*dateien[i].groeszenFaktor;
+ Transformationen.tstop:=tmpe;
+ blockread(f,tmpi,sizeof(longint));
+ dateien[i].tsiz:=tmpi;
+ case dateien[i].Genauigkeit of
+ gSingle: begin
+ blockread(f,tmps,sizeof(single));
+ tmpe:=tmps;
+ end;
+ gDouble: begin
+ blockread(f,tmpd,sizeof(double));
+ tmpe:=tmpd;
+ end;
+ gExtended: blockread(f,tmpe,sizeof(extended));
+ end{of case};
+ tmpe:=tmpe*dateien[i].groeszenFaktor;
+ Transformationen.xstart:=tmpe;
+ case dateien[i].Genauigkeit of
+ gSingle: begin
+ blockread(f,tmps,sizeof(single));
+ tmpe:=tmps;
+ end;
+ gDouble: begin
+ blockread(f,tmpd,sizeof(double));
+ tmpe:=tmpd;
+ end;
+ gExtended: blockread(f,tmpe,sizeof(extended));
+ end{of case};
+ tmpe:=tmpe*dateien[i].groeszenFaktor;
+ Transformationen.xstop:=tmpe;
+ blockread(f,tmpi,sizeof(longint));
+ dateien[i].xsteps:=tmpi;
+ close(f);
+ Positionen[i]:=0;
+ end;
+ end;
+
+ _tsiz:=0;
+ _xsteps:=dateien[0].xsteps;
+ for i:=0 to length(dateien)-1 do begin
+ if dateien[i].xsteps<>_xsteps then begin
+ gibAus('Falsche Anzahl an x-Werten in '''+dateien[i].Name+''', nämlich '+inttostr(dateien[i].xsteps)+' statt '+inttostr(_xsteps)+'.',3);
+ exit;
+ end;
+ _tsiz:=_tsiz+dateien[i].tsiz;
+ if dateien[i].groeszenFaktor<>dateien[0].groeszenFaktor then begin
+ gibAus('Die Dateien haben nicht alle den gleichen Größenfaktor!',3);
+ exit;
+ end;
+ end;
+
+ if not (dateien[0] is tPhaseSpaceInputDateiInfo) then begin
+ Transformationen.tstart:=Positionen[0]*dateien[0].groeszenFaktor;
+ Transformationen.tstop:=(Positionen[0]+1)*dateien[0].groeszenFaktor;
+ for i:=1 to length(Positionen)-1 do begin
+ Transformationen.tstart:=min(Transformationen.tstart,Positionen[i]*dateien[i].groeszenFaktor);
+ Transformationen.tstop:=max(Transformationen.tstop,(Positionen[i]+1)*dateien[i].groeszenFaktor);
+ end;
+ if 0<>round(Transformationen.tstart+length(dateien)*dateien[0].groeszenFaktor-Transformationen.tstop) then begin
+ gibAus('Die Dateien decken nicht den kompletten Zeitbereich von '+inttostr(round(Transformationen.tstart))+'T bis '+inttostr(round(Transformationen.tstop))+'T ab!',3);
+ exit;
+ end;
+ setlength(sortiert,length(dateien));
+ for i:=0 to length(Positionen)-1 do
+ sortiert[Positionen[i]-round(Transformationen.tstart/dateien[i].groeszenFaktor)]:=dateien[i];
+ for i:=0 to length(Positionen)-1 do begin
+ dateien[i]:=sortiert[i];
+ if i=0 then begin
+ dateien[i].t0abs:=0;
+ sWerte.params.tsiz_:=dateien[i].tmax-dateien[i].tmin+1;
+ sWerte.params.xsteps_:=dateien[i].xmax-dateien[i].xmin+1;
+ end
+ else begin
+ dateien[i].t0abs:=
+ dateien[i-1].t0abs + dateien[i-1].tsiz;
+ sWerte.params.tsiz_:=
+ sWerte.params.tsiz_ + dateien[i].tmax-dateien[i].tmin+1;
+ if sWerte.params.xsteps_<>dateien[i].xmax-dateien[i].xmin+1 then begin
+ gibAus('Die Dateien haben unterschiedliche Anzahlen an x-Werten im ausgewählten Bereich!',3);
+ exit;
+ end;
+ end;
+ end;
+ end;
+
+ sWerte.params.refreshKnownValues;
+ result:=true;
+end;
+
+procedure tWerte.initVerzerrung(quelle: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,mt: longint; oberst: boolean; epsilon: extended; verzerrung: tTransformation; verzerrAnzahl: longint; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; Warn: tWarnstufe);
+var
+ i,j: longint;
+ vits: array[boolean] of tVerzerrInitThread;
+ b: boolean;
+begin
+ if mt<=1 then begin
+ for i:=0 to _tsiz-1 do
+ for j:=0 to _xsteps-1 do
+ ZAs[j + i*_xsteps]:=0;
+ for i:=tMin to tMax do
+ for j:=xMin to xMax do begin
+ ZGs[j+i*quelle._xsteps]:=verzerrung.transformiereKoordinaten(j,i,verzerrAnzahl-1);
+ ZPs[j+i*quelle._xsteps]['x']:=floor(ZGs[j+i*quelle._xsteps]['x']);
+ ZPs[j+i*quelle._xsteps]['y']:=floor(ZGs[j+i*quelle._xsteps]['y']);
+ ZGs[j+i*quelle._xsteps]['x']:=
+ ZGs[j+i*quelle._xsteps]['x'] - ZPs[j+i*quelle._xsteps]['x'];
+ ZGs[j+i*quelle._xsteps]['y']:=
+ ZGs[j+i*quelle._xsteps]['y'] - ZPs[j+i*quelle._xsteps]['y'];
+ ZPs[j+i*quelle._xsteps]['x']:=ZPs[j+i*quelle._xsteps]['x'] - x0Abs; // Zielpositionen um die Nullposition verschieben
+ ZPs[j+i*quelle._xsteps]['y']:=ZPs[j+i*quelle._xsteps]['y'] - t0Abs;
+ ZAs[ZPs[j+i*quelle._xsteps]['x'] + ZPs[j+i*quelle._xsteps]['y']*_xsteps]:=
+ ZAs[ZPs[j+i*quelle._xsteps]['x'] + ZPs[j+i*quelle._xsteps]['y']*_xsteps] + (1-ZGs[j+i*quelle._xsteps]['x'])*(1-ZGs[j+i*quelle._xsteps]['y']);
+ ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + ZPs[j+i*quelle._xsteps]['y']*_xsteps]:=
+ ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + ZPs[j+i*quelle._xsteps]['y']*_xsteps] + ZGs[j+i*quelle._xsteps]['x']*(1-ZGs[j+i*quelle._xsteps]['y']);
+ ZAs[ZPs[j+i*quelle._xsteps]['x'] + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps]:=
+ ZAs[ZPs[j+i*quelle._xsteps]['x'] + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps] + (1-ZGs[j+i*quelle._xsteps]['x'])*ZGs[j+i*quelle._xsteps]['y'];
+ ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps]:=
+ ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps] + ZGs[j+i*quelle._xsteps]['x']*ZGs[j+i*quelle._xsteps]['y'];
+ end;
+ end
+ else begin
+ for b:=false to true do
+ vits[b]:=
+ tVerzerrInitThread.create(
+ quelle,
+ self,
+ byte(not b)*xMin + byte(b)*((xMax+xMin) div 2 + 1),
+ byte(not b)*((xMax+xMin) div 2) + byte(b)*xMax,
+ tMin,
+ tMax,
+ x0Abs,
+ t0Abs,
+ mt div 2 + byte(odd(mt) and b),
+ epsilon,
+ verzerrung,
+ verzerrAnzahl,
+ ZPs,
+ ZGs,
+ Warn);
+ while not (vits[false].fertig and vits[true].fertig) do
+ sleep(10);
+ for i:=0 to length(ZAs)-1 do
+ ZAs[i]:=
+ vits[false].ZAs[i] +
+ vits[true].ZAs[i];
+ for b:=false to true do
+ vits[b].free;
+ end;
+ if oberst then
+ for i:=0 to length(ZAs)-1 do
+ if ZAs[i]<epsilon then begin
+ if Warn=wsStreng then
+ gibAus('Warnung: Erhöhe Divisor ['+inttostr(i)+':'+inttostr(i mod _xsteps)+','+inttostr(i div _xsteps)+'] von '+floattostr(ZAs[i])+' auf epsilon='+floattostr(epsilon)+'.',1);
+ ZAs[i]:=epsilon;
+ end;
end;
function tWerte.xscale: extended;
begin
- if Transformationen.xstop=Transformationen.xstart then result:=1
- else result:=(Transformationen.xstop-Transformationen.xstart)/(Transformationen.xsteps-1);
+ if Transformationen.xstop=Transformationen.xstart then result:=1
+ else result:=(Transformationen.xstop-Transformationen.xstart)/(Transformationen.xsteps-1);
end;
function tWerte.tscale: extended;
begin
- if Transformationen.tstop=Transformationen.tstart then result:=1
- else result:=(Transformationen.tstop-Transformationen.tstart)/(Transformationen.tsiz-1);
+ if Transformationen.tstop=Transformationen.tstart then result:=1
+ else result:=(Transformationen.tstop-Transformationen.tstart)/(Transformationen.tsiz-1);
end;
function tWerte.dichtenParameterErkannt(st: boolean; s: string; threads,xmin,xmax,tmin,tmax: longint): boolean;
begin
- result:=true;
- if startetMit('maximale und minimale Dichten bestimmen',s) then begin
- ermittleMinMaxDichten(st,threads,xmin,xmax,tmin,tmax,s='(symmetrisch)');
- exit;
- end;
- if startetMit('Minimaldichte:',s) then begin
- _minW:=exprtofloat(st,s);
- exit;
- end;
- if startetMit('Maximaldichte:',s) then begin
- _maxW:=exprtofloat(st,s);
- exit;
- end;
- result:=false;
+ result:=true;
+ if startetMit('maximale und minimale Dichten bestimmen',s) then begin
+ ermittleMinMaxDichten(st,threads,xmin,xmax,tmin,tmax,s='(symmetrisch)');
+ exit;
+ end;
+ if startetMit('Minimaldichte:',s) then begin
+ _minW:=exprtofloat(st,s);
+ exit;
+ end;
+ if startetMit('Maximaldichte:',s) then begin
+ _maxW:=exprtofloat(st,s);
+ exit;
+ end;
+ result:=false;
end;
function tWerte.kont2disk(dir: char; x: extended): longint;
begin
- case dir of
- 'x':
- result:=min(_xsteps-1,max(0,round(kont2diskFak(dir,x-Transformationen.xstart))));
- 'y','t':
- result:=min(_tsiz-1,max(0,round(kont2diskFak(dir,x-Transformationen.tstart))));
- else
- result:=-1;
- end;
+ case dir of
+ 'x':
+ result:=min(_xsteps-1,max(0,round(kont2diskFak(dir,x-Transformationen.xstart))));
+ 'y','t':
+ result:=min(_tsiz-1,max(0,round(kont2diskFak(dir,x-Transformationen.tstart))));
+ else
+ result:=-1;
+ end;
end;
function tWerte.kont2diskFak(dir: char; x: extended): extended;
begin
- case dir of
- 'x':
- result:=x*(_xsteps-1)/(Transformationen.xstop-Transformationen.xstart);
- 'y','t':
- result:=x*(_tsiz-1)/(Transformationen.tstop-Transformationen.tstart);
- else
- result:=-1;
- end;
+ case dir of
+ 'x':
+ result:=x*(_xsteps-1)/(Transformationen.xstop-Transformationen.xstart);
+ 'y','t':
+ result:=x*(_tsiz-1)/(Transformationen.tstop-Transformationen.tstart);
+ else
+ result:=-1;
+ end;
end;
function tWerte.disk2kont(dir: char; x: longint): extended;
begin
- case dir of
- 'x':
- result:=disk2kontFak(dir,x)+Transformationen.xstart;
- 'y','t':
- result:=disk2kontFak(dir,x)+Transformationen.tstart;
- else
- result:=nan;
- end;
+ case dir of
+ 'x':
+ result:=disk2kontFak(dir,x)+Transformationen.xstart;
+ 'y','t':
+ result:=disk2kontFak(dir,x)+Transformationen.tstart;
+ else
+ result:=nan;
+ end;
end;
function tWerte.disk2kontFak(dir: char; x: longint): extended;
begin
- case dir of
- 'x':
- result:=x/(_xsteps-1)*(Transformationen.xstop-Transformationen.xstart);
- 'y','t':
- result:=x/(_tsiz-1)*(Transformationen.tstop-Transformationen.tstart);
- else
- result:=nan;
- end;
+ case dir of
+ 'x':
+ result:=x/(_xsteps-1)*(Transformationen.xstop-Transformationen.xstart);
+ 'y','t':
+ result:=x/(_tsiz-1)*(Transformationen.tstop-Transformationen.tstart);
+ else
+ result:=nan;
+ end;
end;
procedure tWerte.schreibeWertIntegriert(var f: textfile; i: longint; hor: boolean);
begin
- case Genauigkeit of
- gSingle:
- sWerte.schreibeWertIntegriert(f,i,hor);
- gDouble:
- dWerte.schreibeWertIntegriert(f,i,hor);
- gExtended:
- eWerte.schreibeWertIntegriert(f,i,hor);
- end{of case};
+ case Genauigkeit of
+ gSingle:
+ sWerte.schreibeWertIntegriert(f,i,hor);
+ gDouble:
+ dWerte.schreibeWertIntegriert(f,i,hor);
+ gExtended:
+ eWerte.schreibeWertIntegriert(f,i,hor);
+ end{of case};
end;
function tWerte.ladeDateien(st: boolean; var f: tMyStringlist; pl,sa: boolean): boolean;
-var inputs: tGenerischeInputDateiInfoArray;
+var
+ inputs: tGenerischeInputDateiInfoArray;
procedure aufraeumen;
-var ii: longint;
-begin
- for ii:=0 to length(inputs)-1 do
- if assigned(inputs[ii]) then
- inputs[ii].free;
- setlength(inputs,0);
-end;
-
-begin
- result:=false;
- warteaufBeendigungDesLeseThreads;
- Transformationen.clear;
- Genauigkeit:=gSingle;
- if not ermittleExterneInputParameter(f,inputs) then begin
- aufraeumen;
- exit;
- end;
- if not ermittleInterneInputParameter(inputs) then begin
- aufraeumen;
- exit;
- end;
- if not st then begin
- case Genauigkeit of
- gSingle:
- sWerte.holeRam(3*byte(sa));
- gDouble:
- dWerte.holeRam(3*byte(sa));
- gExtended:
- eWerte.holeRam(3*byte(sa));
- end{of case};
- if pl then begin
- leseThread:=tLeseThread.create(self,inputs);
- result:=true;
- end
- else
- case Genauigkeit of
- gSingle:
- result:=sWerte.liesDateien(inputs);
- gDouble:
- result:=dWerte.liesDateien(inputs);
- gExtended:
- result:=eWerte.liesDateien(inputs);
- end{of case};
- end
- else
- result:=true;
- Transformationen.xsteps:=_xsteps;
- Transformationen.tsiz:=_tsiz;
+var
+ ii: longint;
+begin
+ for ii:=0 to length(inputs)-1 do
+ if assigned(inputs[ii]) then
+ inputs[ii].free;
+ setlength(inputs,0);
+end;
+
+begin
+ result:=false;
+ warteaufBeendigungDesLeseThreads;
+ if not Transformationen.hatNachfolger then
+ Transformationen.free;
+ Transformationen:=tKeineTransformation.create;
+ Genauigkeit:=gSingle;
+ if not ermittleExterneInputParameter(f,inputs) then begin
+ aufraeumen;
+ exit;
+ end;
+ if not ermittleInterneInputParameter(inputs) then begin
+ aufraeumen;
+ exit;
+ end;
+ if not st then begin
+ case Genauigkeit of
+ gSingle:
+ sWerte.holeRam(3*byte(sa));
+ gDouble:
+ dWerte.holeRam(3*byte(sa));
+ gExtended:
+ eWerte.holeRam(3*byte(sa));
+ end{of case};
+ if pl then begin
+ leseThread:=tLeseThread.create(self,inputs);
+ result:=true;
+ end
+ else
+ case Genauigkeit of
+ gSingle:
+ result:=sWerte.liesDateien(inputs);
+ gDouble:
+ result:=dWerte.liesDateien(inputs);
+ gExtended:
+ result:=eWerte.liesDateien(inputs);
+ end{of case};
+ end
+ else
+ result:=true;
+ Transformationen.xsteps:=_xsteps;
+ Transformationen.tsiz:=_tsiz;
end;
function tWerte.ladeAscii(st: boolean; datei: string): boolean;
-var i,j,k: integer;
- Zeit: extended;
- g: textfile;
- s,t: string;
+var
+ i,j,k: integer;
+ Zeit: extended;
+ g: textfile;
+ s,t: string;
begin
result:=false;
warteaufBeendigungDesLeseThreads;
Genauigkeit:=gExtended;
_tsiz:=-100;
+ if not Transformationen.hatNachfolger then
+ Transformationen.free;
+
+ Transformationen:=tKeineTransformation.create;
+
Transformationen.tstart:=-100;
Transformationen.tstop:=-100;
_xsteps:=-100;
@@ -1607,13 +1648,13 @@ begin
exit;
end;
if (_tsiz=-100) or
- (Transformationen.tstart=-100) or
- (Transformationen.tstop=-100) or
- (_xsteps=-100) or
- (Transformationen.xstart=-100) or
- (Transformationen.xstop=-100) or
- (_np=-100) or
- (_beta=-100) then begin
+ (Transformationen.tstart=-100) or
+ (Transformationen.tstop=-100) or
+ (_xsteps=-100) or
+ (Transformationen.xstart=-100) or
+ (Transformationen.xstop=-100) or
+ (_np=-100) or
+ (_beta=-100) then begin
gibAus('Ungenügende Informationen über Raumzeitfenster in Asci-Input-Datei '''+datei+'''!',3);
closefile(g);
exit;
@@ -1667,7 +1708,6 @@ begin
inc(k);
end;
end;
- Transformationen.clear;
Transformationen.xsteps:=_xsteps;
Transformationen.tsiz:=_tsiz;
gibAus('... fertig '+timetostr(now-Zeit),3);
@@ -1675,12 +1715,13 @@ begin
end;
function tWerte.berechneLiKo(st: boolean; var f: tMyStringlist; threads: longint): boolean;
-var i,xmin,xmax,tmin,tmax: longint;
- liKo: tLiKo;
- s: string;
- fertig: boolean;
- liKoThreads: array of tLiKoThread;
- Zeit: extended;
+var
+ i,xmin,xmax,tmin,tmax: longint;
+ liKo: tLiKo;
+ s: string;
+ fertig: boolean;
+ liKoThreads: array of tLiKoThread;
+ Zeit: extended;
begin
result:=false;
warteaufBeendigungDesLeseThreads;
@@ -1720,13 +1761,11 @@ begin
liKo[length(liKo)-1].werte:=wertes^[i mod (length(wertes^)-1)];
if _xsteps=0 then begin
_xsteps:=liKo[length(liKo)-1].werte._xsteps;
- Transformationen.kopiereVon(liKo[length(liKo)-1].werte.Transformationen);
xmin:=0;
xmax:=_xsteps-1;
end;
if _tsiz=0 then begin
_tsiz:=liKo[length(liKo)-1].werte._tsiz;
- Transformationen.kopiereVon(liKo[length(liKo)-1].werte.Transformationen);
tmin:=0;
tmax:=_tsiz-1;
end;
@@ -1766,7 +1805,10 @@ begin
end;
_xsteps:=xmax-xmin+1;
_tsiz:=tmax-tmin+1;
- Transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
+ Transformationen:=tUeberlagerung.create;
+ for i:=0 to length(liKo)-1 do
+ (Transformationen as tUeberlagerung).addKomponente(liKo[i].werte.Transformationen);
+ Transformationen:=tKoordinatenAusschnitt.create(Transformationen,xmin,xmax,tmin,tmax);
_np:=liKo[0].werte._np;
_beta:=liKo[0].werte._beta;
if st then begin
@@ -1808,9 +1850,13 @@ begin
Genauigkeit:=gExtended;
_xsteps:=0;
_tsiz:=0;
+ xmin:=-1;
+ xmax:=-1;
+ tmin:=-1;
+ tmax:=-1;
Zeit:=now;
- schritt:=1;
- horizontal:=true;
+ schritt:=-1;
+ horizontal:=false;
repeat
if not f.metaReadln(s,true) then begin
gibAus('Unerwartetes Dateiende!',3);
@@ -1850,17 +1896,9 @@ begin
if i<0 then
exit;
quellen[length(quellen)-1]:=wertes^[i];
- if _xsteps=0 then begin
- _xsteps:=quellen[length(quellen)-1]._xsteps;
- Transformationen.kopiereVon(quellen[length(quellen)-1].Transformationen);
- xmin:=0;
- xmax:=_xsteps-1;
- end;
- if _tsiz=0 then begin
- _tsiz:=quellen[length(quellen)-1]._tsiz;
- Transformationen.kopiereVon(quellen[length(quellen)-1].Transformationen);
- tmin:=0;
- tmax:=_tsiz-1;
+ if length(quellen)=1 then begin
+ _xsteps:=quellen[0]._xsteps;
+ _tsiz:=quellen[0]._tsiz;
end;
if _xsteps<>quellen[length(quellen)-1]._xsteps then begin
gibAus('Unterschiedliche Anzahl an x-Schritten: '+inttostr(_xsteps)+' bisher vs. '+inttostr(quellen[length(quellen)-1]._xsteps)+' bei '+inttostr(i)+'!',3);
@@ -1893,16 +1931,36 @@ begin
exit;
end;
- Transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
- _xsteps:=xmax-xmin+1;
- _tsiz:=tmax-tmin+1;
-
- if horizontal then
- _xsteps:=_xsteps*length(quellen)
- else
- _tsiz:=_tsiz*length(quellen);
- if not Transformationen.addAgglomeration(horizontal,Schritt,length(quellen))
- then exit;
+ if xmin<0 then
+ xmin:=0;
+ if xmax<0 then
+ xmax:=quellen[0]._xsteps-1;
+ if tmin<0 then
+ tmin:=0;
+ if tmax<0 then
+ tmax:=quellen[0]._tsiz-1;
+
+ if not Transformationen.hatNachfolger then
+ Transformationen.free;
+ Transformationen:=tAgglomeration.create;
+ (Transformationen as tAgglomeration).horizontal:=horizontal;
+ (Transformationen as tAgglomeration).schritt:=schritt;
+ for i:=0 to length(quellen)-1 do
+ (Transformationen as tAgglomeration).addKomponente(
+ tKoordinatenAusschnitt.create(
+ quellen[i].Transformationen,
+ xmin,xmax,tmin,tmax)
+ );
+
+ _xsteps:=Transformationen.xsteps;
+ _tsiz:=Transformationen.tsiz;
+
+ _minW:=quellen[0]._minW;
+ _maxW:=quellen[0]._maxW;
+ for i:=1 to length(quellen)-1 do begin
+ _minW:=min(_minW,quellen[i]._minW);
+ _maxW:=max(_maxW,quellen[i]._maxW);
+ end;
_np:=quellen[0]._np;
_beta:=quellen[0]._beta;
@@ -1922,8 +1980,8 @@ begin
pSi,
xmin,xmax,
tmin,tmax,
- i*byte(horizontal),
- i*byte(not horizontal)
+ (1+xmax-xmin)*i*byte(horizontal),
+ (1+tmax-tmin)*i*byte(not horizontal)
);
end;
gDouble: begin
@@ -1932,8 +1990,8 @@ begin
pDo,
xmin,xmax,
tmin,tmax,
- i*byte(horizontal),
- i*byte(not horizontal)
+ (1+xmax-xmin)*i*byte(horizontal),
+ (1+tmax-tmin)*i*byte(not horizontal)
);
end;
gExtended: begin
@@ -1942,8 +2000,8 @@ begin
pEx,
xmin,xmax,
tmin,tmax,
- i*byte(horizontal),
- i*byte(not horizontal)
+ (1+xmax-xmin)*i*byte(horizontal),
+ (1+tmax-tmin)*i*byte(not horizontal)
);
end;
end;
@@ -1953,16 +2011,21 @@ begin
end;
function tWerte.berechneQuotient(st: boolean; var f: tMyStringlist; threads, dividend, divisor: longint): boolean;
-var i,xmin,xmax,tmin,tmax: longint;
- s: string;
- fertig: boolean;
- quotientThreads: array of tQuotientThread;
- Zeit,epsilon: extended;
+var
+ i,xmin,xmax,tmin,tmax: longint;
+ s: string;
+ fertig: boolean;
+ quotientThreads: array of tQuotientThread;
+ Zeit,epsilon: extended;
begin
result:=false;
warteaufBeendigungDesLeseThreads;
Zeit:=now;
- Transformationen.kopiereVon(wertes^[dividend].Transformationen);
+ if not Transformationen.hatNachfolger then
+ Transformationen.free;
+ Transformationen:=tUeberlagerung.create;
+ (Transformationen as tUeberlagerung).addKomponente(wertes^[dividend].Transformationen);
+ (Transformationen as tUeberlagerung).addKomponente(wertes^[divisor].Transformationen);
_xsteps:=wertes^[dividend]._xsteps;
xmin:=0;
xmax:=_xsteps-1;
@@ -2006,16 +2069,16 @@ begin
_xsteps:=xmax-xmin+1;
_tsiz:=tmax-tmin+1;
if (wertes^[dividend].Transformationen.xstart<>wertes^[divisor].Transformationen.xstart) or
- (wertes^[dividend].Transformationen.xstop<>wertes^[divisor].Transformationen.xstop) or
- (wertes^[dividend].Transformationen.tstart<>wertes^[divisor].Transformationen.tstart) or
- (wertes^[dividend].Transformationen.tstop<>wertes^[divisor].Transformationen.tstop) or
- (wertes^[dividend]._xsteps<>wertes^[divisor]._xsteps) or
- (wertes^[dividend]._tsiz<>wertes^[divisor]._tsiz) then begin
+ (wertes^[dividend].Transformationen.xstop<>wertes^[divisor].Transformationen.xstop) or
+ (wertes^[dividend].Transformationen.tstart<>wertes^[divisor].Transformationen.tstart) or
+ (wertes^[dividend].Transformationen.tstop<>wertes^[divisor].Transformationen.tstop) or
+ (wertes^[dividend]._xsteps<>wertes^[divisor]._xsteps) or
+ (wertes^[dividend]._tsiz<>wertes^[divisor]._tsiz) then begin
// gibAus('Dividend und Divisor haben verschiedene Abmessungen oder verschiedene Genauigkeiten, sowas verstehe ich nicht!',3);
gibAus('Dividend und Divisor haben verschiedene Abmessungen, sowas verstehe ich nicht!',3);
exit;
end;
- Transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
+ Transformationen:=tKoordinatenAusschnitt.create(Transformationen,xmin,xmax,tmin,tmax);
_np:=wertes^[dividend]._np;
_beta:=wertes^[dividend]._beta;
Genauigkeit:=gExtended;
@@ -2042,20 +2105,25 @@ begin
end;
function tWerte.berechneProdukt(st: boolean; var f: tMyStringlist; threads, faktor1, faktor2: longint): boolean;
-var i,xmin,xmax,tmin,tmax: longint;
- s: string;
- fertig: boolean;
- produktThreads: array of tProduktThread;
- Zeit: extended;
+var
+ i,xmin,xmax,tmin,tmax: longint;
+ s: string;
+ fertig: boolean;
+ produktThreads: array of tProduktThread;
+ Zeit: extended;
begin
result:=false;
warteaufBeendigungDesLeseThreads;
Zeit:=now;
- Transformationen.kopiereVon(wertes^[faktor1].Transformationen);
- _xsteps:=wertes^[faktor1]._xsteps;
+ if not Transformationen.hatNachfolger then
+ Transformationen.free;
+ Transformationen:=tUeberlagerung.create;
+ (Transformationen as tUeberlagerung).addKomponente(wertes^[faktor1].Transformationen);
+ (Transformationen as tUeberlagerung).addKomponente(wertes^[faktor2].Transformationen);
+ _xsteps:=Transformationen.xsteps;
xmin:=0;
xmax:=_xsteps-1;
- _tsiz:=wertes^[faktor1]._tsiz;
+ _tsiz:=Transformationen.tsiz;
tmin:=0;
tmax:=_tsiz-1;
_np:=wertes^[faktor1]._np;
@@ -2090,15 +2158,15 @@ begin
_xsteps:=xmax-xmin+1;
_tsiz:=tmax-tmin+1;
if (wertes^[faktor1].Transformationen.xstart<>wertes^[faktor2].Transformationen.xstart) or
- (wertes^[faktor1].Transformationen.xstop<>wertes^[faktor2].Transformationen.xstop) or
- (wertes^[faktor1].Transformationen.tstart<>wertes^[faktor2].Transformationen.tstart) or
- (wertes^[faktor1].Transformationen.tstop<>wertes^[faktor2].Transformationen.tstop) or
- (wertes^[faktor1]._xsteps<>wertes^[faktor2]._xsteps) or
- (wertes^[faktor1]._tsiz<>wertes^[faktor2]._tsiz) then begin
+ (wertes^[faktor1].Transformationen.xstop<>wertes^[faktor2].Transformationen.xstop) or
+ (wertes^[faktor1].Transformationen.tstart<>wertes^[faktor2].Transformationen.tstart) or
+ (wertes^[faktor1].Transformationen.tstop<>wertes^[faktor2].Transformationen.tstop) or
+ (wertes^[faktor1]._xsteps<>wertes^[faktor2]._xsteps) or
+ (wertes^[faktor1]._tsiz<>wertes^[faktor2]._tsiz) then begin
gibAus('Faktor1 und Faktor2 haben verschiedene Abmessungen, sowas verstehe ich nicht!',3);
exit;
end;
- Transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
+ Transformationen:=tKoordinatenAusschnitt.create(Transformationen,xmin,xmax,tmin,tmax);
_np:=wertes^[faktor1]._np;
_beta:=wertes^[faktor1]._beta;
Genauigkeit:=gExtended;
@@ -2125,16 +2193,17 @@ begin
end;
function tWerte.berechneKorrelation(st: boolean; var f: tMyStringlist; threads: longint; const quelle: tWerte): boolean;
-var i,xmin,xmax,tmin,tmax: longint;
- s: string;
- wavelet: tWavelet;
- fertig: boolean;
- ausrichtung: word; // 0 = zentriert, 1 = anfangsbündig, 2 = endbündig
- korrelThreads: array of tKorrelThread;
- Zeit,pvFehler: extended;
- pSi: pTLLWerteSingle;
- pDo: pTLLWerteDouble;
- pEx: pTLLWerteExtended;
+var
+ i,xmin,xmax,tmin,tmax: longint;
+ s: string;
+ wavelet: tWavelet;
+ fertig: boolean;
+ ausrichtung: word; // 0 = zentriert, 1 = anfangsbündig, 2 = endbündig
+ korrelThreads: array of tKorrelThread;
+ Zeit,pvFehler: extended;
+ pSi: pTLLWerteSingle;
+ pDo: pTLLWerteDouble;
+ pEx: pTLLWerteExtended;
begin
result:=false;
warteaufBeendigungDesLeseThreads;
@@ -2142,7 +2211,9 @@ begin
wavelet:=tWavelet.create;
wavelet.mitFFT:=false;
Zeit:=now;
- Transformationen.kopiereVon(quelle.Transformationen);
+ if not Transformationen.hatNachfolger then
+ Transformationen.free;
+ Transformationen:=quelle.Transformationen;
wavelet.freq:=0;
wavelet.tfwhm:=1;
wavelet.typ:=wtSin2;
@@ -2215,7 +2286,7 @@ begin
exit;
until false;
- Transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
+ Transformationen:=tKoordinatenAusschnitt.create(Transformationen,xmin,xmax,tmin,tmax);
_xsteps:=xmax-xmin+1;
if wavelet.mitFFT then begin
i:=1;
@@ -2300,100 +2371,103 @@ begin
end;
procedure tWerte.ermittleMinMaxDichten(st: boolean; threads,xmin,xmax,tmin,tmax: longint; symmetrisch: boolean);
-var i,j: longint;
- DTs: array of tDichteThread;
- fertig: boolean;
- Zeit: extended;
-begin
- if st then begin
- if _minW>=_maxW then _maxW:=_minW+1;
- exit;
- end;
- warteaufBeendigungDesLeseThreads;
- Zeit:=now;
- setlength(DTs,min(threads,xmax+1-xmin));
- gibAus('Ermittle maximale und minimale Dichten ...',3);
- j:=xmin;
- for i:=0 to length(DTs)-1 do begin
- DTs[i]:=tDichteThread.create(j,Byte(i=length(DTs)-1)*xmax + Byte(i<length(DTs)-1)*(j+ ((xmax+1-xmin) div length(DTs))),tmin,tmax,self);
- j:=Byte(i=length(DTs)-1)*xmax + Byte(i<length(DTs)-1)*(j+((xmax+1-xmin) div length(DTs)))+1;
- gibAus('Dichtethread '+inttostr(i)+' gestartet!',1);
- end;
- repeat
- sleep(10);
- fertig:=true;
- for i:=0 to length(DTs)-1 do
- fertig:=fertig and DTs[i].fertig;
- until fertig;
- gibAus('Alle Dichtethreads beendet!',1);
- _maxW:=DTs[0].maxDichte;
- _minW:=DTs[0].minDichte;
- for i:=1 to length(DTs)-1 do begin
- _maxW:=max(_maxW,DTs[i].maxDichte);
- _minW:=min(_minW,DTs[i].minDichte);
- DTs[i].free;
- end;
- gibAus('... sie sind '+myfloattostr(_minW)+' und '+myfloattostr(_maxW)+'. '+timetostr(now-Zeit),3);
- if symmetrisch then begin
- _minW:=min(_minW,-_maxW);
- _maxW:=max(_maxW,-_minW);
- gibAus('Jetzt sind sie '+myfloattostr(_minW)+' und '+myfloattostr(_maxW)+'. '+timetostr(now-Zeit),3);
- end;
+var
+ i,j: longint;
+ DTs: array of tDichteThread;
+ fertig: boolean;
+ Zeit: extended;
+begin
+ if st then begin
+ if _minW>=_maxW then _maxW:=_minW+1;
+ exit;
+ end;
+ warteaufBeendigungDesLeseThreads;
+ Zeit:=now;
+ setlength(DTs,min(threads,xmax+1-xmin));
+ gibAus('Ermittle maximale und minimale Dichten ...',3);
+ j:=xmin;
+ for i:=0 to length(DTs)-1 do begin
+ DTs[i]:=tDichteThread.create(j,Byte(i=length(DTs)-1)*xmax + Byte(i<length(DTs)-1)*(j+ ((xmax+1-xmin) div length(DTs))),tmin,tmax,self);
+ j:=Byte(i=length(DTs)-1)*xmax + Byte(i<length(DTs)-1)*(j+((xmax+1-xmin) div length(DTs)))+1;
+ gibAus('Dichtethread '+inttostr(i)+' gestartet!',1);
+ end;
+ repeat
+ sleep(10);
+ fertig:=true;
+ for i:=0 to length(DTs)-1 do
+ fertig:=fertig and DTs[i].fertig;
+ until fertig;
+ gibAus('Alle Dichtethreads beendet!',1);
+ _maxW:=DTs[0].maxDichte;
+ _minW:=DTs[0].minDichte;
+ for i:=1 to length(DTs)-1 do begin
+ _maxW:=max(_maxW,DTs[i].maxDichte);
+ _minW:=min(_minW,DTs[i].minDichte);
+ DTs[i].free;
+ end;
+ gibAus('... sie sind '+myfloattostr(_minW)+' und '+myfloattostr(_maxW)+'. '+timetostr(now-Zeit),3);
+ if symmetrisch then begin
+ _minW:=min(_minW,-_maxW);
+ _maxW:=max(_maxW,-_minW);
+ gibAus('Jetzt sind sie '+myfloattostr(_minW)+' und '+myfloattostr(_maxW)+'. '+timetostr(now-Zeit),3);
+ end;
end;
procedure tWerte.gleicheMinMaxDichtenAn(st: boolean; var f: tMyStringlist; symmetrisch: boolean);
-var i: longint;
- s: string;
- Zeit: extended;
- vgWs: array of tWerte;
-begin
- setlength(vgWs,0);
-
- repeat
- if not f.metaReadln(s,true) then begin
- gibAus('Unerwartetes Dateiende!',3);
- exit;
- end;
- if s='Ende' then break;
- setlength(vgWs,length(vgWs)+1);
- vgWs[length(vgWs)-1]:=wertes^[findeWerte(s,nil,wertes,Konturen,false)];
- until false;
-
- if st then begin
- if _minW>=_maxW then _maxW:=_minW+1;
- exit;
- end;
- warteaufBeendigungDesLeseThreads;
- for i:=0 to length(vgWs)-1 do
- vgWs[i].warteAufBeendigungDesLeseThreads;
- Zeit:=now;
- gibAus('Gleiche maximale und minimale Dichten an ...',3);
-
- for i:=0 to length(vgWs)-1 do begin
- _minW:=min(_minW,vgWs[i]._minw);
- _maxW:=max(_maxW,vgWs[i]._maxw);
- end;
-
- if symmetrisch then begin
- _minW:=min(_minW,-_maxW);
- _maxW:=max(_maxW,-_minW);
- end;
-
- for i:=0 to length(vgWs)-1 do begin
- vgWs[i]._minw:=_minW;
- vgWs[i]._maxw:=_maxW;
- end;
-
- gibAus('... sie sind '+myfloattostr(_minW)+' und '+myfloattostr(_maxW)+'. '+timetostr(now-Zeit),3);
- if symmetrisch then begin
- _minW:=min(_minW,-_maxW);
- _maxW:=max(_maxW,-_minW);
- gibAus('Jetzt sind sie '+myfloattostr(_minW)+' und '+myfloattostr(_maxW)+'. '+timetostr(now-Zeit),3);
- end;
+var
+ i: longint;
+ s: string;
+ Zeit: extended;
+ vgWs: array of tWerte;
+begin
+ setlength(vgWs,0);
+
+ repeat
+ if not f.metaReadln(s,true) then begin
+ gibAus('Unerwartetes Dateiende!',3);
+ exit;
+ end;
+ if s='Ende' then break;
+ setlength(vgWs,length(vgWs)+1);
+ vgWs[length(vgWs)-1]:=wertes^[findeWerte(s,nil,wertes,Konturen,false)];
+ until false;
+
+ if st then begin
+ if _minW>=_maxW then _maxW:=_minW+1;
+ exit;
+ end;
+ warteaufBeendigungDesLeseThreads;
+ for i:=0 to length(vgWs)-1 do
+ vgWs[i].warteAufBeendigungDesLeseThreads;
+ Zeit:=now;
+ gibAus('Gleiche maximale und minimale Dichten an ...',3);
+
+ for i:=0 to length(vgWs)-1 do begin
+ _minW:=min(_minW,vgWs[i]._minw);
+ _maxW:=max(_maxW,vgWs[i]._maxw);
+ end;
+
+ if symmetrisch then begin
+ _minW:=min(_minW,-_maxW);
+ _maxW:=max(_maxW,-_minW);
+ end;
+
+ for i:=0 to length(vgWs)-1 do begin
+ vgWs[i]._minw:=_minW;
+ vgWs[i]._maxw:=_maxW;
+ end;
+
+ gibAus('... sie sind '+myfloattostr(_minW)+' und '+myfloattostr(_maxW)+'. '+timetostr(now-Zeit),3);
+ if symmetrisch then begin
+ _minW:=min(_minW,-_maxW);
+ _maxW:=max(_maxW,-_minW);
+ gibAus('Jetzt sind sie '+myfloattostr(_minW)+' und '+myfloattostr(_maxW)+'. '+timetostr(now-Zeit),3);
+ end;
end;
function tWerte.fft(threads: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; const fen: tFenster; out pvFehler: extended; Warn: tWarnstufe): boolean;
-var len: longint;
+var
+ len: longint;
begin
len:=1;
if senkrecht then begin
@@ -2409,9 +2483,10 @@ begin
end;
function tWerte.fft(threads,xmin,xmax,tmin,tmax: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; const fen: tFenster; out pvFehler: extended; Warn: tWarnstufe): boolean;
-var fftThreads: array of tFFTThread;
- i: longint;
- fertig: boolean;
+var
+ fftThreads: array of tFFTThread;
+ i: longint;
+ fertig: boolean;
begin
result:=false;
if senkrecht then begin
@@ -2477,10 +2552,11 @@ begin
end;
function tWerte.berechneZeitfrequenzanalyse(st: boolean; var f: tMyStringlist; threads: longint; const quelle: tWerte; Warn: tWarnstufe): boolean;
-var i,j,tmin,tmax,tOf,Schritt: longint;
- Zeit,pvFehler,freqMax: extended;
- Fenster: tFenster;
- s: string;
+var
+ i,j,tmin,tmax,tOf,Schritt: longint;
+ Zeit,pvFehler,freqMax: extended;
+ Fenster: tFenster;
+ s: string;
begin
result:=false;
if (not st) and (quelle._xsteps<>1) and (quelle._tsiz<>1) then begin
@@ -2489,14 +2565,16 @@ begin
end;
warteaufBeendigungDesLeseThreads;
Zeit:=now;
- transformationen.clear;
Fenster.Breite:=0;
Fenster.aktiv:=false;
Fenster.Rand:=0;
Schritt:=round(sqrt(quelle._tsiz));
tmin:=0;
tmax:=quelle._tsiz-1;
- freqMax:=quelle._tsiz/(quelle.Transformationen.tstop-quelle.Transformationen.tstart);
+ if (quelle._xsteps=1) then
+ freqMax:=quelle._tsiz/(quelle.Transformationen.tstop-quelle.Transformationen.tstart)
+ else
+ freqMax:=quelle._xsteps/(quelle.Transformationen.xstop-quelle.Transformationen.xstart);
Genauigkeit:=gExtended;
repeat
if not f.metaReadln(s,true) then begin
@@ -2561,6 +2639,23 @@ begin
floattostrtrunc(disk2kontFak('t',tmax-tmin+1),2,true)+')',3);
exit;
end;
+
+ if not Transformationen.hatNachfolger then
+ Transformationen.free;
+
+ Transformationen:=tAgglomeration.create;
+
+ if quelle._tsiz<>1 then begin
+ for i:=0 to _xsteps-1 do
+ (Transformationen as tAgglomeration).addKomponente(quelle.Transformationen);
+ (Transformationen as tAgglomeration).schritt:=(quelle.disk2kont('t',tmax)-quelle.disk2kont('t',tmin))*(1+1/(tmax-tmin));
+ end
+ else begin
+ for i:=0 to _tsiz-1 do
+ (Transformationen as tAgglomeration).addKomponente(quelle.Transformationen);
+ (Transformationen as tAgglomeration).schritt:=(quelle.disk2kont('x',tmax)-quelle.disk2kont('x',tmin))*(1+1/(tmax-tmin));
+ end;
+(*
Transformationen.xsteps:=_xsteps;
Transformationen.tsiz:=_tsiz;
if quelle._tsiz<>1 then begin
@@ -2575,6 +2670,7 @@ begin
Transformationen.tstart:=0;
Transformationen.tstop:=quelle.disk2kontFak('x',_tsiz-1); // _tstop:=_tsiz/(quelle._xsteps-1)*(quelle._xstop-quelle._xstart);
end;
+*)
if not st then begin
tOf:=(_tsiz-Fenster.Breite) div 2;
eWerte.holeRam(3);
@@ -2611,14 +2707,14 @@ begin
end;
gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',3);
end;
- Transformationen.addFFT(false,true);
+ Transformationen:=tFFTTransformation.create(Transformationen,false,true);
if (Transformationen.tstop<=freqmax) or (freqmax<=0) then
_tsiz:=_tsiz div 2
else begin
freqmax:=Transformationen.tstop * round((_tsiz div 2)/Transformationen.tstop*freqmax) / (_tsiz div 2);
_tsiz:=round((_tsiz div 2)/Transformationen.tstop*freqmax);
end;
- Transformationen.addAusschnitt(0,_xsteps-1,0,_tsiz-1);
+ Transformationen:=tKoordinatenAusschnitt.create(Transformationen,0,_xsteps-1,0,_tsiz-1);
if not st then
eWerte.holeRAM(0);
gibAus('... fertig '+timetostr(now-Zeit),3);
@@ -2626,137 +2722,158 @@ begin
end;
function tWerte.berechneVerzerrung(st: boolean; var f: tMyStringlist; threads: longint; const quelle: tWerte; Warn: tWarnstufe): boolean;
-var i,j: longint;
- grenzen: t2x2Longint;
- ZPs: tIntPointArray; // Zielpositionen
- ZGs: tExtPointArray; // Zielgewichte
- ZAs: tExtendedArray; // Anzahl Quellen, die auf entsprechende Zielposition abgebildet werden
- Zeit,epsilon: extended;
- Vorbearbeitung,
- Nachbearbeitung,
- verzerrung: tTransformationen;
- s: string;
- verzerrThreads: array of tVerzerrThread;
- fertig: boolean;
+var
+ i,j: longint;
+ grenzen: t2x2Longint;
+ ZPs: tIntPointArray; // Zielpositionen
+ ZGs: tExtPointArray; // Zielgewichte
+ ZAs: tExtendedArray; // Anzahl Quellen, die auf entsprechende Zielposition abgebildet werden
+ Zeit,epsilon: extended;
+ Vorbearbeitung,
+ Nachbearbeitung,
+ verzerrung,tmp: tTransformation;
+ vorAnz,nachAnz,verAnz: longint;
+ s: string;
+ verzerrThreads: array of tVerzerrThread;
+ fertig,
+ bearbeitungenLoeschen: boolean;
procedure aufraeumen;
-var ii: longint;
-begin
- for ii:=0 to length(verzerrThreads)-1 do
- if assigned(verzerrThreads[ii]) then
- verzerrThreads[ii].free;
- setlength(verzerrThreads,0);
- Vorbearbeitung.free;
- Nachbearbeitung.free;
- verzerrung.free;
- setlength(ZPs,0);
- setlength(ZGs,0);
- setlength(ZAs,0);
-end;
-begin
- result:=false;
- warteaufBeendigungDesLeseThreads;
- gibAus('Verzerrung berechnen ... ',3);
- Zeit:=now;
- verzerrung:=tTransformationen.create;
- verzerrung.xsteps:=quelle._xsteps;
- verzerrung.tsiz:=quelle._tsiz;
- epsilon:=1e-9;
- Genauigkeit:=gExtended;
- Vorbearbeitung:=tTransformationen.create;
- Nachbearbeitung:=tTransformationen.create;
- repeat
- if not f.metaReadln(s,true) then begin
- gibAus('Unerwartetes Dateiende!',3);
- aufraeumen;
- exit;
- end;
- if s='Ende' then break;
- if quelle.dichtenParameterErkannt(st,s,threads,0,_xsteps-1,0,_tsiz-1) then continue;
- if startetMit('Threadanzahl:',s) then begin
- threads:=strtoint(s);
- continue;
- end;
- if startetMit('Epsilon:',s) then begin
- epsilon:=exprtofloat(st,s);
- continue;
- end;
- if startetMit('Abbildung:',s) then begin
- if not verzerrung.add(st,s,quelle.xscale,quelle.tscale,@(exprtofloat)) then begin
- gibAus('Syntaxfehler in der Funktion '''+s+'''!',3);
- aufraeumen;
- exit;
- end;
- if not st then begin
- gibAus(verzerrung.dumpParams,3);
- for i:=0 to 1 do
- for j:=0 to 1 do
- gibAus(
- inttostr(i*(quelle._xsteps-1))+';'+inttostr(j*(quelle._tsiz-1))+' -> '+
- tExtPointToStr(verzerrung.transformiereKoordinaten(i*(quelle._xsteps-1),j*(quelle._tsiz-1))),3);
- end;
- continue;
- end;
- if startetMit('Nachbearbeitung:',s) then begin
- if not Nachbearbeitung.add(st,s,f,@exprtofloat) then begin
- aufraeumen;
- exit;
- end;
- continue;
- end;
- if startetMit('Vorbearbeitung:',s) then begin
- if not Vorbearbeitung.add(st,s,f,@exprtofloat) then begin
- aufraeumen;
- exit;
- end;
- continue;
- end;
- gibAus('Verstehe Option '''+s+''' nicht bei Erstellung einer Verzerrung!',3);
- aufraeumen;
- exit;
- until false;
- Transformationen.kopiereVon(quelle.Transformationen);
- Transformationen.append(Vorbearbeitung);
- Transformationen.append(Verzerrung);
- Transformationen.append(Nachbearbeitung);
- if not st then begin
- gibAus('... Zielausdehnung berechnen ... ',3);
- verzerrung.berechneZielausdehnung(grenzen);
- _xsteps:=grenzen['x','y']-grenzen['x','x']+2;
- _tsiz:=grenzen['y','y']-grenzen['y','x']+2;
- if (_xsteps<=1) or (_tsiz<=1) then begin
- gibAus('Es passt kein Rechteck des Ziels vollständig in die Quelldaten!',3);
- aufraeumen;
- exit;
- end;
- eWerte.holeRam(3);
- gibAus('Positionen und Gewichte initialisieren ...',3);
- setlength(ZPs,quelle._xsteps*quelle._tsiz);
- setlength(ZGs,quelle._xsteps*quelle._tsiz);
- setlength(ZAs,_xsteps*_tsiz);
- initVerzerrung(quelle,0,quelle._xsteps-1,0,quelle._tsiz-1,grenzen['x','x'],grenzen['y','x'],threads,true,epsilon,verzerrung,ZPs,ZGs,ZAs,Warn);
- gibAus('... fertig, Threads starten',3);
- setlength(verzerrThreads,threads);
- for i:=0 to length(verzerrThreads)-1 do
- verzerrThreads[i]:=tVerzerrThread.create(quelle,self,round(i/length(verzerrThreads)*_xsteps),round((i+1)/length(verzerrThreads)*_xsteps-1),0,_tsiz-1,ZPs,ZGs,ZAs,Vorbearbeitung,Nachbearbeitung);
- repeat
- fertig:=true;
- for i:=0 to length(verzerrThreads)-1 do
- fertig:=fertig and verzerrThreads[i].fertig;
- if not fertig then sleep(10);
- until fertig;
- end;
- aufraeumen;
- gibAus('... fertig '+timetostr(now-Zeit),3);
- result:=true;
+var
+ ii: longint;
+begin
+ for ii:=0 to length(verzerrThreads)-1 do
+ if assigned(verzerrThreads[ii]) then
+ verzerrThreads[ii].free;
+ setlength(verzerrThreads,0);
+ if bearbeitungenLoeschen then begin
+ if assigned(Vorbearbeitung) then
+ Vorbearbeitung.freeAll;
+ if assigned(Nachbearbeitung) then
+ Nachbearbeitung.freeAll;
+ if assigned(Verzerrung) then
+ verzerrung.freeAll;
+ end;
+ setlength(ZPs,0);
+ setlength(ZGs,0);
+ setlength(ZAs,0);
+end;
+begin
+ result:=false;
+ warteaufBeendigungDesLeseThreads;
+ gibAus('Verzerrung berechnen ... ',3);
+ Zeit:=now;
+ bearbeitungenLoeschen:=true;
+ verzerrung:=tKeineTransformation.create;
+ verAnz:=0;
+ epsilon:=1e-9;
+ Genauigkeit:=gExtended;
+ Vorbearbeitung:=tKeineTransformation.create;
+ vorAnz:=0;
+ Nachbearbeitung:=tKeineTransformation.create;
+ nachAnz:=0;
+ repeat
+ if not f.metaReadln(s,true) then begin
+ gibAus('Unerwartetes Dateiende!',3);
+ aufraeumen;
+ exit;
+ end;
+ if s='Ende' then break;
+ if quelle.dichtenParameterErkannt(st,s,threads,0,_xsteps-1,0,_tsiz-1) then continue;
+ if startetMit('Threadanzahl:',s) then begin
+ threads:=strtoint(s);
+ continue;
+ end;
+ if startetMit('Epsilon:',s) then begin
+ epsilon:=exprtofloat(st,s);
+ continue;
+ end;
+ if startetMit('Abbildung:',s) then begin
+ tmp:=tKonkreteKoordinatenTransformation.create;
+ if assigned(verzerrung) then
+ tmp.fuegeVorgaengerHinzu(verzerrung);
+ verzerrung:=tmp;
+ if not (verzerrung as tKonkreteKoordinatenTransformation).initAbbildung(st,s,quelle.xscale,quelle.tscale,@exprtofloat) then begin
+ gibAus('Syntaxfehler in der Funktion '''+s+'''!',3);
+ aufraeumen;
+ exit;
+ end;
+ inc(verAnz);
+ if not st then begin
+ gibAus(verzerrung.dumpParams(verAnz),3);
+ for i:=0 to 1 do
+ for j:=0 to 1 do
+ gibAus(
+ inttostr(i*(quelle._xsteps-1))+';'+inttostr(j*(quelle._tsiz-1))+' -> '+
+ tExtPointToStr(verzerrung.transformiereKoordinaten(i*(quelle._xsteps-1),j*(quelle._tsiz-1),verAnz-1)),3);
+ end;
+ continue;
+ end;
+ if startetMit('Nachbearbeitung:',s) then begin
+ if not liesTWerteTransformationen(st,s,f,@exprtofloat,Nachbearbeitung) then begin
+ aufraeumen;
+ exit;
+ end;
+ inc(nachAnz);
+ continue;
+ end;
+ if startetMit('Vorbearbeitung:',s) then begin
+ if not liesTWerteTransformationen(st,s,f,@exprtofloat,Vorbearbeitung) then begin
+ aufraeumen;
+ exit;
+ end;
+ inc(vorAnz);
+ continue;
+ end;
+ gibAus('Verstehe Option '''+s+''' nicht bei Erstellung einer Verzerrung!',3);
+ aufraeumen;
+ exit;
+ until false;
+ Transformationen:=quelle.Transformationen;
+ Vorbearbeitung.ersetzeAnfangDurch(Transformationen);
+ Verzerrung.ersetzeAnfangDurch(Vorbearbeitung);
+ Nachbearbeitung.ersetzeAnfangDurch(verzerrung);
+ bearbeitungenLoeschen:=false;
+
+ if not st then begin
+ gibAus('... Zielausdehnung berechnen ... ',3);
+ grenzen:=(verzerrung as tKonkreteKoordinatenTransformation).zielausdehnung;
+ _xsteps:=grenzen['x','y']-grenzen['x','x']+2;
+ _tsiz:=grenzen['y','y']-grenzen['y','x']+2;
+ if (_xsteps<=1) or (_tsiz<=1) then begin
+ gibAus('Es passt kein Rechteck des Ziels vollständig in die Quelldaten!',3);
+ aufraeumen;
+ exit;
+ end;
+ eWerte.holeRam(3);
+ gibAus('Positionen und Gewichte initialisieren ...',3);
+ setlength(ZPs,quelle._xsteps*quelle._tsiz);
+ setlength(ZGs,quelle._xsteps*quelle._tsiz);
+ setlength(ZAs,_xsteps*_tsiz);
+ initVerzerrung(quelle,0,quelle._xsteps-1,0,quelle._tsiz-1,grenzen['x','x'],grenzen['y','x'],threads,true,epsilon,verzerrung,verAnz,ZPs,ZGs,ZAs,Warn);
+ gibAus('... fertig, Threads starten',3);
+ setlength(verzerrThreads,threads);
+ for i:=0 to length(verzerrThreads)-1 do
+ verzerrThreads[i]:=tVerzerrThread.create(quelle,self,round(i/length(verzerrThreads)*_xsteps),round((i+1)/length(verzerrThreads)*_xsteps-1),0,_tsiz-1,ZPs,ZGs,ZAs,Vorbearbeitung,Nachbearbeitung,vorAnz,nachAnz);
+ repeat
+ fertig:=true;
+ for i:=0 to length(verzerrThreads)-1 do
+ fertig:=fertig and verzerrThreads[i].fertig;
+ if not fertig then sleep(10);
+ until fertig;
+ end;
+ aufraeumen;
+ gibAus('... fertig '+timetostr(now-Zeit),3);
+ result:=true;
end;
function tWerte.berechneIntegral(st: boolean; var f: tMyStringlist; threads: longint; const quelle: tWerte): boolean;
-var i,tmin,tmax,xmin,xmax: longint;
- Zeit: extended;
- s: string;
- rtg: tIntegrationsRichtung;
- intThreads: array of tIntegralThread;
- fertig: boolean;
+var
+ i,tmin,tmax,xmin,xmax: longint;
+ Zeit: extended;
+ s: string;
+ rtg: tIntegrationsRichtung;
+ intThreads: array of tIntegralThread;
+ fertig: boolean;
begin
result:=false;
warteaufBeendigungDesLeseThreads;
@@ -2816,8 +2933,7 @@ begin
tmax:=min(quelle._tsiz-1,tmax);
xmin:=max(0,xmin);
xmax:=min(quelle._xsteps-1,xmax);
- Transformationen.kopiereVon(quelle.Transformationen);
- Transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
+ Transformationen:=tKoordinatenAusschnitt.create(quelle.Transformationen,xmin,xmax,tmin,tmax);
if not st then begin
_tsiz:=tmax-tmin+1;
_xsteps:=xmax-xmin+1;
@@ -2853,12 +2969,13 @@ begin
end;
function tWerte.berechneFFT(st: boolean; var f: tMyStringlist; threads: longint; Warn: tWarnstufe): boolean;
-var i: longint;
- Zeit,pvFehler: extended;
- NB: tFFTDatenordnung;
- Fenster: tFenster;
- senkrecht: boolean;
- s: string;
+var
+ i: longint;
+ Zeit,pvFehler: extended;
+ NB: tFFTDatenordnung;
+ Fenster: tFenster;
+ senkrecht: boolean;
+ s: string;
begin
result:=false;
warteaufBeendigungDesLeseThreads;
@@ -2912,7 +3029,7 @@ begin
i:=1;
while 2*i<=_tsiz do
i:=i*2;
- Transformationen.addAusschnitt(0,_xsteps-1,(_tsiz-i) div 2,((_tsiz+i) div 2) - 1);
+ Transformationen:=tKoordinatenAusschnitt.create(Transformationen,0,_xsteps-1,(_tsiz-i) div 2,((_tsiz+i) div 2) - 1);
if not st then begin
gibAus('Die Länge wird von '+inttostr(_tsiz)+' auf '+inttostr(i)+' Zeitschritte gekürzt!',3);
_tsiz:=i;
@@ -2922,13 +3039,13 @@ begin
i:=1;
while 2*i<=_xsteps do
i:=i*2;
- Transformationen.addAusschnitt((_xsteps-i) div 2,((_xsteps+i) div 2) - 1,0,_tsiz-1);
+ Transformationen:=tKoordinatenAusschnitt.create(Transformationen,(_xsteps-i) div 2,((_xsteps+i) div 2) - 1,0,_tsiz-1);
if not st then begin
gibAus('Die Länge wird von '+inttostr(_xsteps)+' auf '+inttostr(i)+' Ortsschritte gekürzt!',3);
_xsteps:=i;
end;
end;
- Transformationen.addFFT(not senkrecht,senkrecht);
+ Transformationen:=tFFTTransformation.create(Transformationen,not senkrecht,senkrecht);
if not st then begin
eWerte.holeRam(0);
gibAus('... fertig! '+timetostr(now-Zeit),3);
@@ -2937,12 +3054,13 @@ begin
end;
function tWerte.berechneFFT2d(st: boolean; var f: tMyStringlist; threads: longint; Warn: tWarnstufe): boolean;
-var i,k: longint;
- Zeit,pvFehler: extended;
- NB,preOrd: tFFTDatenordnung;
- Fensters: array[boolean] of tFenster;
- s: string;
- b,spiegeln: boolean;
+var
+ i,k: longint;
+ Zeit,pvFehler: extended;
+ NB,preOrd: tFFTDatenordnung;
+ Fensters: array[boolean] of tFenster;
+ s: string;
+ b,spiegeln: boolean;
begin
result:=false;
warteaufBeendigungDesLeseThreads;
@@ -2994,7 +3112,7 @@ begin
i:=i*2;
if _tsiz>i then begin
gibAus('Die Länge wird von '+inttostr(_tsiz)+' auf '+inttostr(i)+' Zeitschritte gekürzt!',3);
- Transformationen.addAusschnitt(0,_xsteps-1,(_tsiz-i) div 2,((_tsiz+i) div 2) - 1);
+ Transformationen:=tKoordinatenAusschnitt.create(Transformationen,0,_xsteps-1,(_tsiz-i) div 2,((_tsiz+i) div 2) - 1);
_tsiz:=i;
eWerte.holeRam(0);
end;
@@ -3003,13 +3121,13 @@ begin
i:=i*2;
if _xsteps>i then begin
gibAus('Die Breite wird von '+inttostr(_xsteps)+' auf '+inttostr(i)+' Ortsschritte gekürzt!',3);
- Transformationen.addAusschnitt((_xsteps-i) div 2,((_xsteps+i) div 2) - 1,0,_tsiz-1);
+ Transformationen:=tKoordinatenAusschnitt.create(Transformationen,(_xsteps-i) div 2,((_xsteps+i) div 2) - 1,0,_tsiz-1);
for k:=1 to _tsiz-1 do
Move(eWerte.werte[k*_xsteps],eWerte.werte[k*i],i*sizeof(extended));
_xsteps:=i;
eWerte.holeRam(0);
end;
- Transformationen.addFFT(true,true);
+ Transformationen:=tFFTTransformation.create(Transformationen,true,true);
gibAus('... fertig! '+timetostr(now-Zeit),3);
if spiegeln then begin
gibAus('Werte spiegeln ...',3);
@@ -3052,7 +3170,7 @@ var
xmin,xmax,tmin,tmax,xp,tp: longint;
breite,hoehe,lof,rof,oof,uof: longint;
Paletten: pTPalettenArray;
- Nachbearbeitungen: tTransformationenArray;
+ Nachbearbeitungen: tTransformationArray;
BilderThreads: array of TBilderthread;
fertig,Rahmen: boolean;
img: file;
@@ -3063,10 +3181,11 @@ var
quellen: tWerteArray;
procedure aufraeumen;
-var ii: longint;
+var
+ ii: longint;
begin
for ii:=0 to length(Nachbearbeitungen)-1 do
- Nachbearbeitungen[ii].free;
+ Nachbearbeitungen[ii].freeAll;
setlength(Nachbearbeitungen,0);
for ii:=0 to length(BilderThreads)-1 do
if assigned(BilderThreads[ii]) then
@@ -3082,32 +3201,31 @@ begin
end;
begin
- result:=false;
- warteaufBeendigungDesLeseThreads;
- Zeit:=now;
- if not st then
- gibAus('erzeuge lineares Bild aus '+bezeichner+' ...',3);
- datei:='';
- xzoom:=1;
- yzoom:=1;
- xmin:=0;
- xmax:=_xsteps-1;
- tmin:=0;
- tmax:=_tsiz-1;
- schriftgroesze:=24;
- setlength(quellen,1);
- quellen[0]:=self;
- setlength(Nachbearbeitungen,1);
- Nachbearbeitungen[0]:=tTransformationen.create;
- setlength(Paletten,1);
- findePalette(Paletten[0],'Graustufen');
- setlength(Achsen,0);
- setlength(verwKonturen,0);
- setlength(beschriftungen,0);
- setlength(BilderThreads,0);
- Rahmen:=false;
- fontRenderer:=nil;
- repeat
+ result:=false;
+ warteaufBeendigungDesLeseThreads;
+ Zeit:=now;
+ if not st then gibAus('erzeuge lineares Bild aus '+bezeichner+' ...',3);
+ datei:='';
+ xzoom:=1;
+ yzoom:=1;
+ xmin:=0;
+ xmax:=_xsteps-1;
+ tmin:=0;
+ tmax:=_tsiz-1;
+ schriftgroesze:=24;
+ setlength(quellen,1);
+ quellen[0]:=self;
+ setlength(Nachbearbeitungen,1);
+ Nachbearbeitungen[0]:=nil;
+ setlength(Paletten,1);
+ findePalette(Paletten[0],'Graustufen');
+ setlength(Achsen,0);
+ setlength(verwKonturen,0);
+ setlength(beschriftungen,0);
+ setlength(BilderThreads,0);
+ Rahmen:=false;
+ fontRenderer:=nil;
+ repeat
if not f.metaReadln(s,true) then begin
gibAus('Unerwartetes Dateiende in '''+paramstr(1)+'''!',3);
aufraeumen;
@@ -3178,11 +3296,11 @@ begin
j:=length(nachbearbeitungen);
setlength(nachbearbeitungen,i+1);
while j<length(nachbearbeitungen) do begin
- nachbearbeitungen[j]:=tTransformationen.create;
+ nachbearbeitungen[j]:=nil;
inc(j);
end;
end;
- if not Nachbearbeitungen[i].add(st,s,f,@exprtofloat) then begin
+ if not liesTWerteTransformationen(st,s,f,@exprtofloat,Nachbearbeitungen[i]) then begin
aufraeumen;
exit;
end;
@@ -3261,445 +3379,448 @@ begin
gibAus('Verstehe Option '''+s+''' nicht bei Erzeugung eines linearen Bildes!',3);
aufraeumen;
exit;
- until false;
+ until false;
- if (length(Paletten)<>length(Quellen)) or
+ if (length(Paletten)<>length(Quellen)) or
(length(Nachbearbeitungen)<>length(Quellen)) then begin
- gibAus(
- 'Die Anzahl der Paletten ('+inttostr(length(Paletten))+'), '+
- 'der Daten ('+inttostr(length(Quellen))+') und '+
- 'der Nachbearbeitungen ('+inttostr(length(nachbearbeitungen))+') stimmen nicht überein!',3);
- aufraeumen;
- exit;
- end;
-
- if st then begin
- result:=true;
- aufraeumen;
- exit;
- end;
-
- if _maxW=_minW then begin
- gibAus('Zu geringe Dynamik um Dichten auflösen zu können!',3);
- aufraeumen;
- exit;
- end;
- xmin:=max(xmin,0);
- xmax:=min(xmax,_xsteps-1);
- tmin:=max(tmin,0);
- tmax:=min(tmax,_tsiz-1);
- gibAus('('+inttostr(xmin)+'-'+inttostr(xmax)+'x'+inttostr(tmin)+'-'+inttostr(tmax)+')',3);
- gibAus(' ('+floattostr(Transformationen.xstart)+'-'+floattostr(Transformationen.xstop)+' x '+floattostr(Transformationen.tstart)+'-'+floattostr(Transformationen.tstop)+')',3);
- breite:=round((xmax-xmin)*xzoom)+1;
- hoehe:=round((tmax-tmin)*yzoom)+1;
-
- if (breite=1) or (hoehe=1) then begin
- gibAus('Keine/kaum Bildpunkte innerhalb der festgelegten Grenzen!',3);
- aufraeumen;
- exit;
- end;
- gibAus(inttostr(breite)+' x '+inttostr(hoehe)+' Pixel',3);
-
- fontRenderer:=tFontRenderer.create(schriftgroesze);
-
- setlength(Beschriftungen,0);
- for i:=0 to length(Achsen)-1 do begin
+ gibAus(
+ 'Die Anzahl der Paletten ('+inttostr(length(Paletten))+'), '+
+ 'der Daten ('+inttostr(length(Quellen))+') und '+
+ 'der Nachbearbeitungen ('+inttostr(length(nachbearbeitungen))+') stimmen nicht überein!',3);
+ aufraeumen;
+ exit;
+ end;
+
+ if st then begin
+ result:=true;
+ aufraeumen;
+ exit;
+ end;
+
+ if _maxW=_minW then begin
+ gibAus('Zu geringe Dynamik um Dichten auflösen zu können!',3);
+ aufraeumen;
+ exit;
+ end;
+ xmin:=max(xmin,0);
+ xmax:=min(xmax,_xsteps-1);
+ tmin:=max(tmin,0);
+ tmax:=min(tmax,_tsiz-1);
+ gibAus('('+inttostr(xmin)+'-'+inttostr(xmax)+'x'+inttostr(tmin)+'-'+inttostr(tmax)+')',3);
+ gibAus(' ('+floattostr(Transformationen.xstart)+'-'+floattostr(Transformationen.xstop)+' x '+floattostr(Transformationen.tstart)+'-'+floattostr(Transformationen.tstop)+')',3);
+ breite:=round((xmax-xmin)*xzoom)+1;
+ hoehe:=round((tmax-tmin)*yzoom)+1;
+
+ if (breite=1) or (hoehe=1) then begin
+ gibAus('Keine/kaum Bildpunkte innerhalb der festgelegten Grenzen!',3);
+ aufraeumen;
+ exit;
+ end;
+ gibAus(inttostr(breite)+' x '+inttostr(hoehe)+' Pixel',3);
+
+ fontRenderer:=tFontRenderer.create(schriftgroesze);
+
+ setlength(Beschriftungen,0);
+ for i:=0 to length(Achsen)-1 do begin
(* if Achsen[i].Lage in [lOben,lUnten] then
begin
- maw:=xMax/(_xsteps-1)*(_xstop-_xstart)+_xstart;
- miw:=xMin/(_xsteps-1)*(_xstop-_xstart)+_xstart;
+ maw:=xMax/(_xsteps-1)*(_xstop-_xstart)+_xstart;
+ miw:=xMin/(_xsteps-1)*(_xstop-_xstart)+_xstart;
end
- else
+ else
begin
- maw:=tMax/(_tsiz-1)*(_tstop-_tstart)+_tstart;
- miw:=tMin/(_tsiz-1)*(_tstop-_tstart)+_tstart;
- end;
- schritt:=(maw-miw)/Achsen[i].Striche;
- j:=round(ln(schritt)/ln(10));
- schritt:=Achsen[i].faktor*power(10,j);
- wert:=ceil(miw/schritt)*schritt;
- while wert<=maw do *)
- if Achsen[i].Lage in [lOben,lUnten] then begin
- maw:=disk2kont('x',xMax);
- miw:=disk2Kont('x',xMin);
- end
- else begin
- maw:=disk2kont('t',tMax);
- miw:=disk2kont('t',tMin);
- end;
- schritt:=(maw-miw)/Achsen[i].Striche;
- j:=round(ln(schritt)/ln(10));
- schritt:=Achsen[i].faktor*power(10,j);
- wert:=ceil(miw/schritt)*schritt;
- while wert<=maw do begin
- setlength(beschriftungen,length(beschriftungen)+1);
- beschriftungen[length(beschriftungen)-1]:=tBeschriftung.create;
- beschriftungen[length(beschriftungen)-1].bBreite:=Breite;
- beschriftungen[length(beschriftungen)-1].bHoehe:=Hoehe;
- beschriftungen[length(beschriftungen)-1].Rahmen:=Rahmen;
- with beschriftungen[length(beschriftungen)-1] do begin
- fontRend:=fontRenderer;
- lage:=Achsen[i].lage;
+ maw:=tMax/(_tsiz-1)*(_tstop-_tstart)+_tstart;
+ miw:=tMin/(_tsiz-1)*(_tstop-_tstart)+_tstart;
+ end;
+ schritt:=(maw-miw)/Achsen[i].Striche;
+ j:=round(ln(schritt)/ln(10));
+ schritt:=Achsen[i].faktor*power(10,j);
+ wert:=ceil(miw/schritt)*schritt;
+ while wert<=maw do *)
+ if Achsen[i].Lage in [lOben,lUnten] then begin
+ maw:=disk2kont('x',xMax);
+ miw:=disk2Kont('x',xMin);
+ end
+ else begin
+ maw:=disk2kont('t',tMax);
+ miw:=disk2kont('t',tMin);
+ end;
+ schritt:=(maw-miw)/Achsen[i].Striche;
+ j:=round(ln(schritt)/ln(10));
+ schritt:=Achsen[i].faktor*power(10,j);
+ wert:=ceil(miw/schritt)*schritt;
+ while wert<=maw do begin
+ setlength(beschriftungen,length(beschriftungen)+1);
+ beschriftungen[length(beschriftungen)-1]:=tBeschriftung.create;
+ beschriftungen[length(beschriftungen)-1].bBreite:=Breite;
+ beschriftungen[length(beschriftungen)-1].bHoehe:=Hoehe;
+ beschriftungen[length(beschriftungen)-1].Rahmen:=Rahmen;
+ with beschriftungen[length(beschriftungen)-1] do begin
+ fontRend:=fontRenderer;
+ lage:=Achsen[i].lage;
// position:=(wert-miw)/(maw-miw);
- position:=Transformationen.transformiereKoordinaten(Achsen[i].Lage,wert);
- if (position<0) or (position>1) then begin
- gibAus('Der Wert '+floattostr(wert)+' liegt außerhalb des Bildes ('+floattostr(position)+') - das sollte eigentlich nicht passieren!',3);
- beschriftungen[length(beschriftungen)-1].free;
- setlength(beschriftungen,length(beschriftungen)-1);
- end
- else begin
- if lage in [lOben,lUnten] then position:=position*bBreite
- else position:=position*bHoehe;
- inhalt:=floattostr(wert);
- end;
- end;
- wert:=wert+schritt;
- end;
- end;
- gibAus(inttostr(length(Beschriftungen))+' Zahlen an den Achsen',3);
- lof:=Byte(Rahmen);
- rof:=Byte(Rahmen);
- oof:=Byte(Rahmen);
- uof:=Byte(Rahmen);
- for i:=0 to length(beschriftungen)-1 do
+ position:=Transformationen.wertZuPositionAufAchse(Achsen[i].Lage,wert);
+ if (position<0) or (position>1) then begin
+ gibAus('Der Wert '+floattostr(wert)+' liegt außerhalb des Bildes ('+floattostr(position)+') - das sollte eigentlich nicht passieren!',3);
+ beschriftungen[length(beschriftungen)-1].free;
+ setlength(beschriftungen,length(beschriftungen)-1);
+ end
+ else begin
+ if lage in [lOben,lUnten] then position:=position*bBreite
+ else position:=position*bHoehe;
+ inhalt:=floattostr(wert);
+ end;
+ end;
+ wert:=wert+schritt;
+ end;
+ end;
+ gibAus(inttostr(length(Beschriftungen))+' Zahlen an den Achsen',3);
+ lof:=Byte(Rahmen);
+ rof:=Byte(Rahmen);
+ oof:=Byte(Rahmen);
+ uof:=Byte(Rahmen);
+ for i:=0 to length(beschriftungen)-1 do
with Beschriftungen[i] do
- begin
+ begin
lof:=max(lof,-links);
rof:=max(rof,1+rechts-bBreite);
oof:=max(oof,-oben);
uof:=max(uof,1+unten-bHoehe);
- end;
- if lof+oof+rof+uof>0 then
+ end;
+ if lof+oof+rof+uof>0 then
gibAus('Extra-Ränder: '+inttostr(lof)+' Pixel links, '+inttostr(oof)+' Pixel oben, '+inttostr(rof)+' Pixel rechts und '+inttostr(uof)+' Pixel unten.',3);
- setlength(Bilderthreads,maxThreads);
- for i:=0 to length(Bilderthreads)-1 do
- Bilderthreads[i]:=tBilderthread.create(i,length(Bilderthreads),breite,hoehe,lof,oof,rof,uof,quellen,xmin,xmax,tmin,tmax,xzoom,yzoom,Nachbearbeitungen,paletten,@Beschriftungen,rahmen);
- for i:=0 to length(Bilderthreads)-1 do begin
- gibAus('starte Thread '+inttostr(i)+' ...',1);
- Bilderthreads[i].suspended:=false;
- gibAus('... ok!',1);
- end;
- repeat
- sleep(10);
- fertig:=true;
- for i:=0 to length(Bilderthreads)-1 do
- fertig:=fertig and Bilderthreads[i].fertig;
- until fertig;
- gibAus('Alle Threads beendet, Konturen einfügen ...',1);
- for i:=0 to length(verwKonturen)-1 do
- for j:=0 to length(konturen^[verwKonturen[i]].orte)-1 do begin
- xp:=kont2disk('x',konturen^[verwKonturen[i]].orte[j]['x']);
- tp:=kont2disk('t',konturen^[verwKonturen[i]].orte[j]['y']);
-
- if (xmin<=xp) and (xp<=xmax) and (tmin<=tp) and (tp<=tmax) then begin
- k:=0;
- xp:=xp-xmin;
- tp:=tp-tmin;
- while (k<length(Bilderthreads)-1) and (xp>=Bilderthreads[k+1].xpmi) do
- inc(k);
- Bilderthreads[k].farben[(tp+oof)*Bilderthreads[k].Breite + xp - Bilderthreads[k].xpmi]:=
- konturen^[verwKonturen[i]].farbe;
- end;
- end;
- gibAus('fertig, speichere Bild ...',1);
- assign(img,datei);
- rewrite(img,1);
- schreibeBmpHeader(img,breite+lof+rof,hoehe+oof+uof);
- for j:=-oof to uof+hoehe-1 do begin
- for i:=0 to length(Bilderthreads)-1 do
- blockwrite(img,Bilderthreads[i].farben[(j+oof)*Bilderthreads[i].Breite],3*Bilderthreads[i].Breite);
- i:=0;
- blockwrite(img,i,(4-(((lof+breite+rof)*3) mod 4)) mod 4);
- end;
- close(img);
- gibAus('... Threads freigeben ...',1);
- aufraeumen;
-
- result:=true;
- gibAus('... fertig '+timetostr(now-Zeit),3);
+ setlength(Bilderthreads,maxThreads);
+ for i:=0 to length(Bilderthreads)-1 do
+ Bilderthreads[i]:=tBilderthread.create(i,length(Bilderthreads),breite,hoehe,lof,oof,rof,uof,quellen,xmin,xmax,tmin,tmax,xzoom,yzoom,Nachbearbeitungen,paletten,@Beschriftungen,rahmen);
+ for i:=0 to length(Bilderthreads)-1 do begin
+ gibAus('starte Thread '+inttostr(i)+' ...',1);
+ Bilderthreads[i].suspended:=false;
+ gibAus('... ok!',1);
+ end;
+ repeat
+ sleep(10);
+ fertig:=true;
+ for i:=0 to length(Bilderthreads)-1 do
+ fertig:=fertig and Bilderthreads[i].fertig;
+ until fertig;
+ gibAus('Alle Threads beendet, Konturen einfügen ...',1);
+ for i:=0 to length(verwKonturen)-1 do
+ for j:=0 to length(konturen^[verwKonturen[i]].orte)-1 do begin
+ xp:=kont2disk('x',konturen^[verwKonturen[i]].orte[j]['x']);
+ tp:=kont2disk('t',konturen^[verwKonturen[i]].orte[j]['y']);
+
+ if (xmin<=xp) and (xp<=xmax) and (tmin<=tp) and (tp<=tmax) then begin
+ k:=0;
+ xp:=xp-xmin;
+ tp:=tp-tmin;
+ while (k<length(Bilderthreads)-1) and (xp>=Bilderthreads[k+1].xpmi) do
+ inc(k);
+ Bilderthreads[k].farben[(tp+oof)*Bilderthreads[k].Breite + xp - Bilderthreads[k].xpmi]:=
+ konturen^[verwKonturen[i]].farbe;
+ end;
+ end;
+ gibAus('fertig, speichere Bild ...',1);
+ assign(img,datei);
+ rewrite(img,1);
+ schreibeBmpHeader(img,breite+lof+rof,hoehe+oof+uof);
+ for j:=-oof to uof+hoehe-1 do begin
+ for i:=0 to length(Bilderthreads)-1 do
+ blockwrite(img,Bilderthreads[i].farben[(j+oof)*Bilderthreads[i].Breite],3*Bilderthreads[i].Breite);
+ i:=0;
+ blockwrite(img,i,(4-(((lof+breite+rof)*3) mod 4)) mod 4);
+ end;
+ close(img);
+ gibAus('... Threads freigeben ...',1);
+ aufraeumen;
+
+ result:=true;
+ gibAus('... fertig '+timetostr(now-Zeit),3);
end;
function tWerte.erzeugeAscii(st: boolean; var f: tMyStringlist): boolean;
-var datei,s,separator: string;
- outf: textfile;
- i,j: longint;
- xmin,xmax,tmin,tmax: longint;
- Zeit: extended;
- mitKoordinaten: byte;
-begin
- result:=false;
- warteaufBeendigungDesLeseThreads;
- Zeit:=now;
- gibAus('erzeuge Ascii-Datei ...',3);
- datei:='';
- xmin:=0;
- xmax:=_xsteps-1;
- tmin:=0;
- tmax:=_tsiz-1;
- mitKoordinaten:=0;
- separator:=',';
- repeat
- if not f.metaReadln(s,true) then begin
- gibAus('Unerwartetes Dateiende in '''+paramstr(1)+'''!',3);
- exit;
- end;
- if startetMit('Datei:',s) then begin
- datei:=s;
- continue;
- end;
- if startetMit('xmin:',s) then begin
- xmin:=kont2disk('x',exprtofloat(st,s));
- continue;
- end;
- if startetMit('xmax:',s) then begin
- xmax:=kont2disk('x',exprtofloat(st,s));
- continue;
- end;
- if startetMit('tmin:',s) then begin
- tmin:=kont2disk('t',exprtofloat(st,s));
- continue;
- end;
- if startetMit('tmax:',s) then begin
- tmax:=kont2disk('t',exprtofloat(st,s));
- continue;
- end;
- if (s='Koordinaten einfügen') and ((_xsteps=1) or (_tsiz=1)) then begin
- mitKoordinaten:=byte(_xsteps=1)*2 + byte(_tsiz=1);
- continue;
- end;
- if startetMit('Separator:',s) then begin
- if s='Leerzeichen' then begin
- Separator:=' ';
- continue;
- end;
- if s='Tab' then begin
- Separator:=#9;
- continue;
- end;
- Separator:=s;
- continue;
- end;
- if s='Ende' then break;
- gibAus('Verstehe Option '''+s+''' nicht bei Erzeugung einer Ascii-Datei!',3);
- exit;
- until false;
-
- if st then begin
- result:=true;
- exit;
- end;
-
- assign(outf,datei);
- rewrite(outf);
- case mitKoordinaten of
- 0:
- case Genauigkeit of
- gSingle:
- for i:=max(0,tmin) to min(_tsiz-1,tmax) do begin
- s:='';
- for j:=max(0,xmin) to min(_xsteps-1,xmax) do
- s:=s+floattostr(sWerte.werte[i*_xsteps+j])+separator;
- delete(s,length(s),1);
- writeln(outf,s);
- end;
- gDouble:
- for i:=max(0,tmin) to min(_tsiz-1,tmax) do begin
- s:='';
- for j:=max(0,xmin) to min(_xsteps-1,xmax) do
- s:=s+floattostr(dWerte.werte[i*_xsteps+j])+separator;
- delete(s,length(s),1);
- writeln(outf,s);
- end;
- gExtended:
- for i:=max(0,tmin) to min(_tsiz-1,tmax) do begin
- s:='';
- for j:=max(0,xmin) to min(_xsteps-1,xmax) do
- s:=s+floattostr(eWerte.werte[i*_xsteps+j])+separator;
- delete(s,length(s),1);
- writeln(outf,s);
- end;
- end{of Case};
- 1:
- case Genauigkeit of
- gSingle:
- for i:=max(0,xmin) to min(_xsteps-1,xmax) do
- writeln(outf,floattostr(disk2kont('x',i))+separator+floattostr(sWerte.werte[i]));
- gDouble:
- for i:=max(0,xmin) to min(_xsteps-1,xmax) do
- writeln(outf,floattostr(disk2kont('x',i))+separator+floattostr(dWerte.werte[i]));
- gExtended:
- for i:=max(0,xmin) to min(_xsteps-1,xmax) do
- writeln(outf,floattostr(disk2kont('x',i))+separator+floattostr(eWerte.werte[i]));
- end{of Case};
- 2:
- case Genauigkeit of
- gSingle:
- for i:=max(0,tmin) to min(_tsiz-1,tmax) do
- writeln(outf,floattostr(disk2kont('t',i))+separator+floattostr(sWerte.werte[i]));
- gDouble:
- for i:=max(0,tmin) to min(_tsiz-1,tmax) do
- writeln(outf,floattostr(disk2kont('t',i))+separator+floattostr(dWerte.werte[i]));
- gExtended:
- for i:=max(0,tmin) to min(_tsiz-1,tmax) do
- writeln(outf,floattostr(disk2kont('t',i))+separator+floattostr(eWerte.werte[i]));
- end{of Case};
- 3:
- case Genauigkeit of
- gSingle:
- writeln(outf,floattostr(disk2kont('x',0))+separator+floattostr(disk2kont('t',0))+separator+floattostr(sWerte.werte[0]));
- gDouble:
- writeln(outf,floattostr(disk2kont('x',0))+separator+floattostr(disk2kont('t',0))+separator+floattostr(dWerte.werte[0]));
- gExtended:
- writeln(outf,floattostr(disk2kont('x',0))+separator+floattostr(disk2kont('t',0))+separator+floattostr(eWerte.werte[0]));
- end{of Case};
- end{of Case};
- close(outf);
- gibAus('... fertig '+timetostr(now-Zeit),3);
- result:=true;
+var
+ datei,s,separator: string;
+ outf: textfile;
+ i,j: longint;
+ xmin,xmax,tmin,tmax: longint;
+ Zeit: extended;
+ mitKoordinaten: byte;
+begin
+ result:=false;
+ warteaufBeendigungDesLeseThreads;
+ Zeit:=now;
+ gibAus('erzeuge Ascii-Datei ...',3);
+ datei:='';
+ xmin:=0;
+ xmax:=_xsteps-1;
+ tmin:=0;
+ tmax:=_tsiz-1;
+ mitKoordinaten:=0;
+ separator:=',';
+ repeat
+ if not f.metaReadln(s,true) then begin
+ gibAus('Unerwartetes Dateiende in '''+paramstr(1)+'''!',3);
+ exit;
+ end;
+ if startetMit('Datei:',s) then begin
+ datei:=s;
+ continue;
+ end;
+ if startetMit('xmin:',s) then begin
+ xmin:=kont2disk('x',exprtofloat(st,s));
+ continue;
+ end;
+ if startetMit('xmax:',s) then begin
+ xmax:=kont2disk('x',exprtofloat(st,s));
+ continue;
+ end;
+ if startetMit('tmin:',s) then begin
+ tmin:=kont2disk('t',exprtofloat(st,s));
+ continue;
+ end;
+ if startetMit('tmax:',s) then begin
+ tmax:=kont2disk('t',exprtofloat(st,s));
+ continue;
+ end;
+ if (s='Koordinaten einfügen') and ((_xsteps=1) or (_tsiz=1)) then begin
+ mitKoordinaten:=byte(_xsteps=1)*2 + byte(_tsiz=1);
+ continue;
+ end;
+ if startetMit('Separator:',s) then begin
+ if s='Leerzeichen' then begin
+ Separator:=' ';
+ continue;
+ end;
+ if s='Tab' then begin
+ Separator:=#9;
+ continue;
+ end;
+ Separator:=s;
+ continue;
+ end;
+ if s='Ende' then break;
+ gibAus('Verstehe Option '''+s+''' nicht bei Erzeugung einer Ascii-Datei!',3);
+ exit;
+ until false;
+
+ if st then begin
+ result:=true;
+ exit;
+ end;
+
+ assign(outf,datei);
+ rewrite(outf);
+ case mitKoordinaten of
+ 0:
+ case Genauigkeit of
+ gSingle:
+ for i:=max(0,tmin) to min(_tsiz-1,tmax) do begin
+ s:='';
+ for j:=max(0,xmin) to min(_xsteps-1,xmax) do
+ s:=s+floattostr(sWerte.werte[i*_xsteps+j])+separator;
+ delete(s,length(s),1);
+ writeln(outf,s);
+ end;
+ gDouble:
+ for i:=max(0,tmin) to min(_tsiz-1,tmax) do begin
+ s:='';
+ for j:=max(0,xmin) to min(_xsteps-1,xmax) do
+ s:=s+floattostr(dWerte.werte[i*_xsteps+j])+separator;
+ delete(s,length(s),1);
+ writeln(outf,s);
+ end;
+ gExtended:
+ for i:=max(0,tmin) to min(_tsiz-1,tmax) do begin
+ s:='';
+ for j:=max(0,xmin) to min(_xsteps-1,xmax) do
+ s:=s+floattostr(eWerte.werte[i*_xsteps+j])+separator;
+ delete(s,length(s),1);
+ writeln(outf,s);
+ end;
+ end{of Case};
+ 1:
+ case Genauigkeit of
+ gSingle:
+ for i:=max(0,xmin) to min(_xsteps-1,xmax) do
+ writeln(outf,floattostr(disk2kont('x',i))+separator+floattostr(sWerte.werte[i]));
+ gDouble:
+ for i:=max(0,xmin) to min(_xsteps-1,xmax) do
+ writeln(outf,floattostr(disk2kont('x',i))+separator+floattostr(dWerte.werte[i]));
+ gExtended:
+ for i:=max(0,xmin) to min(_xsteps-1,xmax) do
+ writeln(outf,floattostr(disk2kont('x',i))+separator+floattostr(eWerte.werte[i]));
+ end{of Case};
+ 2:
+ case Genauigkeit of
+ gSingle:
+ for i:=max(0,tmin) to min(_tsiz-1,tmax) do
+ writeln(outf,floattostr(disk2kont('t',i))+separator+floattostr(sWerte.werte[i]));
+ gDouble:
+ for i:=max(0,tmin) to min(_tsiz-1,tmax) do
+ writeln(outf,floattostr(disk2kont('t',i))+separator+floattostr(dWerte.werte[i]));
+ gExtended:
+ for i:=max(0,tmin) to min(_tsiz-1,tmax) do
+ writeln(outf,floattostr(disk2kont('t',i))+separator+floattostr(eWerte.werte[i]));
+ end{of Case};
+ 3:
+ case Genauigkeit of
+ gSingle:
+ writeln(outf,floattostr(disk2kont('x',0))+separator+floattostr(disk2kont('t',0))+separator+floattostr(sWerte.werte[0]));
+ gDouble:
+ writeln(outf,floattostr(disk2kont('x',0))+separator+floattostr(disk2kont('t',0))+separator+floattostr(dWerte.werte[0]));
+ gExtended:
+ writeln(outf,floattostr(disk2kont('x',0))+separator+floattostr(disk2kont('t',0))+separator+floattostr(eWerte.werte[0]));
+ end{of Case};
+ end{of Case};
+ close(outf);
+ gibAus('... fertig '+timetostr(now-Zeit),3);
+ result:=true;
end;
function tWerte.erzeugeLineout(st: boolean; params: string): boolean;
-var ab: array[boolean,boolean] of longint;
- s: string;
- f: textfile;
- Zeit: extended;
- i: longint;
- b1,b2: boolean;
-begin
- result:=false;
- warteaufBeendigungDesLeseThreads;
- Zeit:=now;
- if not st then begin
- gibAus('erzeuge Lineout ...',3);
- gibAus('insgesamt: '+floattostr(Transformationen.xstart)+'..'+floattostr(Transformationen.xstop)+' x '+floattostr(Transformationen.tstart)+'..'+floattostr(Transformationen.tstop),3);
- end;
-
- for b1:=false to true do
- for b2:=false to true do
- ab[b1,b2]:=0;
-
- params:=trim(params);
- if startetMit('integriere ',params) then begin
- if startetMit('horizontal',params) then b1:=true
- else if startetMit('vertikal',params) then b1:=false
- else exit;
- if st then begin
- result:=true;
- exit;
- end;
- if b1 then s:='horizontal'
- else s:='vertikal';
- gibAus('... schreibe in '''+params+''', integriere '+s,3);
-
- if pos(' ',params)>0 then begin
- gibAus('Leerzeichen im Dateinamen sind nicht erlaubt!',3);
- exit;
- end;
-
- assignFile(f,params);
- rewrite(f);
- for i:=0 to _xsteps*byte(not b1)+_tsiz*byte(b1)-1 do
- schreibeWertIntegriert(f,i,b1);
- closefile(f);
- end
- else begin
- for b1:=false to true do
- if startetMit('(',params) then begin
- s:=erstesArgument(params,',');
- ab[b1,false]:=kont2disk('x',exprtofloat(st,s));
- s:=erstesArgument(params,')');
- ab[b1,true]:=kont2disk('t',exprtofloat(st,s));
- end
- else begin
- ab[true,false]:=ab[false,false];
- ab[true,true]:=ab[false,true];
- ab[false,false]:=(_xsteps-1)*byte(not b1);
- ab[false,true]:=(_tsiz-1)*byte(not b1);
- end;
-
- if st then begin
- result:=true;
- exit;
- end;
-
- if pos(' ',params)>0 then begin
- gibAus('Leerzeichen im Dateinamen sind nicht erlaubt!',3);
- exit;
- end;
-
- s:='... schreibe in '''+params+''' (';
- for i:=0 to 3 do begin
- s:=s+inttostr(ab[odd(i div 2),odd(i)]);
- if not odd(i) then s:=s+','
- else if i=1 then s:=s+')--(';
- end;
- gibAus(s+') ...',3);
-
- assignFile(f,params);
- rewrite(f);
- if abs(ab[true,true]-ab[false,true])>abs(ab[true,false]-ab[false,false]) then begin
- if ab[true,true]>ab[false,true] then begin
- for i:=ab[false,true] to ab[true,true] do
- schreibeWert(f,round(ab[false,false]+i/(ab[true,true]-ab[false,true])*(ab[true,false]-ab[false,false])),i);
- end
- else
- for i:=ab[false,true] downto ab[true,true] do
- schreibeWert(f,round(ab[false,false]+i/(ab[true,true]-ab[false,true])*(ab[true,false]-ab[false,false])),i);
- end
- else begin
- if ab[true,false]>ab[false,false] then begin
- for i:=ab[false,false] to ab[true,false] do
- schreibeWert(f,i,round(ab[false,true]+i/(ab[true,false]-ab[false,false])*(ab[true,true]-ab[false,true])));
- end
- else
- for i:=ab[false,false] downto ab[true,false] do
- schreibeWert(f,i,round(ab[false,true]+i/(ab[true,false]-ab[false,false])*(ab[true,true]-ab[false,true])));
- end;
- closefile(f);
- end;
- gibAus('... fertig '+timetostr(now-Zeit),3);
- result:=true;
+var
+ ab: array[boolean,boolean] of longint;
+ s: string;
+ f: textfile;
+ Zeit: extended;
+ i: longint;
+ b1,b2: boolean;
+begin
+ result:=false;
+ warteaufBeendigungDesLeseThreads;
+ Zeit:=now;
+ if not st then begin
+ gibAus('erzeuge Lineout ...',3);
+ gibAus('insgesamt: '+floattostr(Transformationen.xstart)+'..'+floattostr(Transformationen.xstop)+' x '+floattostr(Transformationen.tstart)+'..'+floattostr(Transformationen.tstop),3);
+ end;
+
+ for b1:=false to true do
+ for b2:=false to true do
+ ab[b1,b2]:=0;
+
+ params:=trim(params);
+ if startetMit('integriere ',params) then begin
+ if startetMit('horizontal',params) then b1:=true
+ else if startetMit('vertikal',params) then b1:=false
+ else exit;
+ if st then begin
+ result:=true;
+ exit;
+ end;
+ if b1 then s:='horizontal'
+ else s:='vertikal';
+ gibAus('... schreibe in '''+params+''', integriere '+s,3);
+
+ if pos(' ',params)>0 then begin
+ gibAus('Leerzeichen im Dateinamen sind nicht erlaubt!',3);
+ exit;
+ end;
+
+ assignFile(f,params);
+ rewrite(f);
+ for i:=0 to _xsteps*byte(not b1)+_tsiz*byte(b1)-1 do
+ schreibeWertIntegriert(f,i,b1);
+ closefile(f);
+ end
+ else begin
+ for b1:=false to true do
+ if startetMit('(',params) then begin
+ s:=erstesArgument(params,',');
+ ab[b1,false]:=kont2disk('x',exprtofloat(st,s));
+ s:=erstesArgument(params,')');
+ ab[b1,true]:=kont2disk('t',exprtofloat(st,s));
+ end
+ else begin
+ ab[true,false]:=ab[false,false];
+ ab[true,true]:=ab[false,true];
+ ab[false,false]:=(_xsteps-1)*byte(not b1);
+ ab[false,true]:=(_tsiz-1)*byte(not b1);
+ end;
+
+ if st then begin
+ result:=true;
+ exit;
+ end;
+
+ if pos(' ',params)>0 then begin
+ gibAus('Leerzeichen im Dateinamen sind nicht erlaubt!',3);
+ exit;
+ end;
+
+ s:='... schreibe in '''+params+''' (';
+ for i:=0 to 3 do begin
+ s:=s+inttostr(ab[odd(i div 2),odd(i)]);
+ if not odd(i) then s:=s+','
+ else if i=1 then s:=s+')--(';
+ end;
+ gibAus(s+') ...',3);
+
+ assignFile(f,params);
+ rewrite(f);
+ if abs(ab[true,true]-ab[false,true])>abs(ab[true,false]-ab[false,false]) then begin
+ if ab[true,true]>ab[false,true] then begin
+ for i:=ab[false,true] to ab[true,true] do
+ schreibeWert(f,round(ab[false,false]+i/(ab[true,true]-ab[false,true])*(ab[true,false]-ab[false,false])),i);
+ end
+ else
+ for i:=ab[false,true] downto ab[true,true] do
+ schreibeWert(f,round(ab[false,false]+i/(ab[true,true]-ab[false,true])*(ab[true,false]-ab[false,false])),i);
+ end
+ else begin
+ if ab[true,false]>ab[false,false] then begin
+ for i:=ab[false,false] to ab[true,false] do
+ schreibeWert(f,i,round(ab[false,true]+i/(ab[true,false]-ab[false,false])*(ab[true,true]-ab[false,true])));
+ end
+ else
+ for i:=ab[false,false] downto ab[true,false] do
+ schreibeWert(f,i,round(ab[false,true]+i/(ab[true,false]-ab[false,false])*(ab[true,true]-ab[false,true])));
+ end;
+ closefile(f);
+ end;
+ gibAus('... fertig '+timetostr(now-Zeit),3);
+ result:=true;
end;
function tWerte.erzeugeBinning(st: boolean; params: string): boolean;
-var senkrecht,linien: boolean;
- Zeit,x0,dx: extended;
-begin
- result:=false;
- warteaufBeendigungDesLeseThreads;
- Zeit:=now;
- if not st then begin
- gibAus('erzeuge Binning ...',3);
- gibAus('insgesamt: '+floattostr(Transformationen.xstart)+'..'+floattostr(Transformationen.xstop)+' x '+floattostr(Transformationen.tstart)+'..'+floattostr(Transformationen.tstop),3);
- end;
- senkrecht:=Transformationen.xstart=Transformationen.xstop;
- if (not senkrecht) and (Transformationen.tstart<>Transformationen.tstop) then begin
- gibAus('Binning geht nur auf eindimensionalen Daten!',3);
- exit;
- end;
-
- params:=trim(params);
- linien:=startetMit('(Gnuplotlinien)',params);
- x0:=kont2disk(char(ord('x')+byte(senkrecht)),exprtofloat(st,erstesArgument(params)));
- dx:=kont2diskFak(char(ord('x')+byte(senkrecht)),exprtofloat(st,erstesArgument(params)));
-
- if pos(' ',params)>0 then begin
- gibAus('Leerzeichen im Dateinamen sind nicht erlaubt!',3);
- exit;
- end;
-
- if not st then
- case Genauigkeit of
- gSingle:
- sWerte.erzeugeBinning(senkrecht,linien,x0,dx,params);
- gDouble:
- dWerte.erzeugeBinning(senkrecht,linien,x0,dx,params);
- gExtended:
- eWerte.erzeugeBinning(senkrecht,linien,x0,dx,params);
- end{of case};
- gibAus('... fertig '+timetostr(now-Zeit),3);
- result:=true;
+var
+ senkrecht,linien: boolean;
+ Zeit,x0,dx: extended;
+begin
+ result:=false;
+ warteaufBeendigungDesLeseThreads;
+ Zeit:=now;
+ if not st then begin
+ gibAus('erzeuge Binning ...',3);
+ gibAus('insgesamt: '+floattostr(Transformationen.xstart)+'..'+floattostr(Transformationen.xstop)+' x '+floattostr(Transformationen.tstart)+'..'+floattostr(Transformationen.tstop),3);
+ end;
+ senkrecht:=Transformationen.xstart=Transformationen.xstop;
+ if (not senkrecht) and (Transformationen.tstart<>Transformationen.tstop) then begin
+ gibAus('Binning geht nur auf eindimensionalen Daten!',3);
+ exit;
+ end;
+
+ params:=trim(params);
+ linien:=startetMit('(Gnuplotlinien)',params);
+ x0:=kont2disk(char(ord('x')+byte(senkrecht)),exprtofloat(st,erstesArgument(params)));
+ dx:=kont2diskFak(char(ord('x')+byte(senkrecht)),exprtofloat(st,erstesArgument(params)));
+
+ if pos(' ',params)>0 then begin
+ gibAus('Leerzeichen im Dateinamen sind nicht erlaubt!',3);
+ exit;
+ end;
+
+ if not st then
+ case Genauigkeit of
+ gSingle:
+ sWerte.erzeugeBinning(senkrecht,linien,x0,dx,params);
+ gDouble:
+ dWerte.erzeugeBinning(senkrecht,linien,x0,dx,params);
+ gExtended:
+ eWerte.erzeugeBinning(senkrecht,linien,x0,dx,params);
+ end{of case};
+ gibAus('... fertig '+timetostr(now-Zeit),3);
+ result:=true;
end;
procedure tWerte.schreibeWert(var f: textfile; x,y: longint);
@@ -3717,9 +3838,10 @@ begin
end;
procedure tWerte.spiegle(threads,tmin,tmax: longint);
-var i: longint;
- sts: array of tSpiegelthread;
- fertig: boolean;
+var
+ i: longint;
+ sts: array of tSpiegelthread;
+ fertig: boolean;
begin
warteaufBeendigungDesLeseThreads;
setlength(sts,threads);
@@ -3736,14 +3858,15 @@ begin
until fertig;
for i:=0 to length(sts)-1 do
sts[i].free;
- Transformationen.AddSpiegelung;
+ Transformationen:=tSpiegelungsTransformation.create(Transformationen);
gibAus('Alle Spiegelthreads fertig!',1);
end;
procedure tWerte.fft2dNachbearbeitung(threads: longint; nb: tFFTDatenordnung);
-var i: longint;
- FNTs: array of tFFT2dNBThread;
- fertig: boolean;
+var
+ i: longint;
+ FNTs: array of tFFT2dNBThread;
+ fertig: boolean;
begin // bearbeitet nur den Hauptteil (außer erster und mittlerer Zeile/Spalte) nach!
setlength(FNTs,threads);
for i:=0 to length(FNTs)-1 do
@@ -3764,7 +3887,8 @@ begin // bearbeitet nur den Hauptteil (außer erster und mittlerer Zeile/Spalte)
end;
function tWerte.callBackGetValue(s: string): extended;
-var i: longint;
+var
+ i: longint;
begin
result:=nan;
if startetMit('Kontur[',s) or startetMit('Konturen[',s) then begin
@@ -3829,39 +3953,27 @@ end;
procedure tWerte.beendeLeseThreadWennFertig;
begin
- if assigned(leseThread) and leseThread.fertig then begin
- leseThread.free;
- leseThread:=nil;
- end;
-end;
-
-function tWerte.Transformationen: tTransformationen;
-begin
- case genauigkeit of
- gSingle:
- result:=sWerte.params.transformationen;
- gDouble:
- result:=dWerte.params.transformationen;
- gExtended:
- result:=eWerte.params.transformationen;
- end{of case};
+ if assigned(leseThread) and leseThread.fertig then begin
+ leseThread.free;
+ leseThread:=nil;
+ end;
end;
// tLogThread ******************************************************************
constructor tLogThread.create;
begin
- inherited create(true);
- raisedException:=nil;
- freeonterminate:=false;
- fertig:=false;
+ inherited create(true);
+ raisedException:=nil;
+ freeonterminate:=false;
+ fertig:=false;
end;
destructor tLogThread.destroy;
begin
- raisedException.free;
- if (not behalteLogs) and not odd(__ausgabenMaske) then cleanupLog(threadID);
- inherited destroy;
+ raisedException.free;
+ if (not behalteLogs) and not odd(__ausgabenMaske) then cleanupLog(threadID);
+ inherited destroy;
end;
function tLogThread.rFertig: boolean;
@@ -3869,34 +3981,34 @@ var
ei: string;
i: longint;
begin
- if assigned(raisedException) then begin
- if self is tBefehlThread then begin
- if assigned((self as tBefehlThread).p) then begin
- ei:=' '''+(self as tBefehlThread).p.Executable+'''';
- for i:=0 to (self as tBefehlThread).p.parameters.count-1 do
- ei:=ei+' '''+(self as tBefehlThread).p.parameters[i]+'''';
- ei:=ei;
- end
- else ei:=': p=NIL';
- end
- else ei:='';
- raise raisedException;
- raise exception.create('Fehler innerhalb eines Threads ('+className+')'+ei+'!');
- end;
- result:=_fertig;
+ if assigned(raisedException) then begin
+ if self is tBefehlThread then begin
+ if assigned((self as tBefehlThread).p) then begin
+ ei:=' '''+(self as tBefehlThread).p.Executable+'''';
+ for i:=0 to (self as tBefehlThread).p.parameters.count-1 do
+ ei:=ei+' '''+(self as tBefehlThread).p.parameters[i]+'''';
+ ei:=ei;
+ end
+ else ei:=': p=NIL';
+ end
+ else ei:='';
+ raise raisedException;
+ raise exception.create('Fehler innerhalb eines Threads ('+className+')'+ei+'!');
+ end;
+ result:=_fertig;
end;
procedure tLogThread.execute;
begin
- try
- stExecute;
- except
- on E: exception do begin
- dumpExceptionCallStack(E);
- raisedException:=E;
- end;
- end;
- fertig:=true;
+ try
+ stExecute;
+ except
+ on E: exception do begin
+ dumpExceptionCallStack(E);
+ raisedException:=E;
+ end;
+ end;
+ fertig:=true;
end;
// tLiKoThread *****************************************************************
@@ -3918,12 +4030,13 @@ end;
destructor tLiKoThread.destroy;
begin
- inherited destroy;
+ inherited destroy;
end;
procedure tLiKoThread.stExecute;
-var i,j,k: longint;
- out0,in0: boolean;
+var
+ i,j,k: longint;
+ out0,in0: boolean;
begin
gibAus('LiKo-Berechnungsthread gestartet ('+inttostr(xmi)+'-'+inttostr(xma)+'x'+inttostr(tmi)+'-'+inttostr(tma)+') ...',1);
for i:=0 to length(liKo^)-1 do
@@ -3962,20 +4075,20 @@ begin
end;
end;
gExtended:
- for j:=tMi to tMa do begin
- if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
- gibAus('LiKo-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
- for i:=xMi to xMa do begin
- pW.eWerte.werte[i+j*pW._xsteps]:=0;
- for k:=0 to length(liKo^)-1 do begin
- pW.eWerte.werte[i+j*pW._xsteps]:=
- pW.eWerte.werte[i+j*pW._xsteps] +
- liKo^[k].alpha*liKo^[k].werte.eWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xsteps];
- in0:=in0 and (liKo^[k].werte.eWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xsteps]=0);
- end;
- out0:=out0 and (pW.eWerte.werte[i+j*pW._xsteps]=0);
- end;
- end;
+ for j:=tMi to tMa do begin
+ if (tMa-j) mod ((tMa-tMi) div 10) = 0 then
+ gibAus('LiKo-Berechnungsthread: '+inttostr(j)+'/'+inttostr(tMi)+'..'+inttostr(tMa)+' ('+inttostr(xMi)+'..'+inttostr(xMa)+')',1);
+ for i:=xMi to xMa do begin
+ pW.eWerte.werte[i+j*pW._xsteps]:=0;
+ for k:=0 to length(liKo^)-1 do begin
+ pW.eWerte.werte[i+j*pW._xsteps]:=
+ pW.eWerte.werte[i+j*pW._xsteps] +
+ liKo^[k].alpha*liKo^[k].werte.eWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xsteps];
+ in0:=in0 and (liKo^[k].werte.eWerte.werte[(xOf+i) + (tOf+j)*liKo^[k].werte._xsteps]=0);
+ end;
+ out0:=out0 and (pW.eWerte.werte[i+j*pW._xsteps]=0);
+ end;
+ end;
end{of Case};
if in0 then gibAus('Nur Nullen im Input!',1);
if out0 then gibAus('Nur Nullen im Output!',1);
@@ -4004,12 +4117,13 @@ end;
destructor tQuotientThread.destroy;
begin
- inherited destroy;
+ inherited destroy;
end;
procedure tQuotientThread.stExecute;
-var i,j: longint;
- i01,i02,o0: boolean;
+var
+ i,j: longint;
+ i01,i02,o0: boolean;
begin
gibAus('Quotient-Berechnungsthread gestartet ...',1);
i01:=true;
@@ -4212,12 +4326,13 @@ end;
destructor tProduktThread.destroy;
begin
- inherited destroy;
+ inherited destroy;
end;
procedure tProduktThread.stExecute;
-var i,j: longint;
- i01,i02,o0: boolean;
+var
+ i,j: longint;
+ i01,i02,o0: boolean;
begin
gibAus('Produkt-Berechnungsthread gestartet ...',1);
i01:=true;
@@ -4353,7 +4468,7 @@ end;
// tBilderthread ***************************************************************
-constructor tBilderthread.create(i,maxthreads,ibreite,ihoehe,lo,oo,ro,uo: longint; const wes: tWerteArray; xmin,xmax,tmin,tmax: Longint; xzoom,yzoom: extended; Nachbearbeitungen: tTransformationenArray; paletten: pTPalettenArray; beschri: pTBeschriftungen; rm: boolean);
+constructor tBilderthread.create(i,maxthreads,ibreite,ihoehe,lo,oo,ro,uo: longint; const wes: tWerteArray; xmin,xmax,tmin,tmax: Longint; xzoom,yzoom: extended; Nachbearbeitungen: tTransformationArray; paletten: pTPalettenArray; beschri: pTBeschriftungen; rm: boolean);
var
ii: longint;
begin
@@ -4457,7 +4572,7 @@ begin
else begin
farben[i-xpmi+(j+oof)*breite].rgbRed:=
$ff * byte((not rahmen) or
- ((not ((i=-1) and (j>=-1) and (j<=whoehe))) and // links
+ ((not ((i=-1) and (j>=-1) and (j<=whoehe))) and // links
(not ((i=gesBreite) and (j>=-1) and (j<=whoehe))) and // rechts
(not ((j=-1) and (i>=-1) and (i<=gesBreite))) and // oben
(not ((j=whoehe) and (i>=-1) and (i<=gesBreite))))); // unten
@@ -4527,32 +4642,32 @@ end;
constructor tDichteThread.create(xmi,xma,tmi,tma: longint; const werte: tWerte);
begin
- inherited create;
- xmin:=xmi;
- xmax:=xma;
- tmin:=tmi;
- tmax:=tma;
- w:=werte;
- maxdichte:=0;
- gibAus('Dichtethread kreiert: '+inttostr(xmin)+'-'+inttostr(xmax)+' '+inttostr(tmin)+'-'+inttostr(tmax),1);
- suspended:=false;
+ inherited create;
+ xmin:=xmi;
+ xmax:=xma;
+ tmin:=tmi;
+ tmax:=tma;
+ w:=werte;
+ maxdichte:=0;
+ gibAus('Dichtethread kreiert: '+inttostr(xmin)+'-'+inttostr(xmax)+' '+inttostr(tmin)+'-'+inttostr(tmax),1);
+ suspended:=false;
end;
destructor tDichteThread.destroy;
begin
- inherited destroy;
+ inherited destroy;
end;
procedure tDichteThread.stExecute;
begin
- gibAus('Dichtethread gestartet!',1);
- case w.Genauigkeit of
- gSingle: w.sWerte.gibMinMaxDichten(minDichte,maxDichte,xmin,xmax,tmin,tmax);
- gDouble: w.dWerte.gibMinMaxDichten(minDichte,maxDichte,xmin,xmax,tmin,tmax);
- gExtended: w.eWerte.gibMinMaxDichten(minDichte,maxDichte,xmin,xmax,tmin,tmax);
- end{of case};
- gibAus('Dichtethread fertig!',1);
- fertig:=true;
+ gibAus('Dichtethread gestartet!',1);
+ case w.Genauigkeit of
+ gSingle: w.sWerte.gibMinMaxDichten(minDichte,maxDichte,xmin,xmax,tmin,tmax);
+ gDouble: w.dWerte.gibMinMaxDichten(minDichte,maxDichte,xmin,xmax,tmin,tmax);
+ gExtended: w.eWerte.gibMinMaxDichten(minDichte,maxDichte,xmin,xmax,tmin,tmax);
+ end{of case};
+ gibAus('Dichtethread fertig!',1);
+ fertig:=true;
end;
// tFFTThread ******************************************************************
@@ -4577,19 +4692,19 @@ end;
destructor tFFTThread.destroy;
begin
- inherited destroy;
+ inherited destroy;
end;
procedure tFFTThread.stExecute;
begin
- gibAus('FFTthread gestartet: '+inttostr(xMi)+'-'+inttostr(xMa)+' '+inttostr(tMi)+'-'+inttostr(tMa)+' ...',1);
- case pW.Genauigkeit of
- gSingle: erfolg:=pW.sWerte.fft(xMi,xMa,tMi,tMa,sen,inv,vo,na,fen,pvFehler);
- gDouble: erfolg:=pW.dWerte.fft(xMi,xMa,tMi,tMa,sen,inv,vo,na,fen,pvFehler);
- gExtended: erfolg:=pW.eWerte.fft(xMi,xMa,tMi,tMa,sen,inv,vo,na,fen,pvFehler);
- end{of case};
- gibAus('... und fertig! ',1);
- fertig:=true;
+ gibAus('FFTthread gestartet: '+inttostr(xMi)+'-'+inttostr(xMa)+' '+inttostr(tMi)+'-'+inttostr(tMa)+' ...',1);
+ case pW.Genauigkeit of
+ gSingle: erfolg:=pW.sWerte.fft(xMi,xMa,tMi,tMa,sen,inv,vo,na,fen,pvFehler);
+ gDouble: erfolg:=pW.dWerte.fft(xMi,xMa,tMi,tMa,sen,inv,vo,na,fen,pvFehler);
+ gExtended: erfolg:=pW.eWerte.fft(xMi,xMa,tMi,tMa,sen,inv,vo,na,fen,pvFehler);
+ end{of case};
+ gibAus('... und fertig! ',1);
+ fertig:=true;
end;
// tSpiegelThread **************************************************************
@@ -4606,7 +4721,7 @@ end;
destructor tSpiegelThread.destroy;
begin
- inherited destroy;
+ inherited destroy;
end;
procedure tSpiegelThread.stExecute;
@@ -4636,7 +4751,7 @@ end;
destructor tFFT2dNBThread.destroy;
begin
- inherited destroy;
+ inherited destroy;
end;
procedure tFFT2dNBThread.stExecute;
@@ -4671,15 +4786,16 @@ end;
destructor tKorrelThread.destroy;
begin
- inherited destroy;
+ inherited destroy;
end;
procedure tKorrelThread.stExecute;
-var i,j,k,hl: longint;
- sus,suc,tmp,pvF: extended;
- in0,out0: boolean;
- fenster: tFenster;
- tmpW: tWerte;
+var
+ i,j,k,hl: longint;
+ sus,suc,tmp,pvF: extended;
+ in0,out0: boolean;
+ fenster: tFenster;
+ tmpW: tWerte;
begin
gibAus('Korrelationsberechnungsthread gestartet ...',1);
gibAus('('+inttostr(xmi)+'-'+inttostr(xma)+' x '+inttostr(tmi)+'-'+inttostr(tma)+'), '+inttostr(wl.werte.params.tsiz),1);
@@ -4823,7 +4939,8 @@ begin
end;
function tKontur.rxmin: extended;
-var i: longint;
+var
+ i: longint;
begin
if length(orte)=0 then begin
result:=nan;
@@ -4835,7 +4952,8 @@ begin
end;
function tKontur.rxmax: extended;
-var i: longint;
+var
+ i: longint;
begin
if length(orte)=0 then begin
result:=nan;
@@ -4847,7 +4965,8 @@ begin
end;
function tKontur.rtmin: extended;
-var i: longint;
+var
+ i: longint;
begin
if length(orte)=0 then begin
result:=nan;
@@ -4859,7 +4978,8 @@ begin
end;
function tKontur.rtmax: extended;
-var i: longint;
+var
+ i: longint;
begin
if length(orte)=0 then begin
result:=nan;
@@ -4871,8 +4991,9 @@ begin
end;
function tKontur.init(st: boolean; var f: tMyStringlist; w: pTWerteArray; mt: longint): boolean;
-var s,xmi,xma,tmi,tma: string;
- i,j,k,tmpi: longint;
+var
+ s,xmi,xma,tmi,tma: string;
+ i,j,k,tmpi: longint;
begin
result:=false;
gibAus('Kontur erzeugen ...',1);
@@ -4892,8 +5013,8 @@ begin
tmpi:=
(tmpi shl 4) or
(ord(s[i])-ord('0')
- - byte(s[i] in ['a'..'f'])*(ord('a')-ord('0')-10)
- - byte(s[i] in ['A'..'F'])*(ord('A')-ord('0')-10));
+ - byte(s[i] in ['a'..'f'])*(ord('a')-ord('0')-10)
+ - byte(s[i] in ['A'..'F'])*(ord('A')-ord('0')-10));
end
else
tmpi:=strtoint(copy(s,1,pos(' ',s)-1));
@@ -4981,9 +5102,10 @@ begin
end;
function tKontur.liesVonDatei(st: boolean; s: string; xmi,xma,tmi,tma: extended): boolean;
-var tf: textfile;
- i: longint;
- tmp: tExtPoint;
+var
+ tf: textfile;
+ i: longint;
+ tmp: tExtPoint;
begin
result:=false;
if not fileexists(s) then begin
@@ -5015,10 +5137,11 @@ begin
end;
function tKontur.erzeugeAusWerten(st: boolean; s: string; w: pTWerteArray; mt: longint; _xmin,_xmax,_tmin,_tmax: string): boolean;
-var i,j,k,l,xmi,xma,tmi,tma: longint;
- Schwelle: extended;
- fertig: boolean;
- Konturthreads: array of tKonturAusWertenThread;
+var
+ i,j,k,l,xmi,xma,tmi,tma: longint;
+ Schwelle: extended;
+ fertig: boolean;
+ Konturthreads: array of tKonturAusWertenThread;
begin
result:=false;
i:=findeWerte(erstesArgument(s),nil,w,nil,false);
@@ -5072,61 +5195,62 @@ begin
end;
function tKontur.sortiere_nach_y(mt,von,bis: longint): boolean;
-var i,j: longint;
- avg: extended;
- tmp: tExtPoint;
- st1,st2: tSortiereNachYThread;
-begin
- result:=false;
- if von>=bis then begin
- result:=true;
- exit;
- end;
- avg:=0;
- for i:=von to bis do
- avg:=avg+Orte[i]['y'];
- avg:=avg/(bis-von+1);
- i:=von;
- j:=bis;
-
- while i<j do begin
- while (i<=j) and (Orte[i]['y']<=avg) do
- inc(i);
- while (i<=j) and (Orte[j]['y']>=avg) do
- dec(j);
- if i<j then begin
- tmp:=Orte[i];
- Orte[i]:=Orte[j];
- Orte[j]:=tmp;
- end;
- end;
- if i<>j+1 then begin
- gibAus(' interner Quicksort-Fehler: "quicksort-sanity-check nicht bestanden! (i='+inttostr(i)+' & j='+inttostr(j)+')"',1);
- exit;
- end;
- if (j<von) or (i>bis) then begin
- for i:=von+1 to bis do
- if Orte[i]['y'] <> Orte[von]['y'] then begin
- gibAus(' interner Quicksort-Fehler: "komisch, die Orte sind doch unterschiedlich ..."',1);
- halt;
- end;
- result:=true;
- exit;
- end;
-
- if mt<=1 then
- result:=sortiere_nach_y(mt,von,i-1) and sortiere_nach_y(mt,i,bis)
- else begin
- j:=min(max(1,round(mt/(bis+1-von)*(i-von))),mt-1);
- st1:=tSortiereNachYThread.create(self,j,von,i-1);
- st2:=tSortiereNachYThread.create(self,mt-j,i,bis);
- repeat
- sleep(10);
- until st1.fertig and st2.fertig;
- result:=st1.erfolg and st2.erfolg;
- st1.free;
- st2.free;
- end;
+var
+ i,j: longint;
+ avg: extended;
+ tmp: tExtPoint;
+ st1,st2: tSortiereNachYThread;
+begin
+ result:=false;
+ if von>=bis then begin
+ result:=true;
+ exit;
+ end;
+ avg:=0;
+ for i:=von to bis do
+ avg:=avg+Orte[i]['y'];
+ avg:=avg/(bis-von+1);
+ i:=von;
+ j:=bis;
+
+ while i<j do begin
+ while (i<=j) and (Orte[i]['y']<=avg) do
+ inc(i);
+ while (i<=j) and (Orte[j]['y']>=avg) do
+ dec(j);
+ if i<j then begin
+ tmp:=Orte[i];
+ Orte[i]:=Orte[j];
+ Orte[j]:=tmp;
+ end;
+ end;
+ if i<>j+1 then begin
+ gibAus(' interner Quicksort-Fehler: "quicksort-sanity-check nicht bestanden! (i='+inttostr(i)+' & j='+inttostr(j)+')"',1);
+ exit;
+ end;
+ if (j<von) or (i>bis) then begin
+ for i:=von+1 to bis do
+ if Orte[i]['y'] <> Orte[von]['y'] then begin
+ gibAus(' interner Quicksort-Fehler: "komisch, die Orte sind doch unterschiedlich ..."',1);
+ halt;
+ end;
+ result:=true;
+ exit;
+ end;
+
+ if mt<=1 then
+ result:=sortiere_nach_y(mt,von,i-1) and sortiere_nach_y(mt,i,bis)
+ else begin
+ j:=min(max(1,round(mt/(bis+1-von)*(i-von))),mt-1);
+ st1:=tSortiereNachYThread.create(self,j,von,i-1);
+ st2:=tSortiereNachYThread.create(self,mt-j,i,bis);
+ repeat
+ sleep(10);
+ until st1.fertig and st2.fertig;
+ result:=st1.erfolg and st2.erfolg;
+ st1.free;
+ st2.free;
+ end;
end;
// tKonturAusWertenThread ******************************************************
@@ -5146,8 +5270,8 @@ end;
destructor tKonturAusWertenThread.destroy;
begin
- setlength(punkte,0);
- inherited destroy;
+ setlength(punkte,0);
+ inherited destroy;
end;
procedure tKonturAusWertenThread.stExecute;
@@ -5180,15 +5304,15 @@ end;
destructor tIntegralThread.destroy;
begin
- inherited destroy;
+ inherited destroy;
end;
procedure tIntegralThread.stExecute;
begin
gibAus('Integralthread gestartet ('+inttostr(xmi)+'-'+inttostr(xma)+'x'+inttostr(tmi)+'-'+inttostr(tma)+') '+
- '('+inttostr(qu._xsteps)+'x'+inttostr(qu._tsiz)+') -> '+
- '('+inttostr(zi._xsteps)+'x'+inttostr(zi._tsiz)+') delta: '+
- inttostr(xof)+'x'+inttostr(tof)+' ...',1);
+ '('+inttostr(qu._xsteps)+'x'+inttostr(qu._tsiz)+') -> '+
+ '('+inttostr(zi._xsteps)+'x'+inttostr(zi._tsiz)+') delta: '+
+ inttostr(xof)+'x'+inttostr(tof)+' ...',1);
case rtg of
irHorizontal: gibAus(' (horizontal)',1);
irEinfall: gibAus(' (einfallend)',1);
@@ -5222,27 +5346,27 @@ end;
constructor tSortiereNachYThread.create(K: tKontur; threads,von,bis: longint);
begin
- inherited create;
- Kont:=K;
- vo:=von;
- bi:=bis;
- mt:=threads;
- erfolg:=false;
- gibAus('Sortierthread kreiert ('+inttostr(vo)+'-'+inttostr(bi)+') -> x'+inttostr(mt),1);
- suspended:=false;
+ inherited create;
+ Kont:=K;
+ vo:=von;
+ bi:=bis;
+ mt:=threads;
+ erfolg:=false;
+ gibAus('Sortierthread kreiert ('+inttostr(vo)+'-'+inttostr(bi)+') -> x'+inttostr(mt),1);
+ suspended:=false;
end;
destructor tSortiereNachYThread.destroy;
begin
- inherited destroy;
+ inherited destroy;
end;
procedure tSortiereNachYThread.stExecute;
begin
- gibAus('Sortierthread gestartet ('+inttostr(vo)+'-'+inttostr(bi)+') -> x'+inttostr(mt)+' ...',1);
- erfolg:=Kont.sortiere_nach_y(mt,vo,bi);
- gibAus(' ... und fertig',1);
- fertig:=true;
+ gibAus('Sortierthread gestartet ('+inttostr(vo)+'-'+inttostr(bi)+') -> x'+inttostr(mt)+' ...',1);
+ erfolg:=Kont.sortiere_nach_y(mt,vo,bi);
+ gibAus(' ... und fertig',1);
+ fertig:=true;
end;
// tBefehlThread ***************************************************************
@@ -5251,547 +5375,559 @@ constructor tBefehlThread.create(st: boolean; cmd: string; out erfolg: boolean);
var
nichtLeeresArgument: boolean;
function shellParseNextArg(var s: string): string;
-var err: longint;
- sr: tSearchRec;
-begin
- if length(s)=0 then
- exit;
- if startetMit('"',s) then begin
- if pos('"',s)=0 then begin
- gibAus('Kein passendes zweites Anführungszeichen im Argument für den Befehl gefunden!',3);
- erfolg:=false;
- exit;
- end;
- result:=erstesArgument(s,'"');
- end
- else begin
- result:=stringReplace(erstesArgument(s),'$$DATETIME',mydatetimetostr(now),[rfReplaceAll]);
- if pos('*',result)>0 then begin
- err:=findFirst(result,$3F,sr);
- while err=0 do begin
- if (sr.Name<>'.') and (sr.Name<>'..') then s:=trim('"'+extractfilepath(result)+sr.Name+'" '+s);
- err:=findNext(sr);
- end;
- findClose(sr);
- result:=shellParseNextArg(s);
- end;
- end;
- if startetMit('./',result) then
- result:=extractfilepath(paramstr(0))+result;
- if result<>'' then
- nichtLeeresArgument:=true;
-end;
-begin
- if not st then
- inherited create;
-
- erfolg:=cmd<>'';
- if st then begin
- endetMit('&',cmd);
- shellParseNextArg(cmd);
- end
- else begin
- bg:=endetMit('&',cmd);
- p:=tProcess.create(nil);
- p.Options:=p.Options + [poWaitOnExit];
- p.Executable:=shellParseNextArg(cmd);
- end;
- nichtLeeresArgument:=cmd='';
- if not erfolg then begin
- if not st then begin
- p.free;
- p:=nil;
- end;
- exit;
- end;
- while length(cmd)>0 do begin
- if st then
- shellParseNextArg(cmd)
- else
- p.Parameters.Add(shellParseNextArg(cmd));
- if not erfolg then begin
- if not st then begin
- p.free;
- p:=nil;
- end;
- exit;
- end;
- end;
- if st then
- exit;
- if not nichtLeeresArgument then begin
- p.free;
- p:=nil;
- end;
- if assigned(p) then begin
- cmd:=p.Parameters.Text;
- while (length(cmd)>0) and (cmd[length(cmd)] in [#10,#13]) do
- delete(cmd,length(cmd),1);
- cmd:=''''+cmd+'''';
- while pos(#10,cmd)>0 do
- cmd:=leftStr(cmd,pos(#10,cmd)-1)+''' '''+copy(cmd,pos(#10,cmd)+1,length(cmd));
- while pos(#13,cmd)>0 do
- cmd:=leftStr(cmd,pos(#13,cmd)-1)+''' '''+copy(cmd,pos(#13,cmd)+1,length(cmd));
- gibAus('Externer Befehl: '''+p.Executable+''' '+cmd+' erzeugt.',3);
- end
- else
- gibAus('Des Befehls zu expandierende Argumente hatten keine Treffer, er wird ignoriert.',3);
+var
+ err: longint;
+ sr: tSearchRec;
+begin
+ if length(s)=0 then
+ exit;
+ if startetMit('"',s) then begin
+ if pos('"',s)=0 then begin
+ gibAus('Kein passendes zweites Anführungszeichen im Argument für den Befehl gefunden!',3);
+ erfolg:=false;
+ exit;
+ end;
+ result:=erstesArgument(s,'"');
+ end
+ else begin
+ result:=stringReplace(erstesArgument(s),'$$DATETIME',mydatetimetostr(now),[rfReplaceAll]);
+ if pos('*',result)>0 then begin
+ err:=findFirst(result,$3F,sr);
+ while err=0 do begin
+ if (sr.Name<>'.') and (sr.Name<>'..') then s:=trim('"'+extractfilepath(result)+sr.Name+'" '+s);
+ err:=findNext(sr);
+ end;
+ findClose(sr);
+ result:=shellParseNextArg(s);
+ end;
+ end;
+ if startetMit('./',result) then
+ result:=extractfilepath(paramstr(0))+result;
+ if result<>'' then
+ nichtLeeresArgument:=true;
+end;
+begin
+ if not st then
+ inherited create;
+
+ erfolg:=cmd<>'';
+ if st then begin
+ endetMit('&',cmd);
+ shellParseNextArg(cmd);
+ end
+ else begin
+ bg:=endetMit('&',cmd);
+ p:=tProcess.create(nil);
+ p.Options:=p.Options + [poWaitOnExit];
+ p.Executable:=shellParseNextArg(cmd);
+ end;
+ nichtLeeresArgument:=cmd='';
+ if not erfolg then begin
+ if not st then begin
+ p.free;
+ p:=nil;
+ end;
+ exit;
+ end;
+ while length(cmd)>0 do begin
+ if st then
+ shellParseNextArg(cmd)
+ else
+ p.Parameters.Add(shellParseNextArg(cmd));
+ if not erfolg then begin
+ if not st then begin
+ p.free;
+ p:=nil;
+ end;
+ exit;
+ end;
+ end;
+ if st then
+ exit;
+ if not nichtLeeresArgument then begin
+ p.free;
+ p:=nil;
+ end;
+ if assigned(p) then begin
+ cmd:=p.Parameters.Text;
+ while (length(cmd)>0) and (cmd[length(cmd)] in [#10,#13]) do
+ delete(cmd,length(cmd),1);
+ cmd:=''''+cmd+'''';
+ while pos(#10,cmd)>0 do
+ cmd:=leftStr(cmd,pos(#10,cmd)-1)+''' '''+copy(cmd,pos(#10,cmd)+1,length(cmd));
+ while pos(#13,cmd)>0 do
+ cmd:=leftStr(cmd,pos(#13,cmd)-1)+''' '''+copy(cmd,pos(#13,cmd)+1,length(cmd));
+ gibAus('Externer Befehl: '''+p.Executable+''' '+cmd+' erzeugt.',3);
+ end
+ else
+ gibAus('Des Befehls zu expandierende Argumente hatten keine Treffer, er wird ignoriert.',3);
end;
destructor tBefehlThread.destroy;
begin
- gibAus('Befehl zerstört.',3);
- p.free;
- inherited destroy;
+ gibAus('Befehl zerstört.',3);
+ p.free;
+ inherited destroy;
end;
procedure tBefehlThread.stExecute;
begin
- if assigned(p) then begin
- gibAus('externen Befehl ausführen ... '+inttostr(belegterSpeicher),3);
- gibAus(p.Executable,3);
- gibAus(p.Parameters.text,3);
- p.Execute;
- gibAus('... fertig!',1);
- end
- else
- gibAus('Externer Befehl hätte nichts zu tun und wird daher gar nicht erst gestartet.',1);
- fertig:=true;
+ if assigned(p) then begin
+ gibAus('externen Befehl ausführen ... '+inttostr(belegterSpeicher),3);
+ gibAus(p.Executable,3);
+ gibAus(p.Parameters.text,3);
+ p.Execute;
+ gibAus('... fertig!',1);
+ end
+ else
+ gibAus('Externer Befehl hätte nichts zu tun und wird daher gar nicht erst gestartet.',1);
+ fertig:=true;
end;
// tLeseThread *****************************************************************
constructor tLeseThread.create(we: tWerte; inps: tGenerischeInputDateiInfoArray);
-var i: longint;
-begin
- inherited create;
- w:=we;
- setlength(inputs,length(inps));
- for i:=0 to length(inputs)-1 do begin
- if inps[i] is tPhaseSpaceInputDateiInfo then begin
- inputs[i]:=tPhaseSpaceInputDateiInfo.create(inps[i]);
- continue;
- end;
- if inps[i] is tSpaceTimeInputDateiInfo then begin
- inputs[i]:=tSpaceTimeInputDateiInfo.create(inps[i]);
- continue;
- end;
- if inps[i] is tTraceInputDateiInfo then begin
- inputs[i]:=tTraceInputDateiInfo.create(inps[i]);
- continue;
- end;
- if inps[i] is tPipeInputDateiInfo then begin
- inputs[i]:=tPipeInputDateiInfo.create(inps[i]);
- continue;
- end;
- gibAus('unbekannter InputDateiInfo-Typ ...',3);
- halt(1);
- end;
- gibAus('LeseThread erzeugt',1);
- suspended:=false;
+var
+ i: longint;
+begin
+ inherited create;
+ w:=we;
+ setlength(inputs,length(inps));
+ for i:=0 to length(inputs)-1 do begin
+ if inps[i] is tPhaseSpaceInputDateiInfo then begin
+ inputs[i]:=tPhaseSpaceInputDateiInfo.create(inps[i]);
+ continue;
+ end;
+ if inps[i] is tSpaceTimeInputDateiInfo then begin
+ inputs[i]:=tSpaceTimeInputDateiInfo.create(inps[i]);
+ continue;
+ end;
+ if inps[i] is tTraceInputDateiInfo then begin
+ inputs[i]:=tTraceInputDateiInfo.create(inps[i]);
+ continue;
+ end;
+ if inps[i] is tPipeInputDateiInfo then begin
+ inputs[i]:=tPipeInputDateiInfo.create(inps[i]);
+ continue;
+ end;
+ gibAus('unbekannter InputDateiInfo-Typ ...',3);
+ halt(1);
+ end;
+ gibAus('LeseThread erzeugt',1);
+ suspended:=false;
end;
destructor tLeseThread.destroy;
begin
- w:=nil;
- inherited destroy;
+ w:=nil;
+ inherited destroy;
end;
procedure tLeseThread.stExecute;
begin
- gibAus('LeseThread gestartet',1);
- case w.Genauigkeit of
- gSingle:
- if not w.sWerte.liesDateien(inputs) then
- exit;
- gDouble:
- if not w.dWerte.liesDateien(inputs) then
- exit;
- gExtended:
- if not w.eWerte.liesDateien(inputs) then
- exit;
- end{of case};
- gibAus('LeseThread beendet',1);
- fertig:=true;
+ gibAus('LeseThread gestartet',1);
+ case w.Genauigkeit of
+ gSingle:
+ if not w.sWerte.liesDateien(inputs) then
+ exit;
+ gDouble:
+ if not w.dWerte.liesDateien(inputs) then
+ exit;
+ gExtended:
+ if not w.eWerte.liesDateien(inputs) then
+ exit;
+ end{of case};
+ gibAus('LeseThread beendet',1);
+ fertig:=true;
end;
// tVerzerrInitThread **********************************************************
-constructor tVerzerrInitThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tTransformationen; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; Warn: tWarnstufe);
-begin
- inherited create;
- qu:=quelle;
- zi:=ziel;
- ZPs:=zielpositionen;
- ZGs:=zielgewichte;
- setlength(ZAs,zi._xsteps*zi._tsiz);
- xMi:=xMin;
- xMa:=xMax;
- tMi:=tMin;
- tMa:=tMax;
- x0:=x0Abs;
- t0:=t0Abs;
- eps:=epsilon;
- verz:=verzerrung;
- mt:=threads;
- Warnstufe:=Warn;
- gibAus('VerzerrInitThread kreiert',1);
- suspended:=false;
+constructor tVerzerrInitThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tTransformation; verzerrAnz: longint; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; Warn: tWarnstufe);
+begin
+ inherited create;
+ qu:=quelle;
+ zi:=ziel;
+ ZPs:=zielpositionen;
+ ZGs:=zielgewichte;
+ setlength(ZAs,zi._xsteps*zi._tsiz);
+ xMi:=xMin;
+ xMa:=xMax;
+ tMi:=tMin;
+ tMa:=tMax;
+ x0:=x0Abs;
+ t0:=t0Abs;
+ eps:=epsilon;
+ verz:=verzerrung;
+ va:=verzerrAnz;
+ mt:=threads;
+ Warnstufe:=Warn;
+ gibAus('VerzerrInitThread kreiert',1);
+ suspended:=false;
end;
destructor tVerzerrInitThread.destroy;
begin
- setlength(ZAs,0);
- inherited destroy;
+ setlength(ZAs,0);
+ inherited destroy;
end;
procedure tVerzerrInitThread.stExecute;
begin
- gibAus('VerzerrInitThread gestartet ('+inttostr(xMi)+'-'+inttostr(xMa)+'/'+inttostr(tMi)+'-'+inttostr(tMa)+')',1);
- zi.initVerzerrung(qu,xMi,xMa,tMi,tMa,x0,t0,mt,false,eps,verz,ZPs,ZGs,ZAs,Warnstufe);
- gibAus('VerzerrInitThread beendet',1);
+ gibAus('VerzerrInitThread gestartet ('+inttostr(xMi)+'-'+inttostr(xMa)+'/'+inttostr(tMi)+'-'+inttostr(tMa)+')',1);
+ zi.initVerzerrung(qu,xMi,xMa,tMi,tMa,x0,t0,mt,false,eps,verz,va,ZPs,ZGs,ZAs,Warnstufe);
+ gibAus('VerzerrInitThread beendet',1);
end;
// tVerzerrThread **************************************************************
-constructor tVerzerrThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tTransformationen);
+constructor tVerzerrThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tTransformation; vorAnz,nachAnz: longint);
begin
- inherited create;
- qu:=quelle;
- zi:=ziel;
- ZPs:=zielpositionen;
- ZGs:=zielgewichte;
- ZAs:=zielanzahlen;
- xMi:=xMin;
- xMa:=xMax;
- tMi:=tMin;
- tMa:=tMax;
- vb:=Vorbearbeitungen;
- nb:=Nachbearbeitungen;
- gibAus('Verzerrthread erzeugt',1);
- suspended:=false;
+ inherited create;
+ qu:=quelle;
+ zi:=ziel;
+ ZPs:=zielpositionen;
+ ZGs:=zielgewichte;
+ ZAs:=zielanzahlen;
+ xMi:=xMin;
+ xMa:=xMax;
+ tMi:=tMin;
+ tMa:=tMax;
+ vb:=Vorbearbeitungen;
+ va:=vorAnz;
+ nb:=Nachbearbeitungen;
+ na:=nachAnz;
+ gibAus('Verzerrthread erzeugt',1);
+ suspended:=false;
end;
destructor tVerzerrThread.destroy;
begin
- inherited destroy;
+ inherited destroy;
end;
procedure tVerzerrThread.stExecute;
-var sw: pTLLWerteSingle;
- dw: pTLLWerteDouble;
- ew: pTLLWerteExtended;
-begin
- gibAus('Verzerrthread gestartet '+floattostr(qu._minW)+' '+floattostr(qu._maxW),1);
- case qu.genauigkeit of
- gSingle: begin
- sw:=@(qu.sWerte);
- dw:=nil;
- ew:=nil;
- end;
- gDouble: begin
- sw:=nil;
- dw:=@(qu.dWerte);
- ew:=nil;
- end;
- gExtended: begin
- sw:=nil;
- dw:=nil;
- ew:=@(qu.eWerte);
- end;
- end{of case};
- case zi.genauigkeit of
- gSingle:
- case qu.genauigkeit of
- gSingle:
- zi.sWerte.kopiereVerzerrt(sw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
- gDouble:
- zi.sWerte.kopiereVerzerrt(dw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
- gExtended:
- zi.sWerte.kopiereVerzerrt(ew,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
- end{of case};
- gDouble:
- case qu.genauigkeit of
- gSingle:
- zi.dWerte.kopiereVerzerrt(sw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
- gDouble:
- zi.dWerte.kopiereVerzerrt(dw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
- gExtended:
- zi.dWerte.kopiereVerzerrt(ew,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
- end{of case};
- gExtended:
- case qu.genauigkeit of
- gSingle:
- zi.eWerte.kopiereVerzerrt(sw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
- gDouble:
- zi.eWerte.kopiereVerzerrt(dw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
- gExtended:
- zi.eWerte.kopiereVerzerrt(ew,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb);
- end{of case};
- end{of case};
- gibAus('Verzerrthread beendet',1);
+var
+ sw: pTLLWerteSingle;
+ dw: pTLLWerteDouble;
+ ew: pTLLWerteExtended;
+begin
+ gibAus('Verzerrthread gestartet '+floattostr(qu._minW)+' '+floattostr(qu._maxW),1);
+ case qu.genauigkeit of
+ gSingle: begin
+ sw:=@(qu.sWerte);
+ dw:=nil;
+ ew:=nil;
+ end;
+ gDouble: begin
+ sw:=nil;
+ dw:=@(qu.dWerte);
+ ew:=nil;
+ end;
+ gExtended: begin
+ sw:=nil;
+ dw:=nil;
+ ew:=@(qu.eWerte);
+ end;
+ end{of case};
+ case zi.genauigkeit of
+ gSingle:
+ case qu.genauigkeit of
+ gSingle:
+ zi.sWerte.kopiereVerzerrt(sw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ gDouble:
+ zi.sWerte.kopiereVerzerrt(dw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ gExtended:
+ zi.sWerte.kopiereVerzerrt(ew,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ end{of case};
+ gDouble:
+ case qu.genauigkeit of
+ gSingle:
+ zi.dWerte.kopiereVerzerrt(sw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ gDouble:
+ zi.dWerte.kopiereVerzerrt(dw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ gExtended:
+ zi.dWerte.kopiereVerzerrt(ew,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ end{of case};
+ gExtended:
+ case qu.genauigkeit of
+ gSingle:
+ zi.eWerte.kopiereVerzerrt(sw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ gDouble:
+ zi.eWerte.kopiereVerzerrt(dw,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ gExtended:
+ zi.eWerte.kopiereVerzerrt(ew,ZPs,ZGs,ZAs,xMi,xMa,tMi,tMa,vb,nb,va,na);
+ end{of case};
+ end{of case};
+ gibAus('Verzerrthread beendet',1);
end;
// sonstiges *******************************************************************
function findePalette(out Palette: pTPalette; name: string): boolean;
-var i: longint;
+var
+ i: longint;
begin
- result:=true;
- for i:=0 to length(paletten)-1 do
+ result:=true;
+ for i:=0 to length(paletten)-1 do
if paletten[i].name=name then
- begin
+ begin
Palette:=@(paletten[i]);
exit;
- end;
- Palette:=nil;
- result:=false;
-end;
-
-function erzeugeLegende(st: boolean; var f: tMyStringlist; datei: string; Qu: tWerte; minDichte,maxDichte: extended; nb: tTransformationen; pal: pTPalette): boolean;
-var s: string;
- breite,hoehe,i,j,k,lo,ro,oo,uo,
- schriftgroesze: longint;
- img: file;
- lineareFarbe,waagerecht,rahmen: boolean;
- farben: tRgbArray;
- col: tRGB;
- wert,tmp,schritt: extended;
- fontRenderer: tFontRenderer;
- beschriftungsschritte: array of tBeschriftungsschritt;
- beschriftungen: array of tBeschriftung;
-begin
- result:=false;
- breite:=100;
- hoehe:=100;
- waagerecht:=false;
- lineareFarbe:=false;
- schriftgroesze:=24;
- setlength(beschriftungen,0);
- setlength(beschriftungsschritte,2);
- beschriftungsschritte[0].schritte:=0;
- beschriftungsschritte[0].bis:=minDichte;
- beschriftungsschritte[0].linear:=false;
- beschriftungsschritte[0].faktor:=1;
- beschriftungsschritte[1].bis:=maxDichte;
- beschriftungsschritte[1].schritte:=10;
- beschriftungsschritte[1].linear:=true;
- beschriftungsschritte[1].faktor:=1;
- rahmen:=false;
- repeat
- if not f.metaReadln(s,true) then begin
- gibAus('Unerwartetes Dateiende in '''+paramstr(1)+'''!',3);
- exit;
- end;
- if startetMit('Ausrichtung:',s) then begin
- waagerecht:=s='waagerecht';
- if (s='waagerecht') or (s='senkrecht') then continue;
- gibAus(''''+s+''' ist keine gültige Ausrichtung!',3);
- exit;
- end;
- if startetMit('Breite:',s) then begin
- breite:=strtoint(s);
- continue;
- end;
- if startetMit('Höhe:',s) then begin
- hoehe:=strtoint(s);
- continue;
- end;
- if startetMit('Schriftgröße:',s) then begin
- schriftgroesze:=strtoint(s);
- continue;
- end;
- if s='Farbe linear' then begin
- lineareFarbe:=true;
- continue;
- end;
- if s='Werte linear' then begin
- lineareFarbe:=false;
- continue;
- end;
- if s='Rahmen' then begin
- rahmen:=true;
- continue;
- end;
- if s='Beschriftungen:' then begin
- setlength(beschriftungsschritte,1);
- beschriftungsschritte[0].schritte:=0;
- beschriftungsschritte[0].bis:=minDichte;
- beschriftungsschritte[0].linear:=false;
- beschriftungsschritte[0].faktor:=1;
- repeat
- if not f.metaReadln(s,true) then begin
- gibAus('Unerwartetes Dateiende in '''+paramstr(1)+'''!',3);
- exit;
- end;
- if s='Beschriftungsende' then
- break;
- if not ((pos('linear',s)=1) or (pos('logarithmisch',s)=1) or (length(beschriftungsschritte)>1)) then begin
- gibAus('Ich weiß nicht, ob die Beschriftung linear oder logarithmisch sein soll!',3);
- exit;
- end;
- setlength(beschriftungsschritte,length(beschriftungsschritte)+1);
- if not ((pos('linear',s)=1) or (pos('logarithmisch',s)=1)) then begin
- beschriftungsschritte[length(beschriftungsschritte)-1].linear:=
- beschriftungsschritte[length(beschriftungsschritte)-2].linear;
- end;
- if startetMit('linear',s) then
- beschriftungsschritte[length(beschriftungsschritte)-1].linear:=true;
- if startetMit('logarithmisch',s) then begin
- beschriftungsschritte[length(beschriftungsschritte)-1].linear:=false;
- while pos(' ',s)=1 do
- delete(s,1,1);
- minDichte:=Qu.exprtofloat(st,copy(s,1,pos(' ',s)-1));
- beschriftungsschritte[0].bis:=maxDichte*minDichte;
- delete(s,1,pos(' ',s));
- for i:=0 to nb.count-1 do
- if nb[i] is tWerteLogTransformation then begin
- if (nb[i] as tWerteLogTransformation).logMin<>minDichte then begin
- gibAus('Die minimale Dichte der logarithmischen Farbskala ('+myfloattostr(minDichte)+') und der logarithmischen Nachbearbeitung ('+myfloattostr((nb[i] as tWerteLogTransformation).logMin)+') stimmen nicht überein!',3);
- exit;
- end;
- minDichte:=minDichte*maxDichte;
- break;
- end;
- end;
- s:=trim(s);
- beschriftungsschritte[length(beschriftungsschritte)-1].bis:=Qu.exprtofloat(st,erstesArgument(s));
- if endetMit('+',s) then beschriftungsschritte[length(beschriftungsschritte)-1].faktor:=0.5
- else if endetMit('-',s) then beschriftungsschritte[length(beschriftungsschritte)-1].faktor:=2
- else beschriftungsschritte[length(beschriftungsschritte)-1].faktor:=1;
- beschriftungsschritte[length(beschriftungsschritte)-1].schritte:=strtoint(s);
- until false;
- continue;
- end;
- if s='Ende' then
- break;
- gibAus('Verstehe Option '''+s+''' nicht bei Erzeugund der Legende!',3);
- exit;
- until false;
- if st then begin
- result:=true;
- exit;
- end;
-
- fontRenderer:=tFontRenderer.create(schriftgroesze);
-
- gibAus(floattostr(minDichte)+' '+floattostr(maxDichte),1);
- for i:=0 to length(beschriftungsschritte)-1 do
- gibAus(inttostr(i)+' '+floattostr(beschriftungsschritte[i].bis)+' '+floattostr(beschriftungsschritte[i].faktor)+' '+inttostr(beschriftungsschritte[i].schritte)+' '+inttostr(byte(beschriftungsschritte[i].linear)),1);
-
- i:=0;
- wert:=minDichte;
- schritt:=-1;
- while wert<maxDichte do begin
- if i>0 then gibAus(inttostr(i)+' '+floattostr(wert)+' '+floattostr(schritt)+' '+floattostr(beschriftungsschritte[i].bis),1);
- if ((i<length(beschriftungsschritte)-1) and (wert>beschriftungsschritte[i].bis)) or (i=0) then begin
- repeat
- inc(i);
- until (i>=length(beschriftungsschritte)-1) or (beschriftungsschritte[i].bis>=wert);
- if beschriftungsschritte[i].linear then begin
- schritt:=(beschriftungsschritte[i].bis-beschriftungsschritte[i-1].bis)/beschriftungsschritte[i].schritte;
- schritt:=power(10,round(ln(schritt)/ln(10)))*beschriftungsschritte[i].faktor;
- end
- else
- schritt:=power(10,floor(ln(wert)/ln(10)-beschriftungsschritte[i].schritte))*beschriftungsschritte[i].faktor;
- tmp:=round(beschriftungsschritte[i-1].bis/schritt)*schritt;
- while tmp<wert do tmp:=(round(tmp/schritt)+1)*schritt;
- wert:=tmp;
- gibAus(inttostr(i)+' '+floattostr(wert)+' '+floattostr(schritt)+' '+floattostr(beschriftungsschritte[i].bis),1);
- end;
- setlength(beschriftungen,length(beschriftungen)+1);
- beschriftungen[length(beschriftungen)-1]:=tBeschriftung.create;
- beschriftungen[length(beschriftungen)-1].bBreite:=breite;
- beschriftungen[length(beschriftungen)-1].bHoehe:=hoehe;
- beschriftungen[length(beschriftungen)-1].Rahmen:=Rahmen;
- beschriftungen[length(beschriftungen)-1].fontRend:=fontRenderer;
- beschriftungen[length(beschriftungen)-1].position:=(wert-minDichte)/(maxDichte-minDichte);
- beschriftungen[length(beschriftungen)-1].inhalt:=floattostr(wert);
- if not beschriftungsschritte[i].linear then
- schritt:=power(10,floor(ln(wert)/ln(10)-beschriftungsschritte[i].schritte))*beschriftungsschritte[i].faktor;
- wert:=(round(wert/schritt)+1)*schritt;
- end;
-
- if lineareFarbe then
- for i:=0 to length(beschriftungen)-1 do
- beschriftungen[i].position:=nb.transformiereWert(beschriftungen[i].position);
- for i:=0 to length(beschriftungen)-1 do
- beschriftungen[i].position:=beschriftungen[i].position*(hoehe+byte(waagerecht)*(breite-hoehe));
-
- lo:=Byte(Rahmen);
- ro:=Byte(Rahmen);
- oo:=Byte(Rahmen);
- uo:=Byte(Rahmen);
- for i:=0 to length(beschriftungen)-1 do begin
- lo:=max(lo,-beschriftungen[i].links);
- ro:=max(ro,1+beschriftungen[i].rechts-breite);
- oo:=max(oo,-beschriftungen[i].oben);
- uo:=max(uo,1+beschriftungen[i].unten-hoehe);
- end;
- if lo+oo+ro+uo>0 then
- gibAus('Extra-Ränder: '+inttostr(lo)+' Pixel links, '+inttostr(oo)+' Pixel oben, '+inttostr(ro)+' Pixel rechts und '+inttostr(uo)+' Pixel unten.',3);
-
- setlength(farben,byte(waagerecht)*(breite-hoehe)+hoehe);
- for i:=0 to length(farben)-1 do begin
- wert:=i/length(farben);
- if not lineareFarbe then
- wert:=nb.transformiereWert(wert);
- farben[i]:=wertZuFarbe(wert,pal^.farben);
- end;
- assign(img,datei);
- rewrite(img,1);
- schreibeBmpHeader(img,breite+lo+ro,hoehe+oo+uo);
- for j:=-oo to hoehe+uo-1 do begin
- i:=-lo;
- while i<breite+ro do
- if waagerecht and (i=0) and (j>=0) and (j<hoehe) then begin
- blockwrite(img,farben[0],3*breite);
- i:=breite;
- end
- else begin
- if (i>=0) and (i<breite) and (j>=0) and (j<hoehe) then col:=farben[j]
- else begin
- col.rgbRed:=$ff;
- col.rgbGreen:=$ff;
- col.rgbBlue:=$ff;
- if rahmen then begin
- if ((i=-1) and (j>=-1) and (j<=hoehe)) or
+ end;
+ Palette:=nil;
+ result:=false;
+end;
+
+function erzeugeLegende(st: boolean; var f: tMyStringlist; datei: string; Qu: tWerte; minDichte,maxDichte: extended; nb: tTransformation; pal: pTPalette): boolean;
+var
+ s: string;
+ breite,hoehe,i,j,k,lo,ro,oo,uo,
+ schriftgroesze: longint;
+ img: file;
+ lineareFarbe,waagerecht,rahmen: boolean;
+ farben: tRgbArray;
+ col: tRGB;
+ wert,tmp,schritt: extended;
+ fontRenderer: tFontRenderer;
+ beschriftungsschritte: array of tBeschriftungsschritt;
+ beschriftungen: array of tBeschriftung;
+ tmpTr: tTransformation;
+begin
+ result:=false;
+ breite:=100;
+ hoehe:=100;
+ waagerecht:=false;
+ lineareFarbe:=false;
+ schriftgroesze:=24;
+ setlength(beschriftungen,0);
+ setlength(beschriftungsschritte,2);
+ beschriftungsschritte[0].schritte:=0;
+ beschriftungsschritte[0].bis:=minDichte;
+ beschriftungsschritte[0].linear:=false;
+ beschriftungsschritte[0].faktor:=1;
+ beschriftungsschritte[1].bis:=maxDichte;
+ beschriftungsschritte[1].schritte:=10;
+ beschriftungsschritte[1].linear:=true;
+ beschriftungsschritte[1].faktor:=1;
+ rahmen:=false;
+ repeat
+ if not f.metaReadln(s,true) then begin
+ gibAus('Unerwartetes Dateiende in '''+paramstr(1)+'''!',3);
+ exit;
+ end;
+ if startetMit('Ausrichtung:',s) then begin
+ waagerecht:=s='waagerecht';
+ if (s='waagerecht') or (s='senkrecht') then continue;
+ gibAus(''''+s+''' ist keine gültige Ausrichtung!',3);
+ exit;
+ end;
+ if startetMit('Breite:',s) then begin
+ breite:=strtoint(s);
+ continue;
+ end;
+ if startetMit('Höhe:',s) then begin
+ hoehe:=strtoint(s);
+ continue;
+ end;
+ if startetMit('Schriftgröße:',s) then begin
+ schriftgroesze:=strtoint(s);
+ continue;
+ end;
+ if s='Farbe linear' then begin
+ lineareFarbe:=true;
+ continue;
+ end;
+ if s='Werte linear' then begin
+ lineareFarbe:=false;
+ continue;
+ end;
+ if s='Rahmen' then begin
+ rahmen:=true;
+ continue;
+ end;
+ if s='Beschriftungen:' then begin
+ setlength(beschriftungsschritte,1);
+ beschriftungsschritte[0].schritte:=0;
+ beschriftungsschritte[0].bis:=minDichte;
+ beschriftungsschritte[0].linear:=false;
+ beschriftungsschritte[0].faktor:=1;
+ repeat
+ if not f.metaReadln(s,true) then begin
+ gibAus('Unerwartetes Dateiende in '''+paramstr(1)+'''!',3);
+ exit;
+ end;
+ if s='Beschriftungsende' then
+ break;
+ if not ((pos('linear',s)=1) or (pos('logarithmisch',s)=1) or (length(beschriftungsschritte)>1)) then begin
+ gibAus('Ich weiß nicht, ob die Beschriftung linear oder logarithmisch sein soll!',3);
+ exit;
+ end;
+ setlength(beschriftungsschritte,length(beschriftungsschritte)+1);
+ if not ((pos('linear',s)=1) or (pos('logarithmisch',s)=1)) then begin
+ beschriftungsschritte[length(beschriftungsschritte)-1].linear:=
+ beschriftungsschritte[length(beschriftungsschritte)-2].linear;
+ end;
+ if startetMit('linear',s) then
+ beschriftungsschritte[length(beschriftungsschritte)-1].linear:=true;
+ if startetMit('logarithmisch',s) then begin
+ beschriftungsschritte[length(beschriftungsschritte)-1].linear:=false;
+ while pos(' ',s)=1 do
+ delete(s,1,1);
+ minDichte:=Qu.exprtofloat(st,copy(s,1,pos(' ',s)-1));
+ beschriftungsschritte[0].bis:=maxDichte*minDichte;
+ delete(s,1,pos(' ',s));
+ tmpTr:=nb;
+ while assigned(tmpTr) do begin
+ if tmpTr is tWerteLogTransformation then begin
+ if (tmpTr as tWerteLogTransformation).logMin<>minDichte then begin
+ gibAus('Die minimale Dichte der logarithmischen Farbskala ('+myfloattostr(minDichte)+') und der logarithmischen Nachbearbeitung ('+myfloattostr((tmpTr as tWerteLogTransformation).logMin)+') stimmen nicht überein!',3);
+ exit;
+ end;
+ minDichte:=minDichte*maxDichte;
+ break;
+ end;
+ tmpTr:=tmpTr.beliebigerVorgaenger;
+ end;
+ end;
+ s:=trim(s);
+ beschriftungsschritte[length(beschriftungsschritte)-1].bis:=Qu.exprtofloat(st,erstesArgument(s));
+ if endetMit('+',s) then beschriftungsschritte[length(beschriftungsschritte)-1].faktor:=0.5
+ else if endetMit('-',s) then beschriftungsschritte[length(beschriftungsschritte)-1].faktor:=2
+ else beschriftungsschritte[length(beschriftungsschritte)-1].faktor:=1;
+ beschriftungsschritte[length(beschriftungsschritte)-1].schritte:=strtoint(s);
+ until false;
+ continue;
+ end;
+ if s='Ende' then
+ break;
+ gibAus('Verstehe Option '''+s+''' nicht bei Erzeugund der Legende!',3);
+ exit;
+ until false;
+ if st then begin
+ result:=true;
+ exit;
+ end;
+
+ fontRenderer:=tFontRenderer.create(schriftgroesze);
+
+ gibAus(floattostr(minDichte)+' '+floattostr(maxDichte),1);
+ for i:=0 to length(beschriftungsschritte)-1 do
+ gibAus(inttostr(i)+' '+floattostr(beschriftungsschritte[i].bis)+' '+floattostr(beschriftungsschritte[i].faktor)+' '+inttostr(beschriftungsschritte[i].schritte)+' '+inttostr(byte(beschriftungsschritte[i].linear)),1);
+
+ i:=0;
+ wert:=minDichte;
+ schritt:=-1;
+ while wert<maxDichte do begin
+ if i>0 then gibAus(inttostr(i)+' '+floattostr(wert)+' '+floattostr(schritt)+' '+floattostr(beschriftungsschritte[i].bis),1);
+ if ((i<length(beschriftungsschritte)-1) and (wert>beschriftungsschritte[i].bis)) or (i=0) then begin
+ repeat
+ inc(i);
+ until (i>=length(beschriftungsschritte)-1) or (beschriftungsschritte[i].bis>=wert);
+ if beschriftungsschritte[i].linear then begin
+ schritt:=(beschriftungsschritte[i].bis-beschriftungsschritte[i-1].bis)/beschriftungsschritte[i].schritte;
+ schritt:=power(10,round(ln(schritt)/ln(10)))*beschriftungsschritte[i].faktor;
+ end
+ else
+ schritt:=power(10,floor(ln(wert)/ln(10)-beschriftungsschritte[i].schritte))*beschriftungsschritte[i].faktor;
+ tmp:=round(beschriftungsschritte[i-1].bis/schritt)*schritt;
+ while tmp<wert do tmp:=(round(tmp/schritt)+1)*schritt;
+ wert:=tmp;
+ gibAus(inttostr(i)+' '+floattostr(wert)+' '+floattostr(schritt)+' '+floattostr(beschriftungsschritte[i].bis),1);
+ end;
+ setlength(beschriftungen,length(beschriftungen)+1);
+ beschriftungen[length(beschriftungen)-1]:=tBeschriftung.create;
+ beschriftungen[length(beschriftungen)-1].bBreite:=breite;
+ beschriftungen[length(beschriftungen)-1].bHoehe:=hoehe;
+ beschriftungen[length(beschriftungen)-1].Rahmen:=Rahmen;
+ beschriftungen[length(beschriftungen)-1].fontRend:=fontRenderer;
+ beschriftungen[length(beschriftungen)-1].position:=(wert-minDichte)/(maxDichte-minDichte);
+ beschriftungen[length(beschriftungen)-1].inhalt:=floattostr(wert);
+ if not beschriftungsschritte[i].linear then
+ schritt:=power(10,floor(ln(wert)/ln(10)-beschriftungsschritte[i].schritte))*beschriftungsschritte[i].faktor;
+ wert:=(round(wert/schritt)+1)*schritt;
+ end;
+
+ if lineareFarbe then
+ for i:=0 to length(beschriftungen)-1 do
+ beschriftungen[i].position:=nb.transformiereWert(beschriftungen[i].position);
+ for i:=0 to length(beschriftungen)-1 do
+ beschriftungen[i].position:=beschriftungen[i].position*(hoehe+byte(waagerecht)*(breite-hoehe));
+
+ lo:=Byte(Rahmen);
+ ro:=Byte(Rahmen);
+ oo:=Byte(Rahmen);
+ uo:=Byte(Rahmen);
+ for i:=0 to length(beschriftungen)-1 do begin
+ lo:=max(lo,-beschriftungen[i].links);
+ ro:=max(ro,1+beschriftungen[i].rechts-breite);
+ oo:=max(oo,-beschriftungen[i].oben);
+ uo:=max(uo,1+beschriftungen[i].unten-hoehe);
+ end;
+ if lo+oo+ro+uo>0 then
+ gibAus('Extra-Ränder: '+inttostr(lo)+' Pixel links, '+inttostr(oo)+' Pixel oben, '+inttostr(ro)+' Pixel rechts und '+inttostr(uo)+' Pixel unten.',3);
+
+ setlength(farben,byte(waagerecht)*(breite-hoehe)+hoehe);
+ for i:=0 to length(farben)-1 do begin
+ wert:=i/length(farben);
+ if not lineareFarbe then
+ wert:=nb.transformiereWert(wert);
+ farben[i]:=wertZuFarbe(wert,pal^.farben);
+ end;
+ assign(img,datei);
+ rewrite(img,1);
+ schreibeBmpHeader(img,breite+lo+ro,hoehe+oo+uo);
+ for j:=-oo to hoehe+uo-1 do begin
+ i:=-lo;
+ while i<breite+ro do
+ if waagerecht and (i=0) and (j>=0) and (j<hoehe) then begin
+ blockwrite(img,farben[0],3*breite);
+ i:=breite;
+ end
+ else begin
+ if (i>=0) and (i<breite) and (j>=0) and (j<hoehe) then col:=farben[j]
+ else begin
+ col.rgbRed:=$ff;
+ col.rgbGreen:=$ff;
+ col.rgbBlue:=$ff;
+ if rahmen then begin
+ if ((i=-1) and (j>=-1) and (j<=hoehe)) or
((i=breite) and (j>=-1) and (j<=hoehe)) or
((j=-1) and (i>=-1) and (i<=breite)) or
((j=hoehe) and (i>=-1) and (i<=breite)) then begin
- col.rgbRed:=$00;
- col.rgbGreen:=$00;
- col.rgbBlue:=$00;
- end;
- end;
- for k:=0 to length(Beschriftungen)-1 do
- with Beschriftungen[k] do begin
- if (links<=i) and (rechts>=i) and (oben<=j) and (unten>=j) then
- col:=andFarben(col,bild.farben[i-links + (j-oben)*bild.breite]);
- if ((bBreite<=i) and (i<bBreite+4+byte(Rahmen)) and (lage = lRechts) and (strich=j)) or
+ col.rgbRed:=$00;
+ col.rgbGreen:=$00;
+ col.rgbBlue:=$00;
+ end;
+ end;
+ for k:=0 to length(Beschriftungen)-1 do
+ with Beschriftungen[k] do begin
+ if (links<=i) and (rechts>=i) and (oben<=j) and (unten>=j) then
+ col:=andFarben(col,bild.farben[i-links + (j-oben)*bild.breite]);
+ if ((bBreite<=i) and (i<bBreite+4+byte(Rahmen)) and (lage = lRechts) and (strich=j)) or
((-4<=i+byte(Rahmen)) and (i<0) and (lage = lLinks) and (strich=j)) or
((bHoehe<=j) and (j<bHoehe+4+byte(Rahmen)) and (lage = lOben) and (strich=i)) or
((-4<=j+byte(Rahmen)) and (j<0) and (lage = lUnten) and (strich=i)) then begin
col.rgbRed:=$00;
col.rgbGreen:=$00;
col.rgbBlue:=$00;
- end;
- end;
- end;
- blockwrite(img,col,3);
- inc(i);
- end;
- i:=0;
- blockwrite(img,i,(4-(((breite+lo+ro)*3) mod 4)) mod 4);
- end;
+ end;
+ end;
+ end;
+ blockwrite(img,col,3);
+ inc(i);
+ end;
+ i:=0;
+ blockwrite(img,i,(4-(((breite+lo+ro)*3) mod 4)) mod 4);
+ end;
- for i:=0 to length(beschriftungen)-1 do
- beschriftungen[i].free;
- setlength(beschriftungen,0);
+ for i:=0 to length(beschriftungen)-1 do
+ beschriftungen[i].free;
+ setlength(beschriftungen,0);
- close(img);
- fontRenderer.free;
- result:=true;
+ close(img);
+ fontRenderer.free;
+ result:=true;
end;
function strToFftDo(out fftDo: tFFTDatenordnung; s: string): boolean;
@@ -5822,50 +5958,50 @@ var
i: integer;
istZahl: boolean;
begin
- s:=trimAll(s);
- result:=length(pws^)*byte(s=''); // kleine Abkürzung
- while (result<length(pws^)) and (pws^[result].bezeichner<>s) do
- inc(result);
- if result<length(pws^) then begin // Werte gefunden!
- pws^[result].warteaufBeendigungDesLeseThreads;
- exit;
- end;
+ s:=trimAll(s);
+ result:=length(pws^)*byte(s=''); // kleine Abkürzung
+ while (result<length(pws^)) and (pws^[result].bezeichner<>s) do
+ inc(result);
+ if result<length(pws^) then begin // Werte gefunden!
+ pws^[result].warteaufBeendigungDesLeseThreads;
+ exit;
+ end;
- istZahl:=length(s)>0;
- for i:=1 to length(s) do
- istZahl:=istZahl and (s[i] in ['0'..'9']);
+ istZahl:=length(s)>0;
+ for i:=1 to length(s) do
+ istZahl:=istZahl and (s[i] in ['0'..'9']);
- if istZahl then begin // bei s handelt es sich um den Index selbst
- result:=strtoint(s);
- if (result<0) or (result>=length(pws^)) then begin
- gibAus('Index ('+s+') liegt außerhalb des gültigen Bereichs (0..'+inttostr(length(pws^)-1)+')!',3);
- result:=-1;
- end
- else
- pws^[result].warteaufBeendigungDesLeseThreads;
- exit;
- end;
+ if istZahl then begin // bei s handelt es sich um den Index selbst
+ result:=strtoint(s);
+ if (result<0) or (result>=length(pws^)) then begin
+ gibAus('Index ('+s+') liegt außerhalb des gültigen Bereichs (0..'+inttostr(length(pws^)-1)+')!',3);
+ result:=-1;
+ end
+ else
+ pws^[result].warteaufBeendigungDesLeseThreads;
+ exit;
+ end;
- if not darfErstellen then begin
- gibAus('Ich habe Werte '''+s+''' nicht gefunden und darf sie auch nicht erstellen!',3);
- result:=-1;
- exit;
- end;
+ if not darfErstellen then begin
+ gibAus('Ich habe Werte '''+s+''' nicht gefunden und darf sie auch nicht erstellen!',3);
+ result:=-1;
+ exit;
+ end;
- setlength(pws^,length(pws^)+1);
- pws^[length(pws^)-1]:=tWerte.create(Kont,pws);
- pws^[length(pws^)-1].bezeichner:=s;
+ setlength(pws^,length(pws^)+1);
+ pws^[length(pws^)-1]:=tWerte.create(Kont,pws);
+ pws^[length(pws^)-1].bezeichner:=s;
- i:=f.count-1;
- while (i>=0) and not f.needInLine(s,i) do
- dec(i);
+ i:=f.count-1;
+ while (i>=0) and not f.needInLine(s,i) do
+ dec(i);
- // i ist das letzte Vorkommen von s in f
+ // i ist das letzte Vorkommen von s in f
- if pos('lösche Werte ',f[i])=0 then // wenn es sich um einen Löschbefehl handelt, machen wir nichts
- f.insert(i+1,'lösche Werte '+s); // ansonsten veranlassen wir die Löschung
+ if pos('lösche Werte ',f[i])=0 then // wenn es sich um einen Löschbefehl handelt, machen wir nichts
+ f.insert(i+1,'lösche Werte '+s); // ansonsten veranlassen wir die Löschung
- result:=length(pws^)-1;
+ result:=length(pws^)-1;
end;
function findeKontur(s: String; f: tMyStringlist; pks: pTKonturenArray; darfErstellen: boolean): integer;
@@ -5873,285 +6009,289 @@ var
i: integer;
istZahl: boolean;
begin
- s:=trimAll(s);
- result:=length(pks^)*byte(s=''); // kleine Abkürzung
- while (result<length(pks^)) and (pks^[result].bezeichner<>s) do
- inc(result);
- if result<length(pks^) then exit; // Kontur gefunden!
-
- istZahl:=length(s)>0;
- for i:=1 to length(s) do
- istZahl:=istZahl and (s[i] in ['0'..'9']);
-
- if istZahl then begin // bei s handelt es sich um den Index selbst
- result:=strtoint(s);
- if (result<0) or (result>=length(pks^)) then begin
- gibAus('Index ('+s+') liegt außerhalb des gültigen Bereichs (0..'+inttostr(length(pks^)-1)+')!',3);
- result:=-1;
- end;
- exit;
- end;
+ s:=trimAll(s);
+ result:=length(pks^)*byte(s=''); // kleine Abkürzung
+ while (result<length(pks^)) and (pks^[result].bezeichner<>s) do
+ inc(result);
+ if result<length(pks^) then exit; // Kontur gefunden!
+
+ istZahl:=length(s)>0;
+ for i:=1 to length(s) do
+ istZahl:=istZahl and (s[i] in ['0'..'9']);
+
+ if istZahl then begin // bei s handelt es sich um den Index selbst
+ result:=strtoint(s);
+ if (result<0) or (result>=length(pks^)) then begin
+ gibAus('Index ('+s+') liegt außerhalb des gültigen Bereichs (0..'+inttostr(length(pks^)-1)+')!',3);
+ result:=-1;
+ end;
+ exit;
+ end;
- if not darfErstellen then begin
- gibAus('Ich habe Konturen '''+s+''' nicht gefunden und darf sie auch nicht erstellen!',3);
- result:=-1;
- exit;
- end;
+ if not darfErstellen then begin
+ gibAus('Ich habe Konturen '''+s+''' nicht gefunden und darf sie auch nicht erstellen!',3);
+ result:=-1;
+ exit;
+ end;
- setlength(pks^,length(pks^)+1);
- pks^[length(pks^)-1]:=tKontur.create;
- pks^[length(pks^)-1].bezeichner:=s;
+ setlength(pks^,length(pks^)+1);
+ pks^[length(pks^)-1]:=tKontur.create;
+ pks^[length(pks^)-1].bezeichner:=s;
- i:=f.count-1;
- while (i>=0) and not f.needInLine(s,i) do
- dec(i);
+ i:=f.count-1;
+ while (i>=0) and not f.needInLine(s,i) do
+ dec(i);
- // i ist das letzte Vorkommen von s in f
+ // i ist das letzte Vorkommen von s in f
- if pos('lösche Kontur ',f[i])=0 then // wenn es sich um einen Löschbefehl handelt, machen wir nichts
- f.insert(i+1,'lösche Kontur '+s); // ansonsten veranlassen wir die Löschung
+ if pos('lösche Kontur ',f[i])=0 then // wenn es sich um einen Löschbefehl handelt, machen wir nichts
+ f.insert(i+1,'lösche Kontur '+s); // ansonsten veranlassen wir die Löschung
- result:=length(pks^)-1;
+ result:=length(pks^)-1;
end;
function initBmpHeader(w,h: longint): tBmpHeader;
begin
- With result do begin
- bfType1 := $42;
- bfType2 := $4D;
- bfSize := $36 + ((3*w+3) div 4)*4*h;
- bfReserved1 := $0000;
- bfReserved2 := $0000;
- bfOffBits := $36;
- biSize := $28;
- biWidth := w;
- biHeight := h;
- biPlanes := $0001;
- biBitCount := $0018;
- biCompression := $00000000;
- biSizeImage := ((3*w+3) div 4)*4*h;
- biXPelsPerMeter := $00000000;
- biYPelsPerMeter := $00000000;
- biClrUsed := $00000000;
- biClrImportant := $00000000;
- end;
+ With result do begin
+ bfType1 := $42;
+ bfType2 := $4D;
+ bfSize := $36 + ((3*w+3) div 4)*4*h;
+ bfReserved1 := $0000;
+ bfReserved2 := $0000;
+ bfOffBits := $36;
+ biSize := $28;
+ biWidth := w;
+ biHeight := h;
+ biPlanes := $0001;
+ biBitCount := $0018;
+ biCompression := $00000000;
+ biSizeImage := ((3*w+3) div 4)*4*h;
+ biXPelsPerMeter := $00000000;
+ biYPelsPerMeter := $00000000;
+ biClrUsed := $00000000;
+ biClrImportant := $00000000;
+ end;
end;
procedure schreibeBmpHeader(var f: file; w,h: longint);
-var bmpHeader: tBmpHeader;
+var
+ bmpHeader: tBmpHeader;
begin
- bmpHeader:=initBmpHeader(w,h);
- blockwrite(f,bmpHeader,sizeof(bmpHeader));
+ bmpHeader:=initBmpHeader(w,h);
+ blockwrite(f,bmpHeader,sizeof(bmpHeader));
end;
function neuePalette(var f: tMyStringlist): boolean;
-var s,name: string;
- Palette: tRGBArray;
- i,tmpi: longint;
- nPalette: pTPalette;
-begin
- result:=false;
- setlength(Palette,0);
- name:='';
- nPalette:=nil;
- repeat
- if not f.metaReadln(s,true) then begin
- gibAus('Unerwartetes Dateiende in '''+paramstr(1)+'''!',3);
- exit;
- end;
- if s='Ende' then break;
- if startetMit('Name:',s) then begin
- name:=s;
- findePalette(nPalette,s);
- continue;
- end;
- if (length(s)=6) and (s[1] in ['0'..'9','a'..'f']) and
+var
+ s,name: string;
+ Palette: tRGBArray;
+ i,tmpi: longint;
+ nPalette: pTPalette;
+begin
+ result:=false;
+ setlength(Palette,0);
+ name:='';
+ nPalette:=nil;
+ repeat
+ if not f.metaReadln(s,true) then begin
+ gibAus('Unerwartetes Dateiende in '''+paramstr(1)+'''!',3);
+ exit;
+ end;
+ if s='Ende' then break;
+ if startetMit('Name:',s) then begin
+ name:=s;
+ findePalette(nPalette,s);
+ continue;
+ end;
+ if (length(s)=6) and (s[1] in ['0'..'9','a'..'f']) and
(s[2] in ['0'..'9','a'..'f']) and
(s[3] in ['0'..'9','a'..'f']) and
(s[4] in ['0'..'9','a'..'f']) and
(s[5] in ['0'..'9','a'..'f']) and
(s[6] in ['0'..'9','a'..'f']) then begin
- setlength(Palette,length(Palette)+1);
- tmpi:=0;
- for i:=1 to 6 do begin
- tmpi:=tmpi shl 4;
- if s[i] in ['0'..'9'] then
- tmpi:=tmpi + ord(s[i])-ord('0')
- else
- tmpi:=tmpi + ord(s[i])-ord('a')+10;
- end;
- Palette[length(Palette)-1].rgbRed:= tmpi and $0000ff;
- Palette[length(Palette)-1].rgbGreen:=(tmpi and $00ff00) shr 8;
- Palette[length(Palette)-1].rgbBlue:= (tmpi and $ff0000) shr 16;
- continue;
- end;
- gibAus(''''+s+''' ist keine Farbe für eine Palette!',3);
- exit;
- until false;
- if name='' then begin
- gibAus('Die Palette braucht einen Namen!',3);
- exit;
- end;
- if length(Palette)<2 then begin
- gibAus('Zu wenige Farben in der Palette '''+name+''', nämlich nur '+inttostr(length(Palette)),3);
- exit;
- end;
- if nPalette=nil then begin
- setlength(Paletten,length(Paletten)+1);
- nPalette:=@(Paletten[length(Paletten)-1]);
- end;
- nPalette^.name:=name;
- setlength(nPalette^.farben,length(Palette));
- for i:=0 to length(Palette)-1 do
- nPalette^.farben[i]:=Palette[i];
- gibAus('Neue Palette '''+nPalette^.name+''' erstellt!',3);
- result:=true;
+ setlength(Palette,length(Palette)+1);
+ tmpi:=0;
+ for i:=1 to 6 do begin
+ tmpi:=tmpi shl 4;
+ if s[i] in ['0'..'9'] then
+ tmpi:=tmpi + ord(s[i])-ord('0')
+ else
+ tmpi:=tmpi + ord(s[i])-ord('a')+10;
+ end;
+ Palette[length(Palette)-1].rgbRed:= tmpi and $0000ff;
+ Palette[length(Palette)-1].rgbGreen:=(tmpi and $00ff00) shr 8;
+ Palette[length(Palette)-1].rgbBlue:= (tmpi and $ff0000) shr 16;
+ continue;
+ end;
+ gibAus(''''+s+''' ist keine Farbe für eine Palette!',3);
+ exit;
+ until false;
+ if name='' then begin
+ gibAus('Die Palette braucht einen Namen!',3);
+ exit;
+ end;
+ if length(Palette)<2 then begin
+ gibAus('Zu wenige Farben in der Palette '''+name+''', nämlich nur '+inttostr(length(Palette)),3);
+ exit;
+ end;
+ if nPalette=nil then begin
+ setlength(Paletten,length(Paletten)+1);
+ nPalette:=@(Paletten[length(Paletten)-1]);
+ end;
+ nPalette^.name:=name;
+ setlength(nPalette^.farben,length(Palette));
+ for i:=0 to length(Palette)-1 do
+ nPalette^.farben[i]:=Palette[i];
+ gibAus('Neue Palette '''+nPalette^.name+''' erstellt!',3);
+ result:=true;
end;
function externerBefehl(st: boolean; s: string): boolean;
-var bt: tBefehlThread;
+var
+ bt: tBefehlThread;
begin
- bt:=tBefehlThread.create(st,s,result);
- if st then begin
+ bt:=tBefehlThread.create(st,s,result);
+ if st then begin
// bt.free;
- exit;
- end;
- if not result then begin
- try
- bt.free;
- except
- end;
- exit;
- end;
- bt.suspended:=false;
- gibAus('Befehl gestartet.',3);
- if bt.bg then begin
- setlength(externeBefehle,length(externeBefehle)+1);
- externeBefehle[length(externeBefehle)-1]:=bt;
- exit; // Job läuft im Hintergrund weiter!
- end;
- while not bt.fertig do
- sleep(10);
- bt.free;
+ exit;
+ end;
+ if not result then begin
+ try
+ bt.free;
+ except
+ end;
+ exit;
+ end;
+ bt.suspended:=false;
+ gibAus('Befehl gestartet.',3);
+ if bt.bg then begin
+ setlength(externeBefehle,length(externeBefehle)+1);
+ externeBefehle[length(externeBefehle)-1]:=bt;
+ exit; // Job läuft im Hintergrund weiter!
+ end;
+ while not bt.fertig do
+ sleep(10);
+ bt.free;
end;
procedure warte_auf_externeBefehle;
-var i: longint;
- b,c: boolean;
-begin
- c:=true;
- repeat
- b:=false;
- for i:=0 to length(externeBefehle)-1 do
- b:=b or (assigned(externeBefehle[i]) and not externeBefehle[i].fertig);
- if b then begin
- if c then gibAus('Warte auf Beendigung externer Befehle ...',3);
- c:=false;
- sleep(10);
- end;
- until not b;
- if not c then
- gibAus('... alle externen Befehle fertig.',3);
- for i:=0 to length(externeBefehle)-1 do
- if assigned(externeBefehle[i]) then externeBefehle[i].free;
- setlength(externeBefehle,0);
+var
+ i: longint;
+ b,c: boolean;
+begin
+ c:=true;
+ repeat
+ b:=false;
+ for i:=0 to length(externeBefehle)-1 do
+ b:=b or (assigned(externeBefehle[i]) and not externeBefehle[i].fertig);
+ if b then begin
+ if c then gibAus('Warte auf Beendigung externer Befehle ...',3);
+ c:=false;
+ sleep(10);
+ end;
+ until not b;
+ if not c then
+ gibAus('... alle externen Befehle fertig.',3);
+ for i:=0 to length(externeBefehle)-1 do
+ if assigned(externeBefehle[i]) then externeBefehle[i].free;
+ setlength(externeBefehle,0);
end;
procedure beendeExterneBefehleWennFertig;
var
i,j: longint;
begin
- for i:=length(externeBefehle)-1 downto 0 do
- if assigned(externeBefehle) then
- if externeBefehle[i].fertig then begin
- externeBefehle[i].free;
- for j:=i+1 to length(externeBefehle)-1 do
- externeBefehle[j-1]:=externeBefehle[j];
- setlength(externeBefehle,length(externeBefehle)-1);
- end;
-end;
-
-begin
- setlength(externeBefehle,0);
-
- setlength(Paletten,5);
- Paletten[0].name:='Graustufen';
- setlength(Paletten[0].farben,2);
- Paletten[0].farben[0].rgbRed:= $ff;
- Paletten[0].farben[0].rgbGreen:=$ff;
- Paletten[0].farben[0].rgbBlue:= $ff;
- Paletten[0].farben[1].rgbRed:= $00;
- Paletten[0].farben[1].rgbGreen:=$00;
- Paletten[0].farben[1].rgbBlue:= $00;
-
- Paletten[1].name:='invertierte Graustufen';
- setlength(Paletten[1].farben,2);
- Paletten[1].farben[0].rgbRed:= $00;
- Paletten[1].farben[0].rgbGreen:=$00;
- Paletten[1].farben[0].rgbBlue:= $00;
- Paletten[1].farben[1].rgbRed:= $ff;
- Paletten[1].farben[1].rgbGreen:=$ff;
- Paletten[1].farben[1].rgbBlue:= $ff;
-
- Paletten[2].name:='Regenbogen';
- setlength(Paletten[2].farben,6);
- Paletten[2].farben[0].rgbRed:= $00;
- Paletten[2].farben[0].rgbGreen:=$00;
- Paletten[2].farben[0].rgbBlue:= $ff;
- Paletten[2].farben[1].rgbRed:= $00;
- Paletten[2].farben[1].rgbGreen:=$ff;
- Paletten[2].farben[1].rgbBlue:= $ff;
- Paletten[2].farben[2].rgbRed:= $00;
- Paletten[2].farben[2].rgbGreen:=$ff;
- Paletten[2].farben[2].rgbBlue:= $00;
- Paletten[2].farben[3].rgbRed:= $ff;
- Paletten[2].farben[3].rgbGreen:=$ff;
- Paletten[2].farben[3].rgbBlue:= $00;
- Paletten[2].farben[4].rgbRed:= $ff;
- Paletten[2].farben[4].rgbGreen:=$00;
- Paletten[2].farben[4].rgbBlue:= $00;
- Paletten[2].farben[5].rgbRed:= $00;
- Paletten[2].farben[5].rgbGreen:=$00;
- Paletten[2].farben[5].rgbBlue:= $00;
-
- Paletten[3].name:='invertierter Regenbogen';
- setlength(Paletten[3].farben,6);
- Paletten[3].farben[0].rgbRed:= $00;
- Paletten[3].farben[0].rgbGreen:=$00;
- Paletten[3].farben[0].rgbBlue:= $00;
- Paletten[3].farben[1].rgbRed:= $ff;
- Paletten[3].farben[1].rgbGreen:=$00;
- Paletten[3].farben[1].rgbBlue:= $00;
- Paletten[3].farben[2].rgbRed:= $ff;
- Paletten[3].farben[2].rgbGreen:=$ff;
- Paletten[3].farben[2].rgbBlue:= $00;
- Paletten[3].farben[3].rgbRed:= $00;
- Paletten[3].farben[3].rgbGreen:=$ff;
- Paletten[3].farben[3].rgbBlue:= $00;
- Paletten[3].farben[4].rgbRed:= $00;
- Paletten[3].farben[4].rgbGreen:=$ff;
- Paletten[3].farben[4].rgbBlue:= $ff;
- Paletten[3].farben[5].rgbRed:= $00;
- Paletten[3].farben[5].rgbGreen:=$00;
- Paletten[3].farben[5].rgbBlue:= $ff;
-
- Paletten[4].name:='Jet-Regenbogen';
- setlength(Paletten[4].farben,5);
- Paletten[4].farben[0].rgbRed:= $ff;
- Paletten[4].farben[0].rgbGreen:=$00;
- Paletten[4].farben[0].rgbBlue:= $00;
- Paletten[4].farben[1].rgbRed:= $ff;
- Paletten[4].farben[1].rgbGreen:=$ff;
- Paletten[4].farben[1].rgbBlue:= $00;
- Paletten[4].farben[2].rgbRed:= $00;
- Paletten[4].farben[2].rgbGreen:=$ff;
- Paletten[4].farben[2].rgbBlue:= $00;
- Paletten[4].farben[3].rgbRed:= $00;
- Paletten[4].farben[3].rgbGreen:=$ff;
- Paletten[4].farben[3].rgbBlue:= $ff;
- Paletten[4].farben[4].rgbRed:= $00;
- Paletten[4].farben[4].rgbGreen:=$00;
- Paletten[4].farben[4].rgbBlue:= $ff;
+ for i:=length(externeBefehle)-1 downto 0 do
+ if assigned(externeBefehle) then
+ if externeBefehle[i].fertig then begin
+ externeBefehle[i].free;
+ for j:=i+1 to length(externeBefehle)-1 do
+ externeBefehle[j-1]:=externeBefehle[j];
+ setlength(externeBefehle,length(externeBefehle)-1);
+ end;
+end;
+
+begin
+ setlength(externeBefehle,0);
+
+ setlength(Paletten,5);
+ Paletten[0].name:='Graustufen';
+ setlength(Paletten[0].farben,2);
+ Paletten[0].farben[0].rgbRed:= $ff;
+ Paletten[0].farben[0].rgbGreen:=$ff;
+ Paletten[0].farben[0].rgbBlue:= $ff;
+ Paletten[0].farben[1].rgbRed:= $00;
+ Paletten[0].farben[1].rgbGreen:=$00;
+ Paletten[0].farben[1].rgbBlue:= $00;
+
+ Paletten[1].name:='invertierte Graustufen';
+ setlength(Paletten[1].farben,2);
+ Paletten[1].farben[0].rgbRed:= $00;
+ Paletten[1].farben[0].rgbGreen:=$00;
+ Paletten[1].farben[0].rgbBlue:= $00;
+ Paletten[1].farben[1].rgbRed:= $ff;
+ Paletten[1].farben[1].rgbGreen:=$ff;
+ Paletten[1].farben[1].rgbBlue:= $ff;
+
+ Paletten[2].name:='Regenbogen';
+ setlength(Paletten[2].farben,6);
+ Paletten[2].farben[0].rgbRed:= $00;
+ Paletten[2].farben[0].rgbGreen:=$00;
+ Paletten[2].farben[0].rgbBlue:= $ff;
+ Paletten[2].farben[1].rgbRed:= $00;
+ Paletten[2].farben[1].rgbGreen:=$ff;
+ Paletten[2].farben[1].rgbBlue:= $ff;
+ Paletten[2].farben[2].rgbRed:= $00;
+ Paletten[2].farben[2].rgbGreen:=$ff;
+ Paletten[2].farben[2].rgbBlue:= $00;
+ Paletten[2].farben[3].rgbRed:= $ff;
+ Paletten[2].farben[3].rgbGreen:=$ff;
+ Paletten[2].farben[3].rgbBlue:= $00;
+ Paletten[2].farben[4].rgbRed:= $ff;
+ Paletten[2].farben[4].rgbGreen:=$00;
+ Paletten[2].farben[4].rgbBlue:= $00;
+ Paletten[2].farben[5].rgbRed:= $00;
+ Paletten[2].farben[5].rgbGreen:=$00;
+ Paletten[2].farben[5].rgbBlue:= $00;
+
+ Paletten[3].name:='invertierter Regenbogen';
+ setlength(Paletten[3].farben,6);
+ Paletten[3].farben[0].rgbRed:= $00;
+ Paletten[3].farben[0].rgbGreen:=$00;
+ Paletten[3].farben[0].rgbBlue:= $00;
+ Paletten[3].farben[1].rgbRed:= $ff;
+ Paletten[3].farben[1].rgbGreen:=$00;
+ Paletten[3].farben[1].rgbBlue:= $00;
+ Paletten[3].farben[2].rgbRed:= $ff;
+ Paletten[3].farben[2].rgbGreen:=$ff;
+ Paletten[3].farben[2].rgbBlue:= $00;
+ Paletten[3].farben[3].rgbRed:= $00;
+ Paletten[3].farben[3].rgbGreen:=$ff;
+ Paletten[3].farben[3].rgbBlue:= $00;
+ Paletten[3].farben[4].rgbRed:= $00;
+ Paletten[3].farben[4].rgbGreen:=$ff;
+ Paletten[3].farben[4].rgbBlue:= $ff;
+ Paletten[3].farben[5].rgbRed:= $00;
+ Paletten[3].farben[5].rgbGreen:=$00;
+ Paletten[3].farben[5].rgbBlue:= $ff;
+
+ Paletten[4].name:='Jet-Regenbogen';
+ setlength(Paletten[4].farben,5);
+ Paletten[4].farben[0].rgbRed:= $ff;
+ Paletten[4].farben[0].rgbGreen:=$00;
+ Paletten[4].farben[0].rgbBlue:= $00;
+ Paletten[4].farben[1].rgbRed:= $ff;
+ Paletten[4].farben[1].rgbGreen:=$ff;
+ Paletten[4].farben[1].rgbBlue:= $00;
+ Paletten[4].farben[2].rgbRed:= $00;
+ Paletten[4].farben[2].rgbGreen:=$ff;
+ Paletten[4].farben[2].rgbBlue:= $00;
+ Paletten[4].farben[3].rgbRed:= $00;
+ Paletten[4].farben[3].rgbGreen:=$ff;
+ Paletten[4].farben[3].rgbBlue:= $ff;
+ Paletten[4].farben[4].rgbRed:= $00;
+ Paletten[4].farben[4].rgbGreen:=$00;
+ Paletten[4].farben[4].rgbBlue:= $ff;
end.
diff --git a/typenunit.pas b/typenunit.pas
index 974090e..54c98cf 100644
--- a/typenunit.pas
+++ b/typenunit.pas
@@ -199,11 +199,11 @@ type
end;
tBeschriftungen = array of tBeschriftung;
tWaveletTyp = (wtSin2,wtFrequenzfenster);
- tTransformationen = class;
+ tTransformation = class;
tExtraInfos = class
maxW,minW,np,beta: extended;
tsiz,xsteps,tsiz_,xsteps_: longint;
- transformationen: tTransformationen;
+ transformationen: tTransformation;
knownValues: tKnownValues;
constructor create;
destructor destroy; override;
@@ -213,24 +213,98 @@ type
function tstop: extended;
procedure refreshKnownValues;
end;
+ tTransformationArray = array of tTransformation;
tTransformation = class
// eine generische Transformation von Werten oder Koordinaten
// selbst nicht zum Instanziieren gedacht
private
+ vorgaenger,nachfolger: array of tTransformation;
+ in_xs_ts,out_xs_ts: tIntPoint;
+ in_achsen,out_achsen: t2x2Extended;
+ out_wmia: tExtPoint;
+ wmiaExplizit: boolean;
+
procedure testeAuszerhalb(const p: tExtPoint);
+ procedure aktualisiereAchsen; virtual; // nicht zum direkten Aufrufen
+ procedure aktualisiereXsTs; virtual; // nicht zum direkten Aufrufen
+ procedure aktualisiereWmia; virtual; // nicht zum direkten Aufrufen
+
+ function transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint; virtual;
+ // wie ändert sich die Position eines Punktes (Paradebeispiel: bei Spiegelung: x -> xsteps-1-x)
+ // ist für p veranwortlich?
+ function transformiereWertEinzeln(const x: extended): extended; virtual;
+ // wie ändert sich ein Wert
+
+ function rXstart: extended;
+ procedure wXstart(x: extended);
+ function rXstop: extended;
+ procedure wXstop(x: extended);
+ function rTstart: extended;
+ procedure wTstart(t: extended);
+ function rTstop: extended;
+ procedure wTstop(t: extended);
+ function rWmin: extended;
+ procedure wWmin(w: extended);
+ function rWmax: extended;
+ procedure wWmax(w: extended);
+ function rXsteps: longint;
+ procedure wXsteps(x: longint);
+ function rTsiz: longint;
+ procedure wTsiz(t: longint);
public
- in_xs_ts: tIntPoint;
- in_achsen: t2x2Extended;
- function achsen: t2x2Extended; virtual;
- // wie ändern sich xstart,xstop,tstart,tstop?
- function transformiereKoordinaten(const x,y: longint): tExtPoint; overload;
- function transformiereKoordinaten(const p: tExtPoint): tExtPoint; virtual; overload;
- // wie ändert sich die Position eines Punktes (Paradebeispiel: bei Spiegelung: x -> xsteps-1-x)
- function transformiereWert(const x: extended): extended; virtual;
- // wie ändert sich ein Wert
- function xsteps_tsiz: tIntPoint; virtual;
- // wie ändert sich die Ausdehnung?
- function dumpParams: string; virtual;
+ constructor create;
+ destructor destroy; override;
+ destructor freeAll;
+
+ procedure fuegeNachfolgerHinzu(tr: tTransformation);
+ procedure loescheNachfolger(tr: tTransformation);
+ procedure fuegeVorgaengerHinzu(tr: tTransformation);
+ procedure loescheVorgaenger(tr: tTransformation);
+ function hatNachfolger: boolean;
+ procedure aktualisiereAlles; // (inkl. Informieren der Nachfolger)
+ function ersetzeAnfangDurch(tr: tTransformation): boolean;
+ function beliebigerVorgaenger: tTransformation;
+
+ property achsen: t2x2Extended read out_achsen;
+ // wie lauten xstart,xstop,tstart,tstop?
+ function transformiereKoordinaten(const p: tExtPoint; const tiefe: longint = -1): tExtPoint; overload;
+ function transformiereKoordinaten(const x,y: longint; const tiefe: longint = -1): tExtPoint; overload;
+ function wertZuPositionAufAchse(const l: tLage; x: extended): extended; virtual;
+ function transformiereWert(const x: extended; const tiefe: longint = -1): extended;
+ property xsteps_tsiz: tIntPoint read out_xs_ts;
+ function dumpParams: string; virtual; overload;
+ function dumpParams(tiefe: longint): string; overload;
+ property xstart: extended
+ read rXstart
+ write wXstart;
+ property xstop: extended
+ read rXstop
+ write wXstop;
+ property tstart: extended
+ read rTstart
+ write wTstart;
+ property tstop: extended
+ read rTstop
+ write wTstop;
+ property wmin: extended
+ read rWmin
+ write wWmin;
+ property wmax: extended
+ read rWmax
+ write wWmax;
+ property xsteps: longint
+ read rXsteps
+ write wXsteps;
+ property tsiz: longint
+ read rTsiz
+ write wTsiz;
+ end;
+ tKeineTransformation = class (tTransformation)
+ // der Beginn einer Transformationskette, z.B. das Laden von Daten
+ end;
+ tUeberlagerung = class (tTransformation)
+ // die Überlagerung mehrer gleichformatiger Daten, z.B. Linearkombination
+ procedure addKomponente(tr: tTransformation);
end;
tKoordinatenTransformation = class (tTransformation)
// eine generische Transformation der Koordinaten
@@ -240,15 +314,16 @@ type
// repräsentiert die Transformation der Koordinaten bei einer FFT
horizontal,vertikal: boolean;
constructor create; overload;
- constructor create(original: tFFTTransformation); overload;
- function achsen: t2x2Extended; override;
+ constructor create(vorg: tTransformation; hor,ver: boolean);
+ procedure aktualisiereAchsen; override;
// keine Änderung der Positionen, der Werte(skalierung), der Ausdehnung
function dumpParams: string; override;
end;
tSpiegelungsTransformation = class (tKoordinatenTransformation)
// repräsentiert die horizontale Spiegelung der Koordinaten
constructor create;
- function transformiereKoordinaten(const p: tExtPoint): tExtPoint; override; overload;
+ constructor create(vorg: tTransformation);
+ function transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint; override; overload;
// keine Änderung der Achsenbegrenzungen, der Werte(skalierung), der Ausdehnung
function dumpParams: string; override;
end;
@@ -265,34 +340,32 @@ type
lnOff, // Offset der ln-Argumente
expFak: tExtPoint; // Vorfaktoren der Exponentialfunktionen
constructor create; overload;
- constructor create(original: tKonkreteKoordinatenTransformation); overload;
- function transformiereKoordinaten(const p: tExtPoint): tExtPoint; override; overload;
+ function transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint; override; overload;
function initAbbildung(syntaxtest: boolean; s: string; xscale,yscale: extended; etf: tExprToFloat): boolean;
function zielausdehnung: t2x2Longint;
- function xsteps_tsiz: tIntPoint; override;
+ procedure aktualisiereXsTs; override;
// keine Änderung der Achsenbegrenzungen, der Werte(skalierung)
function dumpParams: string; override;
end;
tKoordinatenAusschnitt = class (tKoordinatenTransformation)
gr: t2x2Longint;
constructor create; overload;
- constructor create(original: tKoordinatenAusschnitt); overload;
- function xsteps_tsiz: tIntPoint; override;
- function achsen: t2x2Extended; override;
- function transformiereKoordinaten(const p: tExtPoint): tExtPoint; override; overload;
+ constructor create(vorg: tTransformation; xmin,xmax,tmin,tmax: longint); overload;
+ procedure aktualisiereXsTs; override;
+ procedure aktualisiereAchsen; override;
+ function transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint; override; overload;
// keine Änderung der Werte(skalierung)
function dumpParams: string; override;
end;
tAgglomeration = class (tKoordinatenTransformation)
schritt: extended;
- anzahl: longint;
horizontal: boolean;
constructor create; overload;
- constructor create(original: tAgglomeration); overload;
- function xsteps_tsiz: tIntPoint; override;
- function achsen: t2x2Extended; override;
- function transformiereKoordinaten(const p: tExtPoint): tExtPoint; override; overload;
+ procedure addKomponente(tr: tTransformation);
+ procedure aktualisiereXsTs; override;
+ procedure aktualisiereAchsen; override;
// keine Änderung der Werte(skalierung)
+ function wertZuPositionAufAchse(const l: tLage; x: extended): extended; override;
function dumpParams: string; override;
end;
tBearbeitungstyp = (btUnbekannt,btKnick,btLog,btAbsLog,btAbs);
@@ -304,9 +377,8 @@ type
// Werte knicken
parameter: tExtendedArray;
constructor create; overload;
- constructor create(original: tWerteKnickTransformation); overload;
destructor destroy; override;
- function transformiereWert(const x: extended): extended; override;
+ function transformiereWertEinzeln(const x: extended): extended; override;
// keine Änderung der Achsenbegrenzungen, der Positionen, der Ausdehnung
function dumpParams: string; override;
end;
@@ -314,8 +386,7 @@ type
// Werte logarithmieren
logMin: extended;
constructor create; overload;
- constructor create(original: tWerteLogTransformation); overload;
- function transformiereWert(const x: extended): extended; override;
+ function transformiereWertEinzeln(const x: extended): extended; override;
// keine Änderung der Achsenbegrenzungen, der Positionen, der Ausdehnung
function dumpParams: string; override;
end;
@@ -323,19 +394,18 @@ type
// Wertebeträge logarithmieren
logSkala: extended;
constructor create; overload;
- constructor create(original: tWerteLogAbsTransformation); overload;
- function transformiereWert(const x: extended): extended; override;
+ function transformiereWertEinzeln(const x: extended): extended; override;
// keine Änderung der Achsenbegrenzungen, der Positionen, der Ausdehnung
function dumpParams: string; override;
end;
tWerteAbsTransformation = class (tWerteTransformation)
// Werte betragen
constructor create;
- function transformiereWert(const x: extended): extended; override;
+ function transformiereWertEinzeln(const x: extended): extended; override;
// keine Änderung der Achsenbegrenzungen, der Positionen, der Ausdehnung
function dumpParams: string; override;
end;
- tTransformationen = class
+(* tTransformationen = class
private
// merkt sich, was mit den Werten und Koordinaten nach einem festen Punkt (dem Einlesen) passiert ist,
// sodass man immer nachvollziehen kann, welcher Punkt woher kam und wie verarbeitet wurde.
@@ -346,50 +416,9 @@ type
_xs_ts: tIntPoint;
function gibInhalt(ii: longint): tTransformation;
procedure nimmInhalt(ii: longint; inh: tTransformation);
- function rXstart: extended;
- procedure wXstart(x: extended);
- function rXstop: extended;
- procedure wXstop(x: extended);
- function rTstart: extended;
- procedure wTstart(t: extended);
- function rTstop: extended;
- procedure wTstop(t: extended);
- function rWmin: extended;
- procedure wWmin(w: extended);
- function rWmax: extended;
- procedure wWmax(w: extended);
- function rXsteps: longint;
- procedure wXsteps(x: longint);
- function rTsiz: longint;
- procedure wTsiz(t: longint);
- function xsteps_tsiz: tIntPoint;
function gibAchsen: t2x2Extended;
procedure achsenUndGroeszeAktualisieren;
public
- property xstart: extended
- read rXstart
- write wXstart;
- property xstop: extended
- read rXstop
- write wXstop;
- property tstart: extended
- read rTstart
- write wTstart;
- property tstop: extended
- read rTstop
- write wTstop;
- property wmin: extended
- read rWmin
- write wWmin;
- property wmax: extended
- read rWmax
- write wWmax;
- property xsteps: longint
- read rXsteps
- write wXsteps;
- property tsiz: longint
- read rTsiz
- write wTsiz;
property inhalt[ii: longint]: tTransformation
read gibInhalt
write nimmInhalt; default;
@@ -418,7 +447,9 @@ type
function dumpParams: string;
procedure berechneZielausdehnung(out grenzen: t2x2Longint);
end;
- tTransformationenArray = array of tTransformationen;
+ tTransformationenArray = array of tTransformationen; *)
+
+function liesTWerteTransformationen(st: boolean; s: string; f: tMyStringlist; etf: tExprToFloat; var tr: tTransformation): boolean;
implementation
@@ -426,409 +457,410 @@ implementation
constructor tGenerischeInputDateiInfo.create(Vorlage: tGenerischeInputDateiInfo);
begin
- inherited create;
- fillchar(Name,sizeof(Name),#0);
- Name:=Vorlage.Name;
- fillchar(Fehlerbehebungskommando,sizeof(Fehlerbehebungskommando),#0);
- Fehlerbehebungskommando:=Vorlage.Fehlerbehebungskommando;
- gamma:=Vorlage.gamma;
- groeszenFaktor:=Vorlage.groeszenFaktor;
- Genauigkeit:=Vorlage.Genauigkeit;
- tsiz:=Vorlage.tsiz;
- xsteps:=Vorlage.xsteps;
- tstart:=Vorlage.tstart;
- tstop:=Vorlage.tstop;
- xstart:=Vorlage.xstart;
- xstop:=Vorlage.xstop;
- params:=Vorlage.params;
- t0abs:=Vorlage.t0abs;
+ inherited create;
+ fillchar(Name,sizeof(Name),#0);
+ Name:=Vorlage.Name;
+ fillchar(Fehlerbehebungskommando,sizeof(Fehlerbehebungskommando),#0);
+ Fehlerbehebungskommando:=Vorlage.Fehlerbehebungskommando;
+ gamma:=Vorlage.gamma;
+ groeszenFaktor:=Vorlage.groeszenFaktor;
+ Genauigkeit:=Vorlage.Genauigkeit;
+ tsiz:=Vorlage.tsiz;
+ xsteps:=Vorlage.xsteps;
+ tstart:=Vorlage.tstart;
+ tstop:=Vorlage.tstop;
+ xstart:=Vorlage.xstart;
+ xstop:=Vorlage.xstop;
+ params:=Vorlage.params;
+ t0abs:=Vorlage.t0abs;
end;
constructor tGenerischeInputDateiInfo.create;
begin
- inherited create;
- fillchar(Name,sizeof(Name),#0);
- Name:='';
- fillchar(Fehlerbehebungskommando,sizeof(Fehlerbehebungskommando),#0);
- Fehlerbehebungskommando:='';
- gamma:=1;
- groeszenFaktor:=1;
- Genauigkeit:=gSingle;
- tsiz:=-1;
- t0abs:=-1;
- xsteps:=-1;
- tstart:=-myInf;
- tstop:=myInf;
- xstart:=-myInf;
- xstop:=myInf;
- params:=nil;
+ inherited create;
+ fillchar(Name,sizeof(Name),#0);
+ Name:='';
+ fillchar(Fehlerbehebungskommando,sizeof(Fehlerbehebungskommando),#0);
+ Fehlerbehebungskommando:='';
+ gamma:=1;
+ groeszenFaktor:=1;
+ Genauigkeit:=gSingle;
+ tsiz:=-1;
+ t0abs:=-1;
+ xsteps:=-1;
+ tstart:=-myInf;
+ tstop:=myInf;
+ xstart:=-myInf;
+ xstop:=myInf;
+ params:=nil;
end;
destructor tGenerischeInputDateiInfo.destroy;
begin
- Name:='';
- Fehlerbehebungskommando:='';
- inherited destroy;
+ Name:='';
+ Fehlerbehebungskommando:='';
+ inherited destroy;
end;
function tGenerischeInputDateiInfo.xmin: longint;
begin
- result:=0;
- if assigned(params) and (params.xsteps>1) and (xstart > params.xstart + result/(params.xsteps-1)*(params.xstop-params.xstart)) then
- result:=min(xsteps-1,round((xstart-params.xstart)/(params.xstop-params.xstart)/(params.xsteps-1)));
+ result:=0;
+ if assigned(params) and (params.xsteps>1) and (xstart > params.xstart + result/(params.xsteps-1)*(params.xstop-params.xstart)) then
+ result:=min(xsteps-1,round((xstart-params.xstart)/(params.xstop-params.xstart)/(params.xsteps-1)));
end;
function tGenerischeInputDateiInfo.xmax: longint;
begin
- result:=xsteps-1;
- if assigned(params) and (params.xsteps>1) and (xstop < params.xstart + result/(params.xsteps-1)*(params.xstop-params.xstart)) then
- result:=max(0,round((xstop-params.xstart)/(params.xstop-params.xstart)/(params.xsteps-1)));
+ result:=xsteps-1;
+ if assigned(params) and (params.xsteps>1) and (xstop < params.xstart + result/(params.xsteps-1)*(params.xstop-params.xstart)) then
+ result:=max(0,round((xstop-params.xstart)/(params.xstop-params.xstart)/(params.xsteps-1)));
end;
function tGenerischeInputDateiInfo.tmin: longint;
begin
- result:=t0abs;
- if assigned(params) and (params.tsiz>1) and (tstart > params.tstart + result/(params.tsiz-1)*(params.tstop-params.tstart)) then
- result:=round((tstart-params.tstart)/(params.tstop-params.tstart)/(params.tsiz-1));
- result:=min(tsiz-1,max(0,result-t0abs));
+ result:=t0abs;
+ if assigned(params) and (params.tsiz>1) and (tstart > params.tstart + result/(params.tsiz-1)*(params.tstop-params.tstart)) then
+ result:=round((tstart-params.tstart)/(params.tstop-params.tstart)/(params.tsiz-1));
+ result:=min(tsiz-1,max(0,result-t0abs));
end;
function tGenerischeInputDateiInfo.tmax: longint;
begin
- result:=t0abs+tsiz-1;
- if assigned(params) and (params.tsiz>1) and (tstop < params.tstart + result/(params.tsiz-1)*(params.tstop-params.tstart)) then
- result:=round((tstop-params.tstart)/(params.tstop-params.tstart)/(params.tsiz-1));
- result:=min(tsiz-1,max(0,result-t0abs));
+ result:=t0abs+tsiz-1;
+ if assigned(params) and (params.tsiz>1) and (tstop < params.tstart + result/(params.tsiz-1)*(params.tstop-params.tstart)) then
+ result:=round((tstop-params.tstart)/(params.tstop-params.tstart)/(params.tsiz-1));
+ result:=min(tsiz-1,max(0,result-t0abs));
end;
// tPhaseSpaceInputDateiInfo ****************************************************
constructor tPhaseSpaceInputDateiInfo.create(Vorlage: tGenerischeInputDateiInfo);
begin
- inherited create(Vorlage);
+ inherited create(Vorlage);
end;
constructor tPhaseSpaceInputDateiInfo.create;
begin
- inherited create;
+ inherited create;
end;
destructor tPhaseSpaceInputDateiInfo.destroy;
begin
- inherited destroy;
+ inherited destroy;
end;
// tSpaceTimeInputDateiInfo ****************************************************
constructor tSpaceTimeInputDateiInfo.create(Vorlage: tGenerischeInputDateiInfo);
begin
- inherited create(Vorlage);
+ inherited create(Vorlage);
end;
constructor tSpaceTimeInputDateiInfo.create;
begin
- inherited create;
+ inherited create;
end;
destructor tSpaceTimeInputDateiInfo.destroy;
begin
- inherited destroy;
+ inherited destroy;
end;
// tTraceInputDateiInfo ********************************************************
constructor tTraceInputDateiInfo.create(Vorlage: tGenerischeInputDateiInfo);
begin
- inherited create(Vorlage);
- if Vorlage is tTraceInputDateiInfo then begin
- Spurnummer:=(Vorlage as tTraceInputDateiInfo).Spurnummer;
- FeldNummer:=(Vorlage as tTraceInputDateiInfo).FeldNummer;
- end
- else begin
- Spurnummer:=0;
- FeldNummer:=0;
- end;
+ inherited create(Vorlage);
+ if Vorlage is tTraceInputDateiInfo then begin
+ Spurnummer:=(Vorlage as tTraceInputDateiInfo).Spurnummer;
+ FeldNummer:=(Vorlage as tTraceInputDateiInfo).FeldNummer;
+ end
+ else begin
+ Spurnummer:=0;
+ FeldNummer:=0;
+ end;
end;
constructor tTraceInputDateiInfo.create;
begin
- inherited create;
- Spurnummer:=0;
- FeldNummer:=0;
+ inherited create;
+ Spurnummer:=0;
+ FeldNummer:=0;
end;
destructor tTraceInputDateiInfo.destroy;
begin
- inherited destroy;
+ inherited destroy;
end;
// tPipeInputDateiInfo *********************************************************
constructor tPipeInputDateiInfo.create(Vorlage: tGenerischeInputDateiInfo);
begin
- inherited create(Vorlage);
- fillchar(Analysator,sizeof(Analysator),#0);
- if Vorlage is tPipeInputDateiInfo then begin
- Analysator:=(Vorlage as tPipeInputDateiInfo).Analysator;
- bytesPerSample:=(Vorlage as tPipeInputDateiInfo).bytesPerSample;
- Kodierung:=(Vorlage as tPipeInputDateiInfo).Kodierung;
- end
- else begin
- Analysator:='/usr/bin/soxi -';
- bytesPerSample:=-1;
- Kodierung:=kUnbekannt;
- end;
+ inherited create(Vorlage);
+ fillchar(Analysator,sizeof(Analysator),#0);
+ if Vorlage is tPipeInputDateiInfo then begin
+ Analysator:=(Vorlage as tPipeInputDateiInfo).Analysator;
+ bytesPerSample:=(Vorlage as tPipeInputDateiInfo).bytesPerSample;
+ Kodierung:=(Vorlage as tPipeInputDateiInfo).Kodierung;
+ end
+ else begin
+ Analysator:='/usr/bin/soxi -';
+ bytesPerSample:=-1;
+ Kodierung:=kUnbekannt;
+ end;
end;
constructor tPipeInputDateiInfo.create;
begin
- inherited create;
- fillchar(Analysator,sizeof(Analysator),#0);
- Analysator:='/usr/bin/soxi -';
- bytesPerSample:=-1;
- Kodierung:=kUnbekannt;
+ inherited create;
+ fillchar(Analysator,sizeof(Analysator),#0);
+ Analysator:='/usr/bin/soxi -';
+ bytesPerSample:=-1;
+ Kodierung:=kUnbekannt;
end;
destructor tPipeInputDateiInfo.destroy;
begin
- Analysator:='';
- inherited destroy;
+ Analysator:='';
+ inherited destroy;
end;
function tPipeInputDateiInfo.Executable: string;
begin
- result:=leftStr(Name,pos(' ',Name+' ')-1);
+ result:=leftStr(Name,pos(' ',Name+' ')-1);
end;
function tPipeInputDateiInfo.ParametersText: string;
begin
- result:=copy(Name,pos(' ',Name+' ')+1,length(Name));
- while pos(' ',result)>0 do
- result[pos(' ',result)]:=#13;
+ result:=copy(Name,pos(' ',Name+' ')+1,length(Name));
+ while pos(' ',result)>0 do
+ result[pos(' ',result)]:=#13;
end;
function tPipeInputDateiInfo.AnalysatorExecutable: string;
begin
- result:=leftStr(Analysator,pos(' ',Analysator+' ')-1);
+ result:=leftStr(Analysator,pos(' ',Analysator+' ')-1);
end;
function tPipeInputDateiInfo.AnalysatorParametersText: string;
begin
- result:=copy(Analysator,pos(' ',Analysator+' ')+1,length(Analysator));
- while pos(' ',result)>0 do
- result[pos(' ',result)]:=#13;
+ result:=copy(Analysator,pos(' ',Analysator+' ')+1,length(Analysator));
+ while pos(' ',result)>0 do
+ result[pos(' ',result)]:=#13;
end;
// tInputDateiInfoVorlagen *****************************************************
constructor tInputDateiInfoVorlagen.create;
begin
- inherited create;
- PhaseSpaceVorlage:=tPhaseSpaceInputDateiInfo.create;
- SpaceTimeVorlage:=tSpaceTimeInputDateiInfo.create;
- TraceVorlage:=tTraceInputDateiInfo.create;
- PipeVorlage:=tPipeInputDateiInfo.create;
- fillchar(_Name,sizeof(_Name),#0);
- Name:=SpaceTimeVorlage.Name;
- fillchar(_Fehlerbehebungskommando,sizeof(_Fehlerbehebungskommando),#0);
- Fehlerbehebungskommando:=SpaceTimeVorlage.Fehlerbehebungskommando;
- Gamma:=SpaceTimeVorlage.Gamma;
- groeszenFaktor:=SpaceTimeVorlage.groeszenFaktor;
- Genauigkeit:=SpaceTimeVorlage.Genauigkeit;
- _tsiz:=SpaceTimeVorlage.tsiz;
- _xsteps:=SpaceTimeVorlage.xsteps;
- SpurNummer:=TraceVorlage.SpurNummer;
- FeldNummer:=TraceVorlage.FeldNummer;
- fillchar(_Analysator,sizeof(_Analysator),#0);
- Analysator:=PipeVorlage.Analysator;
- _bytesPerSample:=PipeVorlage.bytesPerSample;
- _Kodierung:=PipeVorlage.Kodierung;
- _tstart:=SpaceTimeVorlage.tstart;
- _tstop:=SpaceTimeVorlage.tstop;
- _xstart:=SpaceTimeVorlage.xstart;
- _xstop:=SpaceTimeVorlage.xstop;
- _t0abs:=SpaceTimeVorlage.t0abs;
+ inherited create;
+ PhaseSpaceVorlage:=tPhaseSpaceInputDateiInfo.create;
+ SpaceTimeVorlage:=tSpaceTimeInputDateiInfo.create;
+ TraceVorlage:=tTraceInputDateiInfo.create;
+ PipeVorlage:=tPipeInputDateiInfo.create;
+ fillchar(_Name,sizeof(_Name),#0);
+ Name:=SpaceTimeVorlage.Name;
+ fillchar(_Fehlerbehebungskommando,sizeof(_Fehlerbehebungskommando),#0);
+ Fehlerbehebungskommando:=SpaceTimeVorlage.Fehlerbehebungskommando;
+ Gamma:=SpaceTimeVorlage.Gamma;
+ groeszenFaktor:=SpaceTimeVorlage.groeszenFaktor;
+ Genauigkeit:=SpaceTimeVorlage.Genauigkeit;
+ _tsiz:=SpaceTimeVorlage.tsiz;
+ _xsteps:=SpaceTimeVorlage.xsteps;
+ SpurNummer:=TraceVorlage.SpurNummer;
+ FeldNummer:=TraceVorlage.FeldNummer;
+ fillchar(_Analysator,sizeof(_Analysator),#0);
+ Analysator:=PipeVorlage.Analysator;
+ _bytesPerSample:=PipeVorlage.bytesPerSample;
+ _Kodierung:=PipeVorlage.Kodierung;
+ _tstart:=SpaceTimeVorlage.tstart;
+ _tstop:=SpaceTimeVorlage.tstop;
+ _xstart:=SpaceTimeVorlage.xstart;
+ _xstop:=SpaceTimeVorlage.xstop;
+ _t0abs:=SpaceTimeVorlage.t0abs;
end;
destructor tInputDateiInfoVorlagen.destroy;
begin
- PhaseSpaceVorlage.free;
- SpaceTimeVorlage.free;
- TraceVorlage.free;
- PipeVorlage.free;
- _Name:='';
- _Fehlerbehebungskommando:='';
- _Analysator:='';
- inherited destroy;
+ PhaseSpaceVorlage.free;
+ SpaceTimeVorlage.free;
+ TraceVorlage.free;
+ PipeVorlage.free;
+ _Name:='';
+ _Fehlerbehebungskommando:='';
+ _Analysator:='';
+ inherited destroy;
end;
procedure tInputDateiInfoVorlagen.wFehlerbehebungskommando(f: string);
begin
- _Fehlerbehebungskommando:=f;
- PhaseSpaceVorlage.Fehlerbehebungskommando:=f;
- SpaceTimeVorlage.Fehlerbehebungskommando:=f;
- TraceVorlage.Fehlerbehebungskommando:=f;
- PipeVorlage.Fehlerbehebungskommando:=f;
+ _Fehlerbehebungskommando:=f;
+ PhaseSpaceVorlage.Fehlerbehebungskommando:=f;
+ SpaceTimeVorlage.Fehlerbehebungskommando:=f;
+ TraceVorlage.Fehlerbehebungskommando:=f;
+ PipeVorlage.Fehlerbehebungskommando:=f;
end;
procedure tInputDateiInfoVorlagen.wName(n: string);
begin
- _Name:=n;
- PhaseSpaceVorlage.Name:=n;
- SpaceTimeVorlage.Name:=n;
- TraceVorlage.Name:=n;
- PipeVorlage.Name:=n;
+ _Name:=n;
+ PhaseSpaceVorlage.Name:=n;
+ SpaceTimeVorlage.Name:=n;
+ TraceVorlage.Name:=n;
+ PipeVorlage.Name:=n;
end;
procedure tInputDateiInfoVorlagen.wGamma(g: extended);
begin
- _Gamma:=g;
- PhaseSpaceVorlage.Gamma:=g;
- SpaceTimeVorlage.Gamma:=g;
- TraceVorlage.Gamma:=g;
- PipeVorlage.Gamma:=g;
+ _Gamma:=g;
+ PhaseSpaceVorlage.Gamma:=g;
+ SpaceTimeVorlage.Gamma:=g;
+ TraceVorlage.Gamma:=g;
+ PipeVorlage.Gamma:=g;
end;
procedure tInputDateiInfoVorlagen.wTStart(t: extended);
begin
- _tstart:=t;
- PhaseSpaceVorlage.tstart:=t;
- SpaceTimeVorlage.tstart:=t;
- TraceVorlage.tstart:=t;
- PipeVorlage.tstart:=t;
+ _tstart:=t;
+ PhaseSpaceVorlage.tstart:=t;
+ SpaceTimeVorlage.tstart:=t;
+ TraceVorlage.tstart:=t;
+ PipeVorlage.tstart:=t;
end;
procedure tInputDateiInfoVorlagen.wTStop(t: extended);
begin
- _tstop:=t;
- PhaseSpaceVorlage.tstop:=t;
- SpaceTimeVorlage.tstop:=t;
- TraceVorlage.tstop:=t;
- PipeVorlage.tstop:=t;
+ _tstop:=t;
+ PhaseSpaceVorlage.tstop:=t;
+ SpaceTimeVorlage.tstop:=t;
+ TraceVorlage.tstop:=t;
+ PipeVorlage.tstop:=t;
end;
procedure tInputDateiInfoVorlagen.wXStart(x: extended);
begin
- _xstart:=x;
- PhaseSpaceVorlage.xstart:=x;
- SpaceTimeVorlage.xstart:=x;
- TraceVorlage.xstart:=x;
- PipeVorlage.xstart:=x;
+ _xstart:=x;
+ PhaseSpaceVorlage.xstart:=x;
+ SpaceTimeVorlage.xstart:=x;
+ TraceVorlage.xstart:=x;
+ PipeVorlage.xstart:=x;
end;
procedure tInputDateiInfoVorlagen.wXStop(x: extended);
begin
- _xstop:=x;
- PhaseSpaceVorlage.xstop:=x;
- SpaceTimeVorlage.xstop:=x;
- TraceVorlage.xstop:=x;
- PipeVorlage.xstop:=x;
+ _xstop:=x;
+ PhaseSpaceVorlage.xstop:=x;
+ SpaceTimeVorlage.xstop:=x;
+ TraceVorlage.xstop:=x;
+ PipeVorlage.xstop:=x;
end;
procedure tInputDateiInfoVorlagen.wT0Abs(t: longint);
begin
- _t0abs:=t;
- PhaseSpaceVorlage.t0abs:=t;
- SpaceTimeVorlage.t0abs:=t;
- TraceVorlage.t0abs:=t;
- PipeVorlage.t0abs:=t;
+ _t0abs:=t;
+ PhaseSpaceVorlage.t0abs:=t;
+ SpaceTimeVorlage.t0abs:=t;
+ TraceVorlage.t0abs:=t;
+ PipeVorlage.t0abs:=t;
end;
procedure tInputDateiInfoVorlagen.wGroeszenFaktor(g: extended);
begin
- _groeszenFaktor:=g;
- PhaseSpaceVorlage.groeszenFaktor:=g;
- SpaceTimeVorlage.groeszenFaktor:=g;
- TraceVorlage.groeszenFaktor:=g;
- PipeVorlage.groeszenFaktor:=g;
+ _groeszenFaktor:=g;
+ PhaseSpaceVorlage.groeszenFaktor:=g;
+ SpaceTimeVorlage.groeszenFaktor:=g;
+ TraceVorlage.groeszenFaktor:=g;
+ PipeVorlage.groeszenFaktor:=g;
end;
procedure tInputDateiInfoVorlagen.wGenauigkeit(g: tGenauigkeit);
begin
- _Genauigkeit:=g;
- PhaseSpaceVorlage.Genauigkeit:=g;
- SpaceTimeVorlage.Genauigkeit:=g;
- TraceVorlage.Genauigkeit:=g;
- PipeVorlage.Genauigkeit:=g;
+ _Genauigkeit:=g;
+ PhaseSpaceVorlage.Genauigkeit:=g;
+ SpaceTimeVorlage.Genauigkeit:=g;
+ TraceVorlage.Genauigkeit:=g;
+ PipeVorlage.Genauigkeit:=g;
end;
procedure tInputDateiInfoVorlagen.wTSiz(t: longint);
begin
- _tsiz:=t;
- PhaseSpaceVorlage.tsiz:=t;
- SpaceTimeVorlage.tsiz:=t;
- TraceVorlage.tsiz:=t;
- PipeVorlage.tsiz:=t;
+ _tsiz:=t;
+ PhaseSpaceVorlage.tsiz:=t;
+ SpaceTimeVorlage.tsiz:=t;
+ TraceVorlage.tsiz:=t;
+ PipeVorlage.tsiz:=t;
end;
procedure tInputDateiInfoVorlagen.wXSteps(x: longint);
begin
- _xsteps:=x;
- PhaseSpaceVorlage.xsteps:=x;
- SpaceTimeVorlage.xsteps:=x;
- TraceVorlage.xsteps:=x;
- PipeVorlage.xsteps:=x;
+ _xsteps:=x;
+ PhaseSpaceVorlage.xsteps:=x;
+ SpaceTimeVorlage.xsteps:=x;
+ TraceVorlage.xsteps:=x;
+ PipeVorlage.xsteps:=x;
end;
procedure tInputDateiInfoVorlagen.wSpurNummer(s: longint);
begin
- _SpurNummer:=s;
- TraceVorlage.SpurNummer:=s;
+ _SpurNummer:=s;
+ TraceVorlage.SpurNummer:=s;
end;
procedure tInputDateiInfoVorlagen.wFeldNummer(f: longint);
begin
- _FeldNummer:=f;
- TraceVorlage.FeldNummer:=f;
+ _FeldNummer:=f;
+ TraceVorlage.FeldNummer:=f;
end;
procedure tInputDateiInfoVorlagen.wAnalysator(a: string);
begin
- _Analysator:=a;
- PipeVorlage.Analysator:=a;
+ _Analysator:=a;
+ PipeVorlage.Analysator:=a;
end;
procedure tInputDateiInfoVorlagen.wBytesPerSample(b: longint);
begin
- _bytesPerSample:=b;
- PipeVorlage.bytesPerSample:=b;
+ _bytesPerSample:=b;
+ PipeVorlage.bytesPerSample:=b;
end;
procedure tInputDateiInfoVorlagen.wKodierung(k: tKodierung);
begin
- _Kodierung:=k;
- PipeVorlage.Kodierung:=k;
+ _Kodierung:=k;
+ PipeVorlage.Kodierung:=k;
end;
function tInputDateiInfoVorlagen.GenauigkeitFromStr(s: string): boolean;
begin
- result:=strToGen(_Genauigkeit,s);
- Genauigkeit:=_Genauigkeit;
+ result:=strToGen(_Genauigkeit,s);
+ Genauigkeit:=_Genauigkeit;
end;
function tInputDateiInfoVorlagen.Fehlerbehebungsprogramm: string;
begin
- result:=copy(Fehlerbehebungskommando,1,pos(' ',Fehlerbehebungskommando+' ')-1);
+ result:=copy(Fehlerbehebungskommando,1,pos(' ',Fehlerbehebungskommando+' ')-1);
end;
function tInputDateiInfoVorlagen.Fehlerbehebungsparameter: string;
begin
- result:=copy(Fehlerbehebungskommando,pos(' ',Fehlerbehebungskommando+' ')+1,length(Fehlerbehebungskommando));
+ result:=copy(Fehlerbehebungskommando,pos(' ',Fehlerbehebungskommando+' ')+1,length(Fehlerbehebungskommando));
end;
procedure tInputDateiInfoVorlagen.wParams(p: tExtrainfos);
begin
- _params:=p;
- PhaseSpaceVorlage.params:=p;
- SpaceTimeVorlage.params:=p;
- TraceVorlage.params:=p;
- PipeVorlage.params:=p;
+ _params:=p;
+ PhaseSpaceVorlage.params:=p;
+ SpaceTimeVorlage.params:=p;
+ TraceVorlage.params:=p;
+ PipeVorlage.params:=p;
end;
// tFenster ********************************************************************
procedure tFenster.berechneWerte(anzWerte: longint);
-var i: integer;
+var
+ i: integer;
begin
setlength(werte,anzWerte);
for i:=0 to length(werte)-1 do begin
@@ -856,53 +888,53 @@ end;
constructor tBeschriftung.create;
begin
- inherited create;
- _inhalt:='';
+ inherited create;
+ _inhalt:='';
end;
destructor tBeschriftung.destroy;
begin
- _inhalt:='';
- inherited destroy;
+ _inhalt:='';
+ inherited destroy;
end;
function tBeschriftung.strich: longint;
begin
- result:=round(position);
+ result:=round(position);
end;
function tBeschriftung.links: longint;
begin
- case lage of
+ case lage of
lOben,lUnten: result:=strich-(bild.breite div 2);
lLinks: result:=-bild.breite-4-Byte(Rahmen);
lRechts: result:=bbreite+3+Byte(Rahmen);
- end{of Case};
+ end{of Case};
end;
function tBeschriftung.oben: longint;
begin
- case lage of
+ case lage of
lLinks,lRechts: result:=strich-(bild.hoehe div 2);
lUnten: result:=-bild.hoehe-4-Byte(Rahmen);
lOben: result:=bHoehe+3+Byte(Rahmen);
- end{of Case};
+ end{of Case};
end;
function tBeschriftung.rechts: longint;
begin
- result:=links+bild.breite-1;
+ result:=links+bild.breite-1;
end;
function tBeschriftung.unten: longint;
begin
- result:=oben+bild.hoehe-1;
+ result:=oben+bild.hoehe-1;
end;
procedure tBeschriftung.wInhalt(s: string);
begin
- _inhalt:=s;
- bild:=fontRend.rendere(_inhalt);
+ _inhalt:=s;
+ bild:=fontRend.rendere(_inhalt);
end;
// tExtraInfos *****************************************************************
@@ -912,7 +944,7 @@ begin
inherited create;
maxW:=1;
minW:=0;
- transformationen:=tTransformationen.create;
+ transformationen:=tTransformation.create;
np:=1;
beta:=0;
tsiz:=0;
@@ -924,29 +956,29 @@ end;
destructor tExtraInfos.destroy;
begin
- knownValues.free;
- transformationen.free;
- inherited destroy;
+ knownValues.free;
+ transformationen.free;
+ inherited destroy;
end;
function tExtraInfos.xstart: extended;
begin
- result:=transformationen.xstart;
+ result:=transformationen.xstart;
end;
function tExtraInfos.xstop: extended;
begin
- result:=transformationen.xstop;
+ result:=transformationen.xstop;
end;
function tExtraInfos.tstart: extended;
begin
- result:=transformationen.tstart;
+ result:=transformationen.tstart;
end;
function tExtraInfos.tstop: extended;
begin
- result:=transformationen.tstop;
+ result:=transformationen.tstop;
end;
procedure tExtraInfos.refreshKnownValues;
@@ -965,520 +997,821 @@ end;
constructor tFontRenderer.create(schriftgroesze: longint);
begin
- inherited create;
+ inherited create;
- gibAus('FontRenderer erzeugen (Schriftgröße '+inttostr(schriftgroesze)+') ...',1);
+ gibAus('FontRenderer erzeugen (Schriftgröße '+inttostr(schriftgroesze)+') ...',1);
- New(agg, Construct);
- agg^.font('/usr/share/fonts/TTF/DejaVuSans.ttf',schriftgroesze,false,false,RasterFontCache,0.0);
+ New(agg, Construct);
+ agg^.font('/usr/share/fonts/TTF/DejaVuSans.ttf',schriftgroesze,false,false,RasterFontCache,0.0);
- gibAus('... fertig',1);
+ gibAus('... fertig',1);
end;
destructor tFontRenderer.destroy;
begin
- Dispose(agg,Destruct);
- inherited destroy;
+ Dispose(agg,Destruct);
+ inherited destroy;
end;
function tFontRenderer.rendere(s: string): tLLBild;
-var buf: array of byte;
- ho,br,ymax,ymin,xmax,xmin,i,j: longint;
- b: boolean;
-begin
- while pos('.',s)>0 do
- s[pos('.',s)]:=',';
- br:=4*round(ceil(agg^.textWidth(char_ptr(s))));
- ho:=4*round(ceil(agg^.fontHeight));
- setlength(buf,ho*br*4);
- agg^.attach(@(buf[0]), br, ho, br * 4);
- agg^.clearAll(0, 0, 0);
- agg^.lineColor(0, 0, 0, 255);
- agg^.fillColor(255, 255, 255, 255);
- agg^.rectangle(-2, -2, br+2, ho+2);
- agg^.lineColor(255, 0, 0, 255);
- agg^.fillColor(0, 0, 0, 255);
- agg^.text(br div 2, ho div 2, char_ptr(s));
-
- ymax:=ho;
- b:=true;
- while b and (ymax>0) do begin
- dec(ymax);
- for i:=0 to br-1 do
- if (buf[4*(i+br*ymax)+0]<>$ff) or
+var
+ buf: array of byte;
+ ho,br,ymax,ymin,xmax,xmin,i,j: longint;
+ b: boolean;
+begin
+ while pos('.',s)>0 do
+ s[pos('.',s)]:=',';
+ br:=4*round(ceil(agg^.textWidth(char_ptr(s))));
+ ho:=4*round(ceil(agg^.fontHeight));
+ setlength(buf,ho*br*4);
+ agg^.attach(@(buf[0]), br, ho, br * 4);
+ agg^.clearAll(0, 0, 0);
+ agg^.lineColor(0, 0, 0, 255);
+ agg^.fillColor(255, 255, 255, 255);
+ agg^.rectangle(-2, -2, br+2, ho+2);
+ agg^.lineColor(255, 0, 0, 255);
+ agg^.fillColor(0, 0, 0, 255);
+ agg^.text(br div 2, ho div 2, char_ptr(s));
+
+ ymax:=ho;
+ b:=true;
+ while b and (ymax>0) do begin
+ dec(ymax);
+ for i:=0 to br-1 do
+ if (buf[4*(i+br*ymax)+0]<>$ff) or
(buf[4*(i+br*ymax)+1]<>$ff) or
(buf[4*(i+br*ymax)+2]<>$ff) then
- b:=false;
- end;
- if b then begin
- gibAus('Leeres Bild!',3);
- halt(1);
- end;
- ymin:=-1;
- b:=true;
- while b and (ymin<ymax) do begin
- inc(ymin);
- for i:=0 to br-1 do
- if (buf[4*(i+br*ymin)+0]<>$ff) or
+ b:=false;
+ end;
+ if b then begin
+ gibAus('Leeres Bild!',3);
+ halt(1);
+ end;
+ ymin:=-1;
+ b:=true;
+ while b and (ymin<ymax) do begin
+ inc(ymin);
+ for i:=0 to br-1 do
+ if (buf[4*(i+br*ymin)+0]<>$ff) or
(buf[4*(i+br*ymin)+1]<>$ff) or
(buf[4*(i+br*ymin)+2]<>$ff) then
- b:=false;
- end;
- if b then begin
- gibAus('Leeres Bild!',3);
- halt(1);
- end;
-
- xmax:=br;
- b:=true;
- while b and (xmax>0) do begin
- dec(xmax);
- for i:=ymin to ymax do
- if (buf[4*(xmax+br*i)+0]<>$ff) or
+ b:=false;
+ end;
+ if b then begin
+ gibAus('Leeres Bild!',3);
+ halt(1);
+ end;
+
+ xmax:=br;
+ b:=true;
+ while b and (xmax>0) do begin
+ dec(xmax);
+ for i:=ymin to ymax do
+ if (buf[4*(xmax+br*i)+0]<>$ff) or
(buf[4*(xmax+br*i)+1]<>$ff) or
(buf[4*(xmax+br*i)+2]<>$ff) then
- b:=false;
- end;
- if b then begin
- gibAus('Leeres Bild!',3);
- halt(1);
- end;
- xmin:=-1;
- b:=true;
- while b and (xmin<=xmax) do begin
- inc(xmin);
- for i:=ymin to ymax do
- if (buf[4*(xmin+br*i)+0]<>$ff) or
+ b:=false;
+ end;
+ if b then begin
+ gibAus('Leeres Bild!',3);
+ halt(1);
+ end;
+ xmin:=-1;
+ b:=true;
+ while b and (xmin<=xmax) do begin
+ inc(xmin);
+ for i:=ymin to ymax do
+ if (buf[4*(xmin+br*i)+0]<>$ff) or
(buf[4*(xmin+br*i)+1]<>$ff) or
(buf[4*(xmin+br*i)+2]<>$ff) then
- b:=false;
- end;
- if b then begin
- gibAus('Leeres Bild!',3);
- halt(1);
- end;
-
- dec(xmin);
- dec(ymin);
- inc(xmax);
- inc(ymax);
-
- result.breite:=xmax-xmin+1;
- result.hoehe:=ymax-ymin+1;
-
- setlength(result.farben,result.breite*result.hoehe);
- for i:=0 to result.breite-1 do
- for j:=0 to result.hoehe-1 do begin
- result.farben[i + j*result.breite].rgbBlue:= byte(buf[4*(i+xmin+br*(j+ymin))+0]);
- result.farben[i + j*result.breite].rgbGreen:=byte(buf[4*(i+xmin+br*(j+ymin))+1]);
- result.farben[i + j*result.breite].rgbRed:= byte(buf[4*(i+xmin+br*(j+ymin))+2]);
- end;
+ b:=false;
+ end;
+ if b then begin
+ gibAus('Leeres Bild!',3);
+ halt(1);
+ end;
+
+ dec(xmin);
+ dec(ymin);
+ inc(xmax);
+ inc(ymax);
+
+ result.breite:=xmax-xmin+1;
+ result.hoehe:=ymax-ymin+1;
+
+ setlength(result.farben,result.breite*result.hoehe);
+ for i:=0 to result.breite-1 do
+ for j:=0 to result.hoehe-1 do begin
+ result.farben[i + j*result.breite].rgbBlue:= byte(buf[4*(i+xmin+br*(j+ymin))+0]);
+ result.farben[i + j*result.breite].rgbGreen:=byte(buf[4*(i+xmin+br*(j+ymin))+1]);
+ result.farben[i + j*result.breite].rgbRed:= byte(buf[4*(i+xmin+br*(j+ymin))+2]);
+ end;
{ for i:=0 to 1 do
- for j:=0 to 1 do begin
- result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbRed:=
- result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbRed xor $ff;
- result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbGreen:=
- result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbGreen xor $ff;
- result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbBlue:=
- result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbBlue xor $ff;
- end; }
- setlength(buf,0);
+ for j:=0 to 1 do begin
+ result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbRed:=
+ result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbRed xor $ff;
+ result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbGreen:=
+ result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbGreen xor $ff;
+ result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbBlue:=
+ result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbBlue xor $ff;
+ end; }
+ setlength(buf,0);
end;
// tTransformation *************************************************************
+constructor tTransformation.create;
+begin
+ inherited create;
+ fillchar(vorgaenger,sizeOf(vorgaenger),#0);
+ fillchar(nachfolger,sizeOf(nachfolger),#0);
+end;
+
+destructor tTransformation.destroy;
+var
+ i: longint;
+begin
+ for i:=0 to length(vorgaenger)-1 do
+ vorgaenger[i].loescheNachfolger(self);
+ setlength(vorgaenger,0);
+ if hatNachfolger then begin
+ gibAus('Ich habe noch '+inttostr(length(nachfolger))+' Nachfolger, da kann ich mich nicht zerstören!',3);
+ raise exception.create('Ich habe noch '+inttostr(length(nachfolger))+' Nachfolger, da kann ich mich nicht zerstören!');
+ end;
+ inherited destroy;
+end;
+
+destructor tTransformation.freeAll;
+var
+ i: longint;
+begin
+ for i:=0 to length(vorgaenger)-1 do
+ vorgaenger[i].loescheNachfolger(self);
+ if hatNachfolger then begin
+ gibAus('Ich habe noch '+inttostr(length(nachfolger))+' Nachfolger, da kann ich mich nicht zerstören!',3);
+ raise exception.create('Ich habe noch '+inttostr(length(nachfolger))+' Nachfolger, da kann ich mich nicht zerstören!');
+ end;
+ for i:=0 to length(vorgaenger)-1 do
+ vorgaenger[i].freeAll;
+ setlength(vorgaenger,0);
+ inherited destroy;
+end;
+
procedure tTransformation.testeAuszerhalb(const p: tExtPoint);
begin
- if (p['x']<0) or (p['x']>in_xs_ts['x']-1) or
- (p['y']<0) or (p['y']>in_xs_ts['y']-1) then
- raise exception.create('Punkt '+tExtPointToStr(p)+' liegt außerhalb des gültigen Eingabebereich (0..'+inttostr(in_xs_ts['x']-1)+' x 0..'+inttostr(in_xs_ts['y']-1)+')!');
+ if (p['x']<0) or (p['x']>in_xs_ts['x']-1) or
+ (p['y']<0) or (p['y']>in_xs_ts['y']-1) then begin
+ gibAus('Punkt '+tExtPointToStr(p)+' liegt außerhalb des gültigen Eingabebereich (0..'+inttostr(in_xs_ts['x']-1)+' x 0..'+inttostr(in_xs_ts['y']-1)+')!',3);
+ raise exception.create('Punkt '+tExtPointToStr(p)+' liegt außerhalb des gültigen Eingabebereich (0..'+inttostr(in_xs_ts['x']-1)+' x 0..'+inttostr(in_xs_ts['y']-1)+')!');
+ end;
+end;
+
+procedure tTransformation.aktualisiereAchsen; // nicht zum direkten Aufrufen
+begin
+end;
+
+procedure tTransformation.aktualisiereXsTs; // nicht zum direkten Aufrufen
+begin
end;
-function tTransformation.transformiereKoordinaten(const x,y: longint): tExtPoint;
-var p: tExtPoint;
+procedure tTransformation.aktualisiereWmia; // nicht zum direkten Aufrufen
begin
- p['x']:=x;
- p['y']:=y;
- result:=transformiereKoordinaten(p);
end;
-function tTransformation.transformiereKoordinaten(const p: tExtPoint): tExtPoint;
+function tTransformation.rXstart: extended;
begin
- result:=p;
- testeAuszerhalb(p);
+ result:=out_achsen['x','x'];
end;
-function tTransformation.transformiereWert(const x: extended): extended;
+procedure tTransformation.wXstart(x: extended);
begin
- result:=x;
+ if not (self is tKeineTransformation) then begin
+ gibAus('Will xstart schreiben, aber bin nicht der Anfang einer Transformationskette!',3);
+ raise exception.create('Will xstart schreiben, aber bin nicht der Anfang einer Transformationskette!');
+ end;
+ in_achsen['x','x']:=x;
+ aktualisiereAlles;
+end;
+
+function tTransformation.rXstop: extended;
+begin
+ result:=out_Achsen['x','y'];
+end;
+
+procedure tTransformation.wXstop(x: extended);
+begin
+ if not (self is tKeineTransformation) then begin
+ gibAus('Will xstop schreiben, aber bin nicht der Anfang einer Transformationskette!',3);
+ raise exception.create('Will xstop schreiben, aber bin nicht der Anfang einer Transformationskette!');
+ end;
+ in_achsen['x','y']:=x;
+ aktualisiereAlles;
end;
-function tTransformation.xsteps_tsiz: tIntPoint;
+function tTransformation.rTstart: extended;
begin
- result:=in_xs_ts;
+ result:=out_Achsen['y','x'];
end;
-function tTransformation.achsen: t2x2Extended;
-var c,d: char;
+procedure tTransformation.wTstart(t: extended);
begin
- for c:='x' to 'y' do
- for d:='x' to 'y' do
- result[c,d]:=in_achsen[c,d]*byte((in_xs_ts['x']>0) and (in_xs_ts['y']>0));
+ if not (self is tKeineTransformation) then begin
+ gibAus('Will tstart schreiben, aber bin nicht der Anfang einer Transformationskette!',3);
+ raise exception.create('Will tstart schreiben, aber bin nicht der Anfang einer Transformationskette!');
+ end;
+ in_achsen['y','x']:=t;
+ aktualisiereAlles;
+end;
+
+function tTransformation.rTstop: extended;
+begin
+ result:=out_Achsen['y','y'];
+end;
+
+procedure tTransformation.wTstop(t: extended);
+begin
+ if not (self is tKeineTransformation) then begin
+ gibAus('Will tstop schreiben, aber bin nicht der Anfang einer Transformationskette!',3);
+ raise exception.create('Will tstop schreiben, aber bin nicht der Anfang einer Transformationskette!');
+ end;
+ in_achsen['y','y']:=t;
+ aktualisiereAlles;
+end;
+
+function tTransformation.rWmin: extended;
+begin
+ result:=out_wmia['x'];
+end;
+
+procedure tTransformation.wWmin(w: extended);
+begin
+ out_wmia['x']:=w;
+ wmiaExplizit:=true;
+ aktualisiereAlles;
+end;
+
+function tTransformation.rWmax: extended;
+begin
+ result:=out_wmia['y'];
+end;
+
+procedure tTransformation.wWmax(w: extended);
+begin
+ wmiaExplizit:=true;
+ out_wmia['y']:=w;
+end;
+
+function tTransformation.rXsteps: longint;
+begin
+ result:=out_xs_ts['x'];
+end;
+
+procedure tTransformation.wXsteps(x: longint);
+begin
+ if not (self is tKeineTransformation) then begin
+ gibAus('Will xsteps schreiben, aber bin nicht der Anfang einer Transformationskette!',3);
+ raise exception.create('Will xsteps schreiben, aber bin nicht der Anfang einer Transformationskette!');
+ end;
+ in_xs_ts['x']:=x;
+end;
+
+function tTransformation.rTsiz: longint;
+begin
+ result:=out_xs_ts['y'];
+end;
+
+procedure tTransformation.wTsiz(t: longint);
+begin
+ if not (self is tKeineTransformation) then begin
+ gibAus('Will tsiz schreiben, aber bin nicht der Anfang einer Transformationskette!',3);
+ raise exception.create('Will tsiz schreiben, aber bin nicht der Anfang einer Transformationskette!');
+ end;
+ in_xs_ts['y']:=t;
+end;
+
+procedure tTransformation.fuegeNachfolgerHinzu(tr: tTransformation);
+begin
+ if assigned(tr) then begin
+ setlength(nachfolger,length(nachfolger)+1);
+ nachfolger[length(nachfolger)-1]:=tr;
+ end;
+end;
+
+procedure tTransformation.loescheNachfolger(tr: tTransformation);
+var
+ i,j: longint;
+begin
+ for i:=0 to length(nachfolger)-1 do
+ if nachfolger[i]=tr then begin
+ for j:=i+1 to length(nachfolger)-1 do
+ nachfolger[j-1]:=nachfolger[j];
+ setlength(nachfolger,length(nachfolger)-1);
+ exit;
+ end;
+ gibAus('Kann zu löschenden Nachfolger nicht finden!',3);
+ raise exception.create('Kann zu löschenden Nachfolger nicht finden!');
+end;
+
+procedure tTransformation.fuegeVorgaengerHinzu(tr: tTransformation);
+begin
+ if assigned(tr) then begin
+ setlength(vorgaenger,length(vorgaenger)+1);
+ vorgaenger[length(vorgaenger)-1]:=tr;
+ end;
+end;
+
+procedure tTransformation.loescheVorgaenger(tr: tTransformation);
+var
+ i,j: longint;
+begin
+ for i:=0 to length(vorgaenger)-1 do
+ if vorgaenger[i]=tr then begin
+ for j:=i+1 to length(vorgaenger)-1 do
+ vorgaenger[j-1]:=vorgaenger[j];
+ setlength(vorgaenger,length(vorgaenger)-1);
+ exit;
+ end;
+ gibAus('Kann zu löschenden Vorgänger nicht finden!',3);
+ raise exception.create('Kann zu löschenden Vorgänger nicht finden!');
+end;
+
+function tTransformation.hatNachfolger: boolean;
+begin
+ result:=length(nachfolger)>0;
+end;
+
+procedure tTransformation.aktualisiereAlles; // (inkl. Informieren der Nachfolger)
+var
+ i: longint;
+begin
+ aktualisiereAchsen;
+ aktualisiereWmia;
+ aktualisiereXsTs;
+ for i:=0 to length(nachfolger)-1 do
+ nachfolger[i].aktualisiereAlles;
+end;
+
+function tTransformation.ersetzeAnfangDurch(tr: tTransformation): boolean;
+begin
+ result:=false;
+
+ if length(vorgaenger)<>1 then begin
+ gibAus('Kann Anfang von Transformation nicht ersetzen, da nicht genau ein Vorgänger!',3);
+ exit;
+ end;
+
+ if vorgaenger[0] is tKeineTransformation then begin
+ vorgaenger[0].loescheNachfolger(self);
+ if not vorgaenger[0].hatNachfolger then
+ vorgaenger[0].free;
+ vorgaenger[0]:=tr;
+ vorgaenger[0].fuegeNachfolgerHinzu(self);
+ result:=true;
+ end
+ else
+ result:=vorgaenger[0].ersetzeAnfangDurch(tr);
+end;
+
+function tTransformation.beliebigerVorgaenger: tTransformation;
+begin
+ result:=vorgaenger[0];
+end;
+
+function tTransformation.transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint;
+begin
+ result:=p;
+ testeAuszerhalb(p);
+end;
+
+function tTransformation.transformiereKoordinaten(const p: tExtPoint; const tiefe: longint = -1): tExtPoint;
+begin
+ if (length(vorgaenger)>0) and (tiefe<>0) then
+ result:=vorgaenger[0].transformiereKoordinaten(p,tiefe-1)
+ else
+ result:=p;
+ result:=transformiereKoordinatenEinzeln(result);
+end;
+
+function tTransformation.transformiereKoordinaten(const x,y: longint; const tiefe: longint = -1): tExtPoint;
+var
+ p: tExtPoint;
+begin
+ p['x']:=x;
+ p['y']:=y;
+ result:=transformiereKoordinaten(p,tiefe);
+end;
+
+function tTransformation.wertZuPositionAufAchse(const l: tLage; x: extended): extended;
+var
+ c,d: char;
+ p: tExtPoint;
+begin
+ c:=char(ord('x')+byte(l in [lOben,lUnten]));
+ d:=char(ord('y')-byte(l in [lOben,lUnten]));
+ p[c]:=(x-in_achsen[c,'x'])/(in_achsen[c,'y']-in_achsen[c,'x']);
+ p[d]:=byte(l in [lRechts,lOben]);
+
+ for d:='x' to 'y' do
+ p[d]:=p[d] * (in_xs_ts[d]-1);
+
+ transformiereKoordinaten(p,0);
+
+ result:=p[c]/(out_xs_ts[d]-1);
+end;
+
+function tTransformation.transformiereWertEinzeln(const x: extended): extended;
+begin
+ result:=x;
+end;
+
+function tTransformation.transformiereWert(const x: extended; const tiefe: longint = -1): extended;
+begin
+ if (length(vorgaenger)>0) and (tiefe<>0) then
+ result:=vorgaenger[0].transformiereWert(x,tiefe-1)
+ else
+ result:=x;
+ result:=transformiereWertEinzeln(result);
end;
function tTransformation.dumpParams: string;
begin
- result:='';
+ result:='';
+end;
+
+function tTransformation.dumpParams(tiefe: longint): string;
+var
+ i: longint;
+begin
+ if tiefe=0 then
+ result:=''
+ else
+ for i:=0 to length(vorgaenger)-1 do begin
+ if length(vorgaenger)>1 then
+ result:=result+#13'< '+inttostr(i)+' >';
+ result:=result+#13+vorgaenger[i].dumpParams(tiefe-1);
+ end;
+ result:=result+inttostr(tiefe+1)+': '+dumpParams;
+end;
+
+// tUeberlagerung **************************************************************
+
+procedure tUeberlagerung.addKomponente(tr: tTransformation);
+begin
+ fuegeVorgaengerHinzu(tr);
end;
// tFFTTransformation **********************************************************
constructor tFFTTransformation.create;
begin
- inherited create;
- horizontal:=false;
- vertikal:=false;
+ inherited create;
+ horizontal:=false;
+ vertikal:=false;
end;
-constructor tFFTTransformation.create(original: tFFTTransformation);
+constructor tFFTTransformation.create(vorg: tTransformation; hor,ver: boolean);
begin
- inherited create;
- horizontal:=original.horizontal;
- vertikal:=original.vertikal;
+ inherited create;
+ fuegeVorgaengerHinzu(vorg);
+ horizontal:=hor;
+ vertikal:=ver;
end;
-function tFFTTransformation.achsen: t2x2Extended;
-var c: char;
+procedure tFFTTransformation.aktualisiereAchsen;
+var
+ c: char;
begin
- if horizontal then begin
- result['x','x']:=0;
- result['x','y']:=(in_xs_ts['x']-1)/(in_achsen['x','y']-in_achsen['x','x']);
- end
- else
- for c:='x' to 'y' do
- result['x',c]:=in_achsen['x',c];
- if vertikal then begin
- result['y','x']:=0;
- result['y','y']:=(in_xs_ts['y']-1)/(in_achsen['y','y']-in_achsen['y','x']);
- end
- else
- for c:='x' to 'y' do
- result['y',c]:=in_achsen['y',c];
+ if horizontal then begin
+ out_achsen['x','x']:=0;
+ out_achsen['x','y']:=(in_xs_ts['x']-1)/(in_achsen['x','y']-in_achsen['x','x']);
+ end
+ else
+ for c:='x' to 'y' do
+ out_achsen['x',c]:=in_achsen['x',c];
+ if vertikal then begin
+ out_achsen['y','x']:=0;
+ out_achsen['y','y']:=(in_xs_ts['y']-1)/(in_achsen['y','y']-in_achsen['y','x']);
+ end
+ else
+ for c:='x' to 'y' do
+ out_achsen['y',c]:=in_achsen['y',c];
end;
function tFFTTransformation.dumpParams: string;
begin
- result:='FFT: ';
- if horizontal then result:=result+'h';
- if vertikal then result:=result+'v';
+ result:='FFT: ';
+ if horizontal then result:=result+'h';
+ if vertikal then result:=result+'v';
end;
// tSpiegelungsTransformation **************************************************
constructor tSpiegelungsTransformation.create;
begin
- inherited create;
+ inherited create;
end;
-function tSpiegelungsTransformation.transformiereKoordinaten(const p: tExtPoint): tExtPoint;
+constructor tSpiegelungsTransformation.create(vorg: tTransformation);
begin
- testeAuszerhalb(p);
- result['x']:=in_xs_ts['x']-1-p['x'];
- result['y']:=p['y'];
+ inherited create;
+ fuegeVorgaengerHinzu(vorg);
+end;
+
+function tSpiegelungsTransformation.transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint;
+begin
+ testeAuszerhalb(p);
+ result['x']:=in_xs_ts['x']-1-p['x'];
+ result['y']:=p['y'];
end;
function tSpiegelungsTransformation.dumpParams: string;
begin
- result:='horizontale Spiegelung';
+ result:='horizontale Spiegelung';
end;
// tKonkreteKoordinatenTransformation ******************************************
constructor tKonkreteKoordinatenTransformation.create;
-var c,d: char;
-begin
- for c:='x' to 'y' do begin
- for d:='x' to 'y' do begin
- lin[c,d]:=byte(c=d);
- lnInt[c,d]:=0;
- expExp[c,d]:=0;
- end;
- off[c]:=0;
- lnFak[c]:=0;
- expFak[c]:=0;
- lnOff[c]:=1;
- end;
-end;
-
-constructor tKonkreteKoordinatenTransformation.create(original: tKonkreteKoordinatenTransformation);
-var c,d: char;
-begin
- for c:='x' to 'y' do begin
- for d:='x' to 'y' do begin
- lin[c,d]:=original.lin[c,d];
- lnInt[c,d]:=original.lnInt[c,d];
- expExp[c,d]:=original.expExp[c,d];
- end;
- off[c]:=original.off[c];
- lnFak[c]:=original.lnFak[c];
- expFak[c]:=original.expFak[c];
- lnOff[c]:=original.lnOff[c];
- end;
+var
+ c,d: char;
+begin
+ for c:='x' to 'y' do begin
+ for d:='x' to 'y' do begin
+ lin[c,d]:=byte(c=d);
+ lnInt[c,d]:=0;
+ expExp[c,d]:=0;
+ end;
+ off[c]:=0;
+ lnFak[c]:=0;
+ expFak[c]:=0;
+ lnOff[c]:=1;
+ end;
end;
function tKonkreteKoordinatenTransformation.findeLineareParameter(syntaxtest: boolean; auszenSkala: char; s: string; xscale,yscale: extended; var off,xl,yl: extended; ueberschreiben: boolean; etf: tExprToFloat): boolean;
-var t: string;
- c: char;
- tmp: extended;
-begin
- result:=false;
- if ueberschreiben then begin
- off:=0;
- xl:=0;
- yl:=0;
- end;
- while length(s)>0 do begin
- t:=leftStr(s,max(binOpPos('+',s),binOpPos('-',s))-1);
- if (binOpPos('+',t)>0) or (binOpPos('-',t)>0) then
- t:=leftStr(s,min(binOpPos('+',s),binOpPos('-',s))-1);
- if t='' then begin
- t:=s;
- s:='';
- end
- else
- delete(s,1,length(t));
- if t='' then exit;
- c:=rightStr(t,1)[1];
- if c in ['x','y'] then delete(t,length(t),1);
- if leftStr(t,1)='+' then delete(t,1,1);
- if t='' then tmp:=1
- else if t='-' then tmp:=-1
- else try
- tmp:=etf(syntaxtest,t);
- case c of
- 'x': tmp:=tmp*xscale;
- 'y': tmp:=tmp*yscale;
- end;
- case auszenSkala of
- 'x': tmp:=tmp/xscale;
- 'y': tmp:=tmp/yscale;
- end;
- except
- exit;
- end;
- case c of
- 'x':
- xl:=xl+tmp;
- 'y','t':
- yl:=yl+tmp;
- else
- off:=off+tmp;
- end{of case};
- end;
- result:=true;
-end;
-
-function tKonkreteKoordinatenTransformation.transformiereKoordinaten(const p: tExtPoint): tExtPoint;
-var c,d: char;
- lt,et: extended;
-begin
- testeAuszerhalb(p);
- for c:='x' to 'y' do begin
- result[c]:=off[c];
- lt:=lnOff[c];
- et:=0;
- for d:='x' to 'y' do begin
- result[c]:=
- result[c] + p[d]*lin[c,d];
- lt:=lt+p[d]*lnInt[c,d];
- et:=et+p[d]*expExp[c,d];
- end;
- result[c]:=
- result[c] + lnFak[c] * ln(lt) + expFak[c] * exp(et);
- end;
+var
+ t: string;
+ c: char;
+ tmp: extended;
+begin
+ result:=false;
+ if ueberschreiben then begin
+ off:=0;
+ xl:=0;
+ yl:=0;
+ end;
+ while length(s)>0 do begin
+ t:=leftStr(s,max(binOpPos('+',s),binOpPos('-',s))-1);
+ if (binOpPos('+',t)>0) or (binOpPos('-',t)>0) then
+ t:=leftStr(s,min(binOpPos('+',s),binOpPos('-',s))-1);
+ if t='' then begin
+ t:=s;
+ s:='';
+ end
+ else
+ delete(s,1,length(t));
+ if t='' then exit;
+ c:=rightStr(t,1)[1];
+ if c in ['x','y'] then delete(t,length(t),1);
+ if leftStr(t,1)='+' then delete(t,1,1);
+ if t='' then tmp:=1
+ else if t='-' then tmp:=-1
+ else try
+ tmp:=etf(syntaxtest,t);
+ case c of
+ 'x': tmp:=tmp*xscale;
+ 'y': tmp:=tmp*yscale;
+ end;
+ case auszenSkala of
+ 'x': tmp:=tmp/xscale;
+ 'y': tmp:=tmp/yscale;
+ end;
+ except
+ exit;
+ end;
+ case c of
+ 'x':
+ xl:=xl+tmp;
+ 'y','t':
+ yl:=yl+tmp;
+ else
+ off:=off+tmp;
+ end{of case};
+ end;
+ result:=true;
+end;
+
+function tKonkreteKoordinatenTransformation.transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint;
+var
+ c,d: char;
+ lt,et: extended;
+begin
+ testeAuszerhalb(p);
+ for c:='x' to 'y' do begin
+ result[c]:=off[c];
+ lt:=lnOff[c];
+ et:=0;
+ for d:='x' to 'y' do begin
+ result[c]:=
+ result[c] + p[d]*lin[c,d];
+ lt:=lt+p[d]*lnInt[c,d];
+ et:=et+p[d]*expExp[c,d];
+ end;
+ result[c]:=
+ result[c] + lnFak[c] * ln(lt) + expFak[c] * exp(et);
+ end;
end;
function tKonkreteKoordinatenTransformation.initAbbildung(syntaxtest: boolean; s: string; xscale,yscale: extended; etf: tExprToFloat): boolean;
-var c,d: char;
- i: longint;
- t,u,v: string;
- tmp: extended;
-begin
- result:=false;
- if not assigned(etf) then exit;
- for c:='x' to 'y' do begin
- for d:='x' to 'y' do begin
- lin[c,d]:=0;
- lnInt[c,d]:=0;
- expExp[c,d]:=0;
- end;
- off[c]:=0;
- lnFak[c]:=0;
- expFak[c]:=0;
- lnOff[c]:=1;
- end;
- while pos(' ',s)>0 do
- delete(s,pos(' ',s),1);
- if (not startetMit('(',s)) or
+var
+ c,d: char;
+ i: longint;
+ t,u,v: string;
+ tmp: extended;
+begin
+ result:=false;
+ if not assigned(etf) then exit;
+ for c:='x' to 'y' do begin
+ for d:='x' to 'y' do begin
+ lin[c,d]:=0;
+ lnInt[c,d]:=0;
+ expExp[c,d]:=0;
+ end;
+ off[c]:=0;
+ lnFak[c]:=0;
+ expFak[c]:=0;
+ lnOff[c]:=1;
+ end;
+ while pos(' ',s)>0 do
+ delete(s,pos(' ',s),1);
+ if (not startetMit('(',s)) or
(not endetMit(')',s)) then exit;
- if pos(';',s)=0 then exit;
- t:=erstesArgument(s,';');
- if (t='') or (s='') then exit;
- for c:='x' to 'y' do begin
- while pos('(',t)>0 do begin
- u:=t;
- delete(u,1,pos('(',u));
- if pos(')',u)=0 then exit;
- u:=leftStr(u,pos(')',u)-1);
- i:=pos('(',t);
- while (i>=1) and not (t[i] in ['+','-']) do
- dec(i);
- if i=0 then i:=1;
- v:=copy(t,i,pos('(',t)-i-3);
- if leftStr(v,1)='+' then delete(v,1,1);
- if v='' then tmp:=1
- else if v='-' then tmp:=-1
- else try
- tmp:=etf(syntaxtest,v);
- if c='x' then tmp:=tmp/xscale
- else tmp:=tmp/yscale;
- except
- exit;
- end;
- if copy(t,pos('(',t)-3,3)='log' then begin
- lnFak[c]:=tmp;
- if not findeLineareParameter(syntaxtest,' ',u,xscale,yscale,lnOff[c],lnInt[c,'x'],lnInt[c,'y'],true,etf) then exit;
- end
- else if copy(t,pos('(',t)-3,3)='exp' then begin
- expFak[c]:=tmp;
- tmp:=0;
- if not findeLineareParameter(syntaxtest,' ',u,xscale,yscale,tmp,expExp[c,'x'],expExp[c,'y'],true,etf) then exit;
- if tmp<>0 then exit;
- end
- else exit;
- delete(t,i,pos(')',t)-i+1);
- end;
- if t<>'' then
- if not findeLineareParameter(syntaxtest,c,t,xscale,yscale,off[c],lin[c,'x'],lin[c,'y'],false,etf) then exit;
- t:=s;
- end;
- result:=true;
+ if pos(';',s)=0 then exit;
+ t:=erstesArgument(s,';');
+ if (t='') or (s='') then exit;
+ for c:='x' to 'y' do begin
+ while pos('(',t)>0 do begin
+ u:=t;
+ delete(u,1,pos('(',u));
+ if pos(')',u)=0 then exit;
+ u:=leftStr(u,pos(')',u)-1);
+ i:=pos('(',t);
+ while (i>=1) and not (t[i] in ['+','-']) do
+ dec(i);
+ if i=0 then i:=1;
+ v:=copy(t,i,pos('(',t)-i-3);
+ if leftStr(v,1)='+' then delete(v,1,1);
+ if v='' then tmp:=1
+ else if v='-' then tmp:=-1
+ else try
+ tmp:=etf(syntaxtest,v);
+ if c='x' then tmp:=tmp/xscale
+ else tmp:=tmp/yscale;
+ except
+ exit;
+ end;
+ if copy(t,pos('(',t)-3,3)='log' then begin
+ lnFak[c]:=tmp;
+ if not findeLineareParameter(syntaxtest,' ',u,xscale,yscale,lnOff[c],lnInt[c,'x'],lnInt[c,'y'],true,etf) then exit;
+ end
+ else if copy(t,pos('(',t)-3,3)='exp' then begin
+ expFak[c]:=tmp;
+ tmp:=0;
+ if not findeLineareParameter(syntaxtest,' ',u,xscale,yscale,tmp,expExp[c,'x'],expExp[c,'y'],true,etf) then exit;
+ if tmp<>0 then exit;
+ end
+ else exit;
+ delete(t,i,pos(')',t)-i+1);
+ end;
+ if t<>'' then
+ if not findeLineareParameter(syntaxtest,c,t,xscale,yscale,off[c],lin[c,'x'],lin[c,'y'],false,etf) then exit;
+ t:=s;
+ end;
+ result:=true;
end;
function tKonkreteKoordinatenTransformation.dumpParams: string;
-var c,d: char;
-begin
- result:='';
- for c:='x' to 'y' do begin
- result:=result+#13#10+c+' = ';
- if off[c]<>0 then
- result:=result + floattostr(off[c]) + ' ';
- for d:='x' to 'y' do
- if lin[c,d]<>0 then
- result:=result + '+ ' + floattostr(lin[c,d]) + ' ' + d + ' ';
- if lnFak[c]<>0 then begin
- result:=result + '+ ' + floattostr(lnFak[c])+' log ( ';
- if lnOff[c]<>0 then
- result:=result + floattostr(lnoff[c]) + ' ';
- for d:='x' to 'y' do
- if lnInt[c,d]<>0 then
- result:=result + '+ ' + floattostr(lnInt[c,d]) + ' ' + d + ' ';
- result:=result + ') ';
- end;
- if expFak[c]<>0 then begin
- result:=result + '+ ' + floattostr(expFak[c])+' exp ( ';
- for d:='x' to 'y' do
- if expExp[c,d]<>0 then
- result:=result + '+ ' + floattostr(expExp[c,d]) + ' ' + d + ' ';
- result:=result + ') ';
- end;
- end;
- delete(result,1,2);
+var
+ c,d: char;
+begin
+ result:='';
+ for c:='x' to 'y' do begin
+ result:=result+#13#10+c+' = ';
+ if off[c]<>0 then
+ result:=result + floattostr(off[c]) + ' ';
+ for d:='x' to 'y' do
+ if lin[c,d]<>0 then
+ result:=result + '+ ' + floattostr(lin[c,d]) + ' ' + d + ' ';
+ if lnFak[c]<>0 then begin
+ result:=result + '+ ' + floattostr(lnFak[c])+' log ( ';
+ if lnOff[c]<>0 then
+ result:=result + floattostr(lnoff[c]) + ' ';
+ for d:='x' to 'y' do
+ if lnInt[c,d]<>0 then
+ result:=result + '+ ' + floattostr(lnInt[c,d]) + ' ' + d + ' ';
+ result:=result + ') ';
+ end;
+ if expFak[c]<>0 then begin
+ result:=result + '+ ' + floattostr(expFak[c])+' exp ( ';
+ for d:='x' to 'y' do
+ if expExp[c,d]<>0 then
+ result:=result + '+ ' + floattostr(expExp[c,d]) + ' ' + d + ' ';
+ result:=result + ') ';
+ end;
+ end;
+ delete(result,1,2);
end;
function tKonkreteKoordinatenTransformation.zielausdehnung: t2x2Longint;
-var RandPkt: tExtPoint;
- i,j,k: longint;
- c,d: char;
-begin
- for c:='x' to 'y' do
- for d:='x' to 'y' do
- result[c,d]:=-1;
- for k:=0 to 1 do
- for i:=0 to (in_xs_ts['x']*(1-k)+in_xs_ts['y']*k)-1 do
- for j:=0 to 1 do begin
- RandPkt:=transformiereKoordinaten(
- i*(1-k) + j*k*(in_xs_ts['x']-1),
- j*(1-k)*(in_xs_ts['y']-1) + i*k);
- for c:='x' to 'y' do
- for d:='x' to 'y' do
- if ((i=0) and (j=0)) or ((d='y') xor (result[c,d]>floor(RandPkt[c]) + byte(d='y'))) then
- result[c,d]:=floor(RandPkt[c]) + byte(d='y');
- end;
-end;
-
-function tKonkreteKoordinatenTransformation.xsteps_tsiz: tIntPoint;
-var gr: t2x2Longint;
- c: char;
-begin
- gr:=zielausdehnung;
- for c:='x' to 'y' do
- result[c]:=gr[c,'y']-gr[c,'x']+1;
+var
+ RandPkt: tExtPoint;
+ i,j,k: longint;
+ c,d: char;
+begin
+ for c:='x' to 'y' do
+ for d:='x' to 'y' do
+ result[c,d]:=-1;
+ for k:=0 to 1 do
+ for i:=0 to (in_xs_ts['x']*(1-k)+in_xs_ts['y']*k)-1 do
+ for j:=0 to 1 do begin
+ RandPkt:=transformiereKoordinaten(
+ i*(1-k) + j*k*(in_xs_ts['x']-1),
+ j*(1-k)*(in_xs_ts['y']-1) + i*k);
+ for c:='x' to 'y' do
+ for d:='x' to 'y' do
+ if ((i=0) and (j=0)) or ((d='y') xor (result[c,d]>floor(RandPkt[c]) + byte(d='y'))) then
+ result[c,d]:=floor(RandPkt[c]) + byte(d='y');
+ end;
+end;
+
+procedure tKonkreteKoordinatenTransformation.aktualisiereXsTs;
+var
+ gr: t2x2Longint;
+ c: char;
+begin
+ gr:=zielausdehnung;
+ for c:='x' to 'y' do
+ out_xs_ts[c]:=gr[c,'y']-gr[c,'x']+1;
end;
// tKoordinatenAusschnitt ******************************************************
constructor tKoordinatenAusschnitt.create;
-var c,d: char;
+var
+ c,d: char;
begin
- inherited create;
- for c:='x' to 'y' do
- for d:='x' to 'y' do
- gr[c,d]:=0;
+ inherited create;
+ for c:='x' to 'y' do
+ for d:='x' to 'y' do
+ gr[c,d]:=0;
end;
-constructor tKoordinatenAusschnitt.create(original: tKoordinatenAusschnitt);
-var c,d: char;
+constructor tKoordinatenAusschnitt.create(vorg: tTransformation; xmin,xmax,tmin,tmax: longint);
begin
- inherited create;
- for c:='x' to 'y' do
- for d:='x' to 'y' do
- gr[c,d]:=original.gr[c,d];
+ inherited create;
+ fuegeVorgaengerHinzu(vorg);
+ gr['x','x']:=xmin;
+ gr['x','y']:=xmax;
+ gr['y','x']:=tmin;
+ gr['y','y']:=tmax;
end;
-function tKoordinatenAusschnitt.xsteps_tsiz: tIntPoint;
-var c: char;
+procedure tKoordinatenAusschnitt.aktualisiereXsTs;
+var
+ c: char;
begin
- for c:='x' to 'y' do
- result[c]:=max(0,min(in_xs_ts[c],gr[c,'y']+1)-gr[c,'x']);
+ for c:='x' to 'y' do
+ out_xs_ts[c]:=max(0,min(in_xs_ts[c],gr[c,'y']+1)-gr[c,'x']);
end;
-function tKoordinatenAusschnitt.achsen: t2x2Extended;
-var c,d: char;
+procedure tKoordinatenAusschnitt.aktualisiereAchsen;
+var
+ c,d: char;
begin
- for c:='x' to 'y' do
- if in_xs_ts[c]<=1 then begin
- for d:='x' to 'y' do
- result[c,d]:=in_achsen[c,d];
- if in_achsen[c,'x']<>in_achsen[c,'y'] then
- fehler('Nur eine Koordinate, aber '+floattostr(in_achsen[c,'x'])+' = '+c+'start <> '+c+'stop = '+floattostr(in_achsen[c,'y'])+'!');
- end
- else
- for d:='x' to 'y' do
- result[c,d]:=in_achsen[c,'x'] + gr[c,d]/(in_xs_ts[c]-1)*(in_achsen[c,'y']-in_achsen[c,'x']);
+ for c:='x' to 'y' do
+ if in_xs_ts[c]<=1 then begin
+ for d:='x' to 'y' do
+ out_achsen[c,d]:=in_achsen[c,d];
+ if in_achsen[c,'x']<>in_achsen[c,'y'] then
+ fehler('Nur eine Koordinate, aber '+floattostr(in_achsen[c,'x'])+' = '+c+'start <> '+c+'stop = '+floattostr(in_achsen[c,'y'])+'!');
+ end
+ else
+ for d:='x' to 'y' do
+ out_achsen[c,d]:=in_achsen[c,'x'] + gr[c,d]/(in_xs_ts[c]-1)*(in_achsen[c,'y']-in_achsen[c,'x']);
end;
-function tKoordinatenAusschnitt.transformiereKoordinaten(const p: tExtPoint): tExtPoint;
-var c: char;
+function tKoordinatenAusschnitt.transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint;
+var
+ c: char;
begin
- testeAuszerhalb(p);
- for c:='x' to 'y' do
- result[c]:=max(0,min(gr[c,'y'],p[c])-gr[c,'x']);
+ testeAuszerhalb(p);
+ for c:='x' to 'y' do
+ result[c]:=max(0,min(gr[c,'y'],p[c])-gr[c,'x']);
end;
function tKoordinatenAusschnitt.dumpParams: string;
begin
- result:='Koordinatenausschnitt: '+inttostr(gr['x','x'])+'..'+inttostr(gr['x','y'])+' x '+inttostr(gr['y','x'])+'..'+inttostr(gr['y','y']);
+ result:='Koordinatenausschnitt: '+inttostr(gr['x','x'])+'..'+inttostr(gr['x','y'])+' x '+inttostr(gr['y','x'])+'..'+inttostr(gr['y','y']);
end;
// tAgglomeration **************************************************************
@@ -1486,55 +1819,68 @@ end;
constructor tAgglomeration.create;
begin
inherited create;
- schritt:=0;
- anzahl:=0;
+ schritt:=-1;
horizontal:=false;
end;
-constructor tAgglomeration.create(original: tAgglomeration);
+procedure tAgglomeration.addKomponente(tr: tTransformation);
begin
- inherited create;
- schritt:=original.schritt;
- anzahl:=original.anzahl;
- horizontal:=original.horizontal;
+ fuegeVorgaengerHinzu(tr);
end;
-function tAgglomeration.xsteps_tsiz: tIntPoint;
+procedure tAgglomeration.aktualisiereXsTs;
var
c: char;
begin
for c:='x' to 'y' do
- result[c]:=in_xs_ts[c]*(1+(anzahl-1)*byte(horizontal xor (c='y')));
+ out_xs_ts[c]:=in_xs_ts[c]*(1+(length(vorgaenger)-1)*byte(horizontal xor (c='y')));
end;
-function tAgglomeration.achsen: t2x2Extended;
+procedure tAgglomeration.aktualisiereAchsen;
var
c,d: char;
begin
for c:='x' to 'y' do
- if in_xs_ts[c]<=1 then begin
+ if in_xs_ts[c]<=1 then begin // diese Dimension gibt es in der Quelle nicht
+ if (horizontal xor (c='y')) and (schritt<0) then
+ fehler('Die Richtung einer Agglomeration ohne explizite Schrittweite kann nicht senkrecht zur Dimension eindimensionaler Daten sein!');
for d:='x' to 'y' do
- result[c,d]:=in_achsen[c,d] + schritt*(anzahl-1)*byte((horizontal xor (c='y')) and (d='y'));
+ out_achsen[c,d]:=in_achsen[c,d] + schritt*(length(vorgaenger)-1)*byte((horizontal xor (c='y')) and (d='y'));
if in_achsen[c,'x']<>in_achsen[c,'y'] then
fehler('Nur eine Koordinate, aber '+floattostr(in_achsen[c,'x'])+' = '+c+'start <> '+c+'stop = '+floattostr(in_achsen[c,'y'])+'!');
end
- else begin
- if horizontal xor (c='y') then
- fehler('In der Richtung der Agglomeration ('+c+') können nicht mehrere Daten liegen!');
+ else // diese Dimension gibt es in der Quelle
for d:='x' to 'y' do
- result[c,d]:=in_achsen[c,d];
- end;
+ out_achsen[c,d]:=
+ in_achsen[c,d] +
+ (in_achsen[c,'y']-in_achsen[c,'x'])/
+ (1+1/in_xs_ts[c]) *
+ (length(vorgaenger)-1) *
+ byte((horizontal xor (c='y')) and (d='y'));
end;
-function tAgglomeration.transformiereKoordinaten(const p: tExtPoint): tExtPoint;
+function tAgglomeration.wertZuPositionAufAchse(const l: tLage; x: extended): extended;
+var
+ i: longint;
+ c: char;
begin
- testeAuszerhalb(p);
- result:=p; // es ist etwas unpräzise, schließlich landet p des i-ten Datensatzes auf p + i * schritt * (byte(horizontal);byte(not horizontal))
+ i:=0;
+ if horizontal xor not (l in [lOben,lUnten]) then begin
+ c:=char(ord('x')+byte(l in [lOben,lUnten]));
+ while (i<length(vorgaenger)) and (vorgaenger[i].achsen[c,'y']<x) do
+ inc(i);
+ end;
+
+ if (i>=length(vorgaenger)) or
+ (vorgaenger[i].achsen[c,'x']>x) then result:=0
+ else result:=vorgaenger[i].wertZuPositionAufAchse(l,x);
+
+ result:=(result+i)/length(vorgaenger);
end;
function tAgglomeration.dumpParams: string;
begin
- result:='Agglomeration: '+inttostr(anzahl)+'x ';
+ result:='Agglomeration: '+inttostr(length(vorgaenger))+'x ';
if horizontal then
result:=result+'horizont'
else
@@ -1546,475 +1892,462 @@ end;
constructor tWerteKnickTransformation.create;
begin
- inherited create;
- setlength(parameter,0);
-end;
-
-constructor tWerteKnickTransformation.create(original: tWerteKnickTransformation);
-var i: longint;
-begin
- inherited create;
- setlength(parameter,length(original.parameter));
- for i:=0 to length(parameter)-1 do
- parameter[i]:=original.parameter[i];
+ inherited create;
+ setlength(parameter,0);
end;
destructor tWerteKnickTransformation.destroy;
begin
- setlength(parameter,0);
- inherited destroy;
+ setlength(parameter,0);
+ inherited destroy;
end;
-function tWerteKnickTransformation.transformiereWert(const x: extended): extended;
-var i: longint;
+function tWerteKnickTransformation.transformiereWertEinzeln(const x: extended): extended;
+var
+ i: longint;
begin
- if x>=parameter[length(parameter)-2] then begin
- result:=parameter[length(parameter)-1];
- exit;
- end;
- i:=0;
- while (i<length(parameter)-2) and (x>=parameter[i+2]) do
- inc(i,2);
- result:=x-parameter[i];
- result:=result/(parameter[i+2]-parameter[i]);
- result:=parameter[i+1]+result*(parameter[i+3]-parameter[i+1])
+ if x>=parameter[length(parameter)-2] then begin
+ result:=parameter[length(parameter)-1];
+ exit;
+ end;
+ i:=0;
+ while (i<length(parameter)-2) and (x>=parameter[i+2]) do
+ inc(i,2);
+ result:=x-parameter[i];
+ result:=result/(parameter[i+2]-parameter[i]);
+ result:=parameter[i+1]+result*(parameter[i+3]-parameter[i+1])
end;
function tWerteKnickTransformation.dumpParams: string;
-var i: longint;
+var
+ i: longint;
begin
- result:='Knick:';
- for i:=0 to length(parameter) div 2 - 1 do
- result:=result + ' (' + floattostr(parameter[2*i])+';'+floattostr(parameter[2*i+1])+')';
+ result:='Knick:';
+ for i:=0 to length(parameter) div 2 - 1 do
+ result:=result + ' (' + floattostr(parameter[2*i])+';'+floattostr(parameter[2*i+1])+')';
end;
// tWerteLogTransformation *****************************************************
constructor tWerteLogTransformation.create;
begin
- inherited create;
- logMin:=0.1;
-end;
-
-constructor tWerteLogTransformation.create(original: tWerteLogTransformation);
-begin
- inherited create;
- logMin:=original.logMin;
+ inherited create;
+ logMin:=0.1;
end;
-function tWerteLogTransformation.transformiereWert(const x: extended): extended;
+function tWerteLogTransformation.transformiereWertEinzeln(const x: extended): extended;
begin
- result:=ln(max(x/logMin,1))/ln(max(1/logMin,1));
+ result:=ln(max(x/logMin,1))/ln(max(1/logMin,1));
end;
function tWerteLogTransformation.dumpParams: string;
begin
- result:='Logarithmus: '+floattostr(logMin);
+ result:='Logarithmus: '+floattostr(logMin);
end;
// tWerteLogAbsTransformation **************************************************
constructor tWerteLogAbsTransformation.create;
begin
- inherited create;
- logSkala:=0.1;
-end;
-
-constructor tWerteLogAbsTransformation.create(original: tWerteLogAbsTransformation);
-begin
- inherited create;
- logSkala:=original.logSkala;
+ inherited create;
+ logSkala:=0.1;
end;
-function tWerteLogAbsTransformation.transformiereWert(const x: extended): extended;
+function tWerteLogAbsTransformation.transformiereWertEinzeln(const x: extended): extended;
begin
- result:=(1+sign(x-0.5)*ln(logSkala*abs(x-0.5)+1)/ln(logSkala*0.5+1))/2;
+ result:=(1+sign(x-0.5)*ln(logSkala*abs(x-0.5)+1)/ln(logSkala*0.5+1))/2;
end;
function tWerteLogAbsTransformation.dumpParams: string;
begin
- result:='Betragslogarithmus: '+floattostr(logSkala);
+ result:='Betragslogarithmus: '+floattostr(logSkala);
end;
// tWerteAbsTransformation *****************************************************
constructor tWerteAbsTransformation.create;
begin
- inherited create;
+ inherited create;
end;
-function tWerteAbsTransformation.transformiereWert(const x: extended): extended;
+function tWerteAbsTransformation.transformiereWertEinzeln(const x: extended): extended;
begin
- result:=2*abs(x-0.5);
+ result:=2*abs(x-0.5);
end;
function tWerteAbsTransformation.dumpParams: string;
begin
- result:='Betrag';
+ result:='Betrag';
end;
// tTransformationen ***********************************************************
-
+(*
constructor tTransformationen.create;
begin
- inherited create;
- setlength(Schritte,0);
+ inherited create;
+ setlength(Schritte,0);
end;
constructor tTransformationen.create(original: tTransformationen);
begin
- inherited create;
- setlength(Schritte,0);
- if not kopiereVon(original) then
- halt(1);
+ inherited create;
+ setlength(Schritte,0);
+ if not kopiereVon(original) then
+ halt(1);
end;
destructor tTransformationen.destroy;
-var i: longint;
+var
+ i: longint;
begin
- for i:=0 to length(Schritte)-1 do
- if assigned(Schritte[i]) then
- Schritte[i].free;
- setlength(Schritte,0);
- inherited destroy;
+ for i:=0 to length(Schritte)-1 do
+ if assigned(Schritte[i]) then
+ Schritte[i].free;
+ setlength(Schritte,0);
+ inherited destroy;
end;
function tTransformationen.gibInhalt(ii: longint): tTransformation;
begin
- result:=Schritte[ii];
+ result:=Schritte[ii];
end;
procedure tTransformationen.nimmInhalt(ii: longint; inh: tTransformation);
begin
- Schritte[ii]:=inh;
+ Schritte[ii]:=inh;
end;
function tTransformationen.rXstart: extended;
begin
- result:=gibAchsen['x','x'];
+ result:=gibAchsen['x','x'];
end;
procedure tTransformationen.wXstart(x: extended);
begin
- if kCount>0 then begin
- gibAus('Will xstart schreiben, aber der kCount ist '+inttostr(kCount),3);
- raise exception.create('Will xstart schreiben, aber der kCount ist '+inttostr(kCount));
- end;
- _xtstao['x','x']:=x;
+ if kCount>0 then begin
+ gibAus('Will xstart schreiben, aber der kCount ist '+inttostr(kCount),3);
+ raise exception.create('Will xstart schreiben, aber der kCount ist '+inttostr(kCount));
+ end;
+ _xtstao['x','x']:=x;
end;
function tTransformationen.rXstop: extended;
begin
- result:=gibAchsen['x','y'];
+ result:=gibAchsen['x','y'];
end;
procedure tTransformationen.wXstop(x: extended);
begin
- if kCount>0 then begin
- gibAus('Will xstop schreiben, aber der kCount ist '+inttostr(kCount),3);
- raise exception.create('Will xstop schreiben, aber der kCount ist '+inttostr(kCount));
- end;
- _xtstao['x','y']:=x;
+ if kCount>0 then begin
+ gibAus('Will xstop schreiben, aber der kCount ist '+inttostr(kCount),3);
+ raise exception.create('Will xstop schreiben, aber der kCount ist '+inttostr(kCount));
+ end;
+ _xtstao['x','y']:=x;
end;
function tTransformationen.rTstart: extended;
begin
- result:=gibAchsen['y','x'];
+ result:=gibAchsen['y','x'];
end;
procedure tTransformationen.wTstart(t: extended);
begin
- if kCount>0 then begin
- gibAus('Will tstart schreiben, aber der kCount ist '+inttostr(kCount),3);
- raise exception.create('Will tstart schreiben, aber der kCount ist '+inttostr(kCount));
- end;
- _xtstao['y','x']:=t;
+ if kCount>0 then begin
+ gibAus('Will tstart schreiben, aber der kCount ist '+inttostr(kCount),3);
+ raise exception.create('Will tstart schreiben, aber der kCount ist '+inttostr(kCount));
+ end;
+ _xtstao['y','x']:=t;
end;
function tTransformationen.rTstop: extended;
begin
- result:=gibAchsen['y','y'];
+ result:=gibAchsen['y','y'];
end;
procedure tTransformationen.wTstop(t: extended);
begin
- if kCount>0 then begin
- gibAus('Will tstop schreiben, aber der kCount ist '+inttostr(kCount),3);
- raise exception.create('Will tstop schreiben, aber der kCount ist '+inttostr(kCount));
- end;
- _xtstao['y','y']:=t;
+ if kCount>0 then begin
+ gibAus('Will tstop schreiben, aber der kCount ist '+inttostr(kCount),3);
+ raise exception.create('Will tstop schreiben, aber der kCount ist '+inttostr(kCount));
+ end;
+ _xtstao['y','y']:=t;
end;
function tTransformationen.rWmin: extended;
begin
- result:=_wmia['x'];
+ result:=_wmia['x'];
end;
procedure tTransformationen.wWmin(w: extended);
begin
- _wmia['x']:=w;
+ _wmia['x']:=w;
end;
function tTransformationen.rWmax: extended;
begin
- result:=_wmia['y'];
+ result:=_wmia['y'];
end;
procedure tTransformationen.wWmax(w: extended);
begin
- _wmia['y']:=w;
+ _wmia['y']:=w;
end;
function tTransformationen.rXsteps: longint;
begin
- result:=xsteps_tsiz['x'];
+ result:=xsteps_tsiz['x'];
end;
procedure tTransformationen.wXsteps(x: longint);
begin
- if kCount>0 then begin
- gibAus('Will xsteps schreiben, aber der kCount ist '+inttostr(kCount),3);
- raise exception.create('Will xsteps schreiben, aber der kCount ist '+inttostr(kCount));
- end;
- _xs_ts['x']:=x;
+ if kCount>0 then begin
+ gibAus('Will xsteps schreiben, aber der kCount ist '+inttostr(kCount),3);
+ raise exception.create('Will xsteps schreiben, aber der kCount ist '+inttostr(kCount));
+ end;
+ _xs_ts['x']:=x;
end;
function tTransformationen.rTsiz: longint;
begin
- result:=xsteps_tsiz['y'];
+ result:=xsteps_tsiz['y'];
end;
function tTransformationen.xsteps_tsiz: tIntPoint;
begin
- if count=0 then result:=_xs_ts
- else result:=last.xsteps_tsiz;
+ if count=0 then result:=_xs_ts
+ else result:=last.xsteps_tsiz;
end;
procedure tTransformationen.wTsiz(t: longint);
begin
- if kCount>0 then begin
- gibAus('Will tsiz schreiben, aber der kCount ist '+inttostr(kCount),3);
- raise exception.create('Will tsiz schreiben, aber der kCount ist '+inttostr(kCount));
- end;
- _xs_ts['y']:=t;
+ if kCount>0 then begin
+ gibAus('Will tsiz schreiben, aber der kCount ist '+inttostr(kCount),3);
+ raise exception.create('Will tsiz schreiben, aber der kCount ist '+inttostr(kCount));
+ end;
+ _xs_ts['y']:=t;
end;
function tTransformationen.count: longint;
begin
- result:=length(Schritte);
+ result:=length(Schritte);
end;
function tTransformationen.kCount: longint;
-var i: longint;
+var
+ i: longint;
begin
- result:=0;
- for i:=0 to count-1 do
- if Inhalt[i] is tKoordinatenTransformation then
- inc(result);
+ result:=0;
+ for i:=0 to count-1 do
+ if Inhalt[i] is tKoordinatenTransformation then
+ inc(result);
end;
function tTransformationen.wCount: longint;
-var i: longint;
+var
+ i: longint;
begin
- result:=0;
- for i:=0 to count-1 do
- if Inhalt[i] is tWerteTransformation then
- inc(result);
+ result:=0;
+ for i:=0 to count-1 do
+ if Inhalt[i] is tWerteTransformation then
+ inc(result);
end;
procedure tTransformationen.achsenUndGroeszeAktualisieren;
-var i: longint;
+var
+ i: longint;
begin
- for i:=0 to count-1 do begin
- if i=0 then begin
- schritte[i].in_xs_ts:=_xs_ts;
- schritte[i].in_achsen:=_xtstao;
- end
- else begin
- schritte[i].in_xs_ts:=schritte[i-1].xsteps_tsiz;
- schritte[i].in_achsen:=schritte[i-1].achsen;
- end
- end;
+ for i:=0 to count-1 do begin
+ if i=0 then begin
+ schritte[i].in_xs_ts:=_xs_ts;
+ schritte[i].in_achsen:=_xtstao;
+ end
+ else begin
+ schritte[i].in_xs_ts:=schritte[i-1].xsteps_tsiz;
+ schritte[i].in_achsen:=schritte[i-1].achsen;
+ end
+ end;
end;
function tTransformationen.gibAchsen: t2x2Extended;
begin
- if count=0 then result:=_xtstao
- else result:=last.achsen;
+ if count=0 then result:=_xtstao
+ else result:=last.achsen;
end;
function tTransformationen.last: tTransformation;
begin
- result:=gibInhalt(count-1);
+ result:=gibInhalt(count-1);
end;
procedure tTransformationen.clear;
-var i: longint;
+var
+ i: longint;
begin
- for i:=0 to length(Schritte)-1 do
- if assigned(Schritte[i]) then
- Schritte[i].free;
- setlength(Schritte,0);
+ for i:=0 to length(Schritte)-1 do
+ if assigned(Schritte[i]) then
+ Schritte[i].free;
+ setlength(Schritte,0);
end;
procedure tTransformationen.clearWerte;
-var i,j: longint;
-begin
- for i:=0 to length(Schritte)-1 do
- if assigned(Schritte[i]) and (Schritte[i] is tWerteTransformation) then
- Schritte[i].free;
- j:=0;
- for i:=0 to length(Schritte)-1 do
- if assigned(Schritte[i]) then begin
- Schritte[j]:=Schritte[i];
- inc(j);
- end;
- setlength(Schritte,j);
- achsenUndGroeszeAktualisieren;
+var
+ i,j: longint;
+begin
+ for i:=0 to length(Schritte)-1 do
+ if assigned(Schritte[i]) and (Schritte[i] is tWerteTransformation) then
+ Schritte[i].free;
+ j:=0;
+ for i:=0 to length(Schritte)-1 do
+ if assigned(Schritte[i]) then begin
+ Schritte[j]:=Schritte[i];
+ inc(j);
+ end;
+ setlength(Schritte,j);
+ achsenUndGroeszeAktualisieren;
end;
procedure tTransformationen.addFFT(hor,ver: boolean);
begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tFFTTransformation.create;
- with last as tFFTTransformation do begin
- horizontal:=hor;
- vertikal:=ver;
- end;
- achsenUndGroeszeAktualisieren;
+ setlength(Schritte,length(Schritte)+1);
+ Schritte[length(Schritte)-1]:=tFFTTransformation.create;
+ with last as tFFTTransformation do begin
+ horizontal:=hor;
+ vertikal:=ver;
+ end;
+ achsenUndGroeszeAktualisieren;
end;
procedure tTransformationen.AddSpiegelung;
begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tSpiegelungsTransformation.create;
- achsenUndGroeszeAktualisieren;
+ setlength(Schritte,length(Schritte)+1);
+ Schritte[length(Schritte)-1]:=tSpiegelungsTransformation.create;
+ achsenUndGroeszeAktualisieren;
end;
function tTransformationen.add(inh: tTransformation): boolean;
begin
- result:=false;
- setlength(Schritte,length(Schritte)+1);
- if inh is tFFTTransformation then
- Schritte[length(Schritte)-1]:=tFFTTransformation.create(inh as tFFTTransformation)
- else if inh is tKoordinatenAusschnitt then
- Schritte[length(Schritte)-1]:=tKoordinatenAusschnitt.create(inh as tKoordinatenAusschnitt)
- else if inh is tKonkreteKoordinatenTransformation then
- Schritte[length(Schritte)-1]:=tKonkreteKoordinatenTransformation.create(inh as tKonkreteKoordinatenTransformation)
- else if inh is tSpiegelungsTransformation then
- Schritte[length(Schritte)-1]:=tSpiegelungsTransformation.create
- else if inh is tWerteKnickTransformation then
- Schritte[length(Schritte)-1]:=tWerteKnickTransformation.create(inh as tWerteKnickTransformation)
- else if inh is tWerteLogTransformation then
- Schritte[length(Schritte)-1]:=tWerteLogTransformation.create(inh as tWerteLogTransformation)
- else if inh is tWerteLogAbsTransformation then
- Schritte[length(Schritte)-1]:=tWerteLogAbsTransformation.create(inh as tWerteLogAbsTransformation)
- else if inh is tWerteAbsTransformation then
- Schritte[length(Schritte)-1]:=tWerteAbsTransformation.create
- else begin
- gibAus('Ich kann unbekannten Transformationstyp ('+inh.ClassName+') nicht einfügen, da ich ihn nicht kopieren kann!',3);
- exit;
- end;
- achsenUndGroeszeAktualisieren;
- result:=true;
+ result:=false;
+ setlength(Schritte,length(Schritte)+1);
+ if inh is tFFTTransformation then
+ Schritte[length(Schritte)-1]:=tFFTTransformation.create(inh as tFFTTransformation)
+ else if inh is tKoordinatenAusschnitt then
+ Schritte[length(Schritte)-1]:=tKoordinatenAusschnitt.create(inh as tKoordinatenAusschnitt)
+ else if inh is tAgglomeration then
+ Schritte[length(Schritte)-1]:=tAgglomeration.create(inh as tAgglomeration)
+ else if inh is tKonkreteKoordinatenTransformation then
+ Schritte[length(Schritte)-1]:=tKonkreteKoordinatenTransformation.create(inh as tKonkreteKoordinatenTransformation)
+ else if inh is tSpiegelungsTransformation then
+ Schritte[length(Schritte)-1]:=tSpiegelungsTransformation.create
+ else if inh is tWerteKnickTransformation then
+ Schritte[length(Schritte)-1]:=tWerteKnickTransformation.create(inh as tWerteKnickTransformation)
+ else if inh is tWerteLogTransformation then
+ Schritte[length(Schritte)-1]:=tWerteLogTransformation.create(inh as tWerteLogTransformation)
+ else if inh is tWerteLogAbsTransformation then
+ Schritte[length(Schritte)-1]:=tWerteLogAbsTransformation.create(inh as tWerteLogAbsTransformation)
+ else if inh is tWerteAbsTransformation then
+ Schritte[length(Schritte)-1]:=tWerteAbsTransformation.create
+ else begin
+ gibAus('Ich kann unbekannten Transformationstyp ('+inh.ClassName+') nicht einfügen, da ich ihn nicht kopieren kann!',3);
+ exit;
+ end;
+ achsenUndGroeszeAktualisieren;
+ result:=true;
end;
function tTransformationen.add(st: boolean; s: string; f: tMyStringlist; etf: tExprToFloat): boolean;
-var i: longint;
-begin
- result:=false;
- if s='Knick' then begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tWerteKnickTransformation.create;
- with (last as tWerteKnickTransformation) do begin
- setlength(parameter,2);
- parameter[0]:=0;
- parameter[1]:=0;
- repeat
- if not f.metaReadln(s,true) then begin
- gibAus('Unerwartetes Dateiende!',3);
- exit;
- end;
- if s='Ende' then break;
- setlength(parameter,length(parameter)+2);
- parameter[length(parameter)-2]:=
- etf(st,erstesArgument(s,' '));
- if s='' then s:=inttostr(length(parameter) div 2 - 1);
- parameter[length(parameter)-1]:=
- etf(st,s);
- until false;
- for i:=0 to length(parameter)-1 do
- if odd(i) then
- parameter[i]:=
- parameter[i]/
- (length(parameter) div 2);
- setlength(parameter,length(parameter)+2);
- parameter[length(parameter)-2]:= 1;
- parameter[length(parameter)-1]:= 1;
- end;
- result:=true;
- exit;
- end;
- if startetMit('Log:',s) then begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tWerteLogTransformation.create;
- (last as tWerteLogTransformation).logMin:=etf(st,s);
- result:=true;
- exit;
- end;
- if startetMit('AbsLog:',s) then begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tWerteLogAbsTransformation.create;
- (last as tWerteLogAbsTransformation).logSkala:=etf(st,s);
- result:=true;
- exit;
- end;
- if s='Abs' then begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tWerteAbsTransformation.create;
- result:=true;
- exit;
- end;
- gibAus('Kenne Nachbearbeitungsmethode '''+s+''' nicht!',3);
+var
+ i: longint;
+begin
+ result:=false;
+ if s='Knick' then begin
+ setlength(Schritte,length(Schritte)+1);
+ Schritte[length(Schritte)-1]:=tWerteKnickTransformation.create;
+ with (last as tWerteKnickTransformation) do begin
+ setlength(parameter,2);
+ parameter[0]:=0;
+ parameter[1]:=0;
+ repeat
+ if not f.metaReadln(s,true) then begin
+ gibAus('Unerwartetes Dateiende!',3);
+ exit;
+ end;
+ if s='Ende' then break;
+ setlength(parameter,length(parameter)+2);
+ parameter[length(parameter)-2]:=
+ etf(st,erstesArgument(s,' '));
+ if s='' then s:=inttostr(length(parameter) div 2 - 1);
+ parameter[length(parameter)-1]:=
+ etf(st,s);
+ until false;
+ for i:=0 to length(parameter)-1 do
+ if odd(i) then
+ parameter[i]:=
+ parameter[i]/
+ (length(parameter) div 2);
+ setlength(parameter,length(parameter)+2);
+ parameter[length(parameter)-2]:= 1;
+ parameter[length(parameter)-1]:= 1;
+ end;
+ result:=true;
+ exit;
+ end;
+ if startetMit('Log:',s) then begin
+ setlength(Schritte,length(Schritte)+1);
+ Schritte[length(Schritte)-1]:=tWerteLogTransformation.create;
+ (last as tWerteLogTransformation).logMin:=etf(st,s);
+ result:=true;
+ exit;
+ end;
+ if startetMit('AbsLog:',s) then begin
+ setlength(Schritte,length(Schritte)+1);
+ Schritte[length(Schritte)-1]:=tWerteLogAbsTransformation.create;
+ (last as tWerteLogAbsTransformation).logSkala:=etf(st,s);
+ result:=true;
+ exit;
+ end;
+ if s='Abs' then begin
+ setlength(Schritte,length(Schritte)+1);
+ Schritte[length(Schritte)-1]:=tWerteAbsTransformation.create;
+ result:=true;
+ exit;
+ end;
+ gibAus('Kenne Nachbearbeitungsmethode '''+s+''' nicht!',3);
end;
function tTransformationen.add(syntaxtest: boolean; s: string; xscale,yscale: extended; etf: tExprToFloat): boolean;
begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tKonkreteKoordinatenTransformation.create;
- result:=(last as tKonkreteKoordinatenTransformation).initAbbildung(syntaxtest,s,xscale,yscale,etf);
- achsenUndGroeszeAktualisieren;
+ setlength(Schritte,length(Schritte)+1);
+ Schritte[length(Schritte)-1]:=tKonkreteKoordinatenTransformation.create;
+ result:=(last as tKonkreteKoordinatenTransformation).initAbbildung(syntaxtest,s,xscale,yscale,etf);
+ achsenUndGroeszeAktualisieren;
end;
function tTransformationen.append(inhs: tTransformationen): boolean;
-var i: longint;
+var
+ i: longint;
begin
- result:=true;
- for i:=0 to inhs.count-1 do
- result:=result and add(inhs[i]);
- achsenUndGroeszeAktualisieren;
+ result:=true;
+ for i:=0 to inhs.count-1 do
+ result:=result and add(inhs[i]);
+ achsenUndGroeszeAktualisieren;
end;
procedure tTransformationen.addAusschnitt(xmin,xmax,tmin,tmax: longint);
begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tKoordinatenAusschnitt.create;
- (last as tKoordinatenAusschnitt).gr['x','x']:=xmin;
- (last as tKoordinatenAusschnitt).gr['x','y']:=xmax;
- (last as tKoordinatenAusschnitt).gr['y','x']:=tmin;
- (last as tKoordinatenAusschnitt).gr['y','y']:=tmax;
- achsenUndGroeszeAktualisieren;
+ setlength(Schritte,length(Schritte)+1);
+ Schritte[length(Schritte)-1]:=tKoordinatenAusschnitt.create;
+ (last as tKoordinatenAusschnitt).gr['x','x']:=xmin;
+ (last as tKoordinatenAusschnitt).gr['x','y']:=xmax;
+ (last as tKoordinatenAusschnitt).gr['y','x']:=tmin;
+ (last as tKoordinatenAusschnitt).gr['y','y']:=tmax;
+ achsenUndGroeszeAktualisieren;
end;
function tTransformationen.addAgglomeration(horizontal: boolean; schritt: extended; anzahl: longint): boolean;
begin
result:=false;
- if horizontal and (xsteps<>1) then begin
- gibAus('Horizontale Agglomeration über in x-Richtung ausgedehnte Werte ist nicht erlaubt!',3);
- exit;
- end;
- if (not horizontal) and (tsiz<>1) then begin
- gibAus('Vertikale Agglomeration über in t-Richtung ausgedehnte Werte ist nicht erlaubt!',3);
+ if (xsteps_tsiz[char(ord('y')-byte(horizontal))]>1) xor (schritt<0) then begin
+ gibAus('Eine explizite Schrittweite ist genau dann anzugeben, wenn die Werte in der Agglomerationsrichtung keine Ausdehnung haben!',3);
exit;
end;
setlength(Schritte,length(Schritte)+1);
@@ -2028,80 +2361,150 @@ end;
function tTransformationen.kopiereVon(original: tTransformationen): boolean;
begin
- clear;
- _xs_ts:=original._xs_ts;
- _xtstao:=original._xtstao;
- _wmia:=original._wmia;
- result:=append(original);
+ clear;
+ _xs_ts:=original._xs_ts;
+ _xtstao:=original._xtstao;
+ _wmia:=original._wmia;
+ result:=append(original);
end;
function tTransformationen.transformiereKoordinaten(const lage: tLage; const x: extended): extended;
-var p: tExtPoint;
- c,d: char;
+var
+ p: tExtPoint;
+ c,d: char;
begin
- c:=char(ord('x')+byte(not(lage in [lOben,lUnten])));
- d:=char(ord('x')+byte(lage in [lOben,lUnten]));
- if lage in [lLinks,lUnten] then p[d]:=0
- else p[d]:=1;
+ c:=char(ord('x')+byte(not(lage in [lOben,lUnten])));
+ d:=char(ord('x')+byte(lage in [lOben,lUnten]));
- p[c]:=(x-gibAchsen[c,'x'])/(gibAchsen[c,'y']-gibAchsen[c,'x']);
- for d:='x' to 'y' do
- p[d]:=p[d]*(_xs_ts[d]-1);
- p:=transformiereKoordinaten(p);
- result:=p[c]/xsteps_tsiz[c];
+ p[d]:=byte(lage in [lRechts,lOben]);
+ p[c]:=(x-_xtstao[c,'x'])/(_xtstao[c,'y']-_xtstao[c,'x']);
+ for d:='x' to 'y' do
+ p[d]:=p[d]*(_xs_ts[d]-1);
+ p:=transformiereKoordinaten(p);
+ result:=p[c]/xsteps_tsiz[c]; writeln(' ',floattostr(result));
end;
function tTransformationen.transformiereKoordinaten(const x,y: extended): tExtPoint;
begin
- result['x']:=x;
- result['y']:=y;
- result:=transformiereKoordinaten(result);
+ result['x']:=x;
+ result['y']:=y;
+ result:=transformiereKoordinaten(result);
end;
function tTransformationen.transformiereKoordinaten(const p: tExtPoint): tExtPoint;
-var i: longint;
+var
+ i: longint;
begin
- result:=p;
- for i:=0 to count-1 do
- result:=inhalt[i].transformiereKoordinaten(result);
+ result:=p;
+ for i:=0 to count-1 do
+ result:=inhalt[i].transformiereKoordinaten(result);
end;
function tTransformationen.transformiereWert(const x: extended): extended;
-var i: longint;
+var
+ i: longint;
begin
- result:=x;
- for i:=0 to count-1 do
- result:=inhalt[i].transformiereWert(result);
+ result:=x;
+ for i:=0 to count-1 do
+ result:=inhalt[i].transformiereWert(result);
end;
function tTransformationen.dumpParams: string;
-var i: longint;
+var
+ i: longint;
begin
- result:=inttostr(xsteps)+' x '+inttostr(tsiz)+' ('+floattostr(xstart)+'..'+floattostr(xstop)+' x '+floattostr(tstart)+'..'+floattostr(tstop)+')';
- for i:=0 to count-1 do
- result:=result+#10' '+inhalt[i].dumpParams;
+ result:=inttostr(xsteps)+' x '+inttostr(tsiz)+' ('+floattostr(xstart)+'..'+floattostr(xstop)+' x '+floattostr(tstart)+'..'+floattostr(tstop)+')';
+ for i:=0 to count-1 do
+ result:=result+#10' '+inhalt[i].dumpParams;
end;
procedure tTransformationen.berechneZielausdehnung(out grenzen: t2x2Longint);
-var RandPkt: tExtPoint;
- i,j,k: longint;
- c,d: char;
-begin
- for c:='x' to 'y' do
- for d:='x' to 'y' do
- grenzen[c,d]:=-1;
- for k:=0 to 1 do
- for i:=0 to (_xs_ts['x']*(1-k)+_xs_ts['y']*k)-1 do
- for j:=0 to 1 do begin
- RandPkt:=transformiereKoordinaten(
- i*(1-k) + j*k*(_xs_ts['x']-1),
- j*(1-k)*(_xs_ts['y']-1) + i*k);
- for c:='x' to 'y' do
- for d:='x' to 'y' do
- if ((d='y') xor (grenzen[c,d]>floor(RandPkt[c]) + byte(d='y'))) or
+var
+ RandPkt: tExtPoint;
+ i,j,k: longint;
+ c,d: char;
+begin
+ for c:='x' to 'y' do
+ for d:='x' to 'y' do
+ grenzen[c,d]:=-1;
+ for k:=0 to 1 do
+ for i:=0 to (_xs_ts['x']*(1-k)+_xs_ts['y']*k)-1 do
+ for j:=0 to 1 do begin
+ RandPkt:=transformiereKoordinaten(
+ i*(1-k) + j*k*(_xs_ts['x']-1),
+ j*(1-k)*(_xs_ts['y']-1) + i*k);
+ for c:='x' to 'y' do
+ for d:='x' to 'y' do
+ if ((d='y') xor (grenzen[c,d]>floor(RandPkt[c]) + byte(d='y'))) or
((k=0) and (i=0) and (j=0)) then
- grenzen[c,d]:=floor(RandPkt[c]) + byte(d='y');
- end;
+ grenzen[c,d]:=floor(RandPkt[c]) + byte(d='y');
+ end;
+end;
+*)
+
+function liesTWerteTransformationen(st: boolean; s: string; f: tMyStringlist; etf: tExprToFloat; var tr: tTransformation): boolean;
+var
+ i: longint;
+ tmp: tTransformation;
+begin
+ result:=false;
+ if s='Knick' then begin
+ tmp:=tWerteKnickTransformation.create;
+ with (tmp as tWerteKnickTransformation) do begin
+ setlength(parameter,2);
+ parameter[0]:=0;
+ parameter[1]:=0;
+ repeat
+ if not f.metaReadln(s,true) then begin
+ gibAus('Unerwartetes Dateiende!',3);
+ exit;
+ end;
+ if s='Ende' then break;
+ setlength(parameter,length(parameter)+2);
+ parameter[length(parameter)-2]:=
+ etf(st,erstesArgument(s,' '));
+ if s='' then s:=inttostr(length(parameter) div 2 - 1);
+ parameter[length(parameter)-1]:=
+ etf(st,s);
+ until false;
+ for i:=0 to length(parameter)-1 do
+ if odd(i) then
+ parameter[i]:=
+ parameter[i]/
+ (length(parameter) div 2);
+ setlength(parameter,length(parameter)+2);
+ parameter[length(parameter)-2]:= 1;
+ parameter[length(parameter)-1]:= 1;
+ end;
+ result:=true;
+ tmp.fuegeVorgaengerHinzu(tr);
+ tr:=tmp;
+ exit;
+ end;
+ if startetMit('Log:',s) then begin
+ tmp:=tWerteLogTransformation.create;
+ (tmp as tWerteLogTransformation).logMin:=etf(st,s);
+ result:=true;
+ tmp.fuegeVorgaengerHinzu(tr);
+ tr:=tmp;
+ exit;
+ end;
+ if startetMit('AbsLog:',s) then begin
+ tmp:=tWerteLogAbsTransformation.create;
+ (tmp as tWerteLogAbsTransformation).logSkala:=etf(st,s);
+ result:=true;
+ tmp.fuegeVorgaengerHinzu(tr);
+ tr:=tmp;
+ exit;
+ end;
+ if s='Abs' then begin
+ tmp:=tWerteAbsTransformation.create;
+ result:=true;
+ tmp.fuegeVorgaengerHinzu(tr);
+ tr:=tmp;
+ exit;
+ end;
+ gibAus('Kenne Bearbeitungsmethode '''+s+''' nicht!',3);
end;
end.
diff --git a/werteunit.pas b/werteunit.pas
index b1d46f5..c1b66ec 100644
--- a/werteunit.pas
+++ b/werteunit.pas
@@ -38,9 +38,9 @@ type
procedure kopiereVonNach(original: pTLLWerteSingle; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint); overload;
procedure kopiereVonNach(original: pTLLWerteDouble; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint); overload;
procedure kopiereVonNach(original: pTLLWerteExtended; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint); overload;
- procedure kopiereVerzerrt(original: pTLLWerteSingle; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen); overload;
- procedure kopiereVerzerrt(original: pTLLWerteDouble; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen); overload;
- procedure kopiereVerzerrt(original: pTLLWerteExtended; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen); overload;
+ procedure kopiereVerzerrt(original: pTLLWerteSingle; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint); overload;
+ procedure kopiereVerzerrt(original: pTLLWerteDouble; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint); overload;
+ procedure kopiereVerzerrt(original: pTLLWerteExtended; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint); overload;
destructor destroy; override;
function liesDateien(dateien: tGenerischeInputDateiInfoArray): boolean;
function fft(senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; const fen: tFenster; out pvFehler: extended): boolean; overload;
@@ -85,9 +85,9 @@ uses systemunit;
constructor tLLWerte.create(ps: tExtrainfos);
begin
- inherited create;
- params:=ps;
- setlength(werte,0);
+ inherited create;
+ params:=ps;
+ setlength(werte,0);
end;
constructor tLLWerte.create(original: pTLLWerteSingle; ps: tExtrainfos; xmin,xmax: longint);
@@ -142,116 +142,123 @@ begin
end;
procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax,tmin,tmax: longint);
-var i,j: longint;
+var
+ i,j: longint;
begin
- inherited create;
- tmax:=min(tmax,original^.params.tsiz-1);
- tmin:=max(tmin,0);
- params.tsiz:=tmax+1-tmin;
- xmax:=min(xmax,original^.params.xsteps-1);
- xmin:=max(xmin,0);
- params.xsteps:=xmax+1-xmin;
- params.transformationen.kopiereVon(original^.params.transformationen);
- params.transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
- params.maxW:=0;
- params.minW:=0;
- params.np:=original^.params.np;
- params.beta:=original^.params.beta;
- params.refreshKnownValues;
- if not st then begin
- holeRam(0);
- for i:=xmin to xmax do
- for j:=tmin to tmax do
- werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
- end;
+ inherited create;
+ tmax:=min(tmax,original^.params.tsiz-1);
+ tmin:=max(tmin,0);
+ params.tsiz:=tmax+1-tmin;
+ xmax:=min(xmax,original^.params.xsteps-1);
+ xmin:=max(xmin,0);
+ params.xsteps:=xmax+1-xmin;
+ if not params.transformationen.hatNachfolger then
+ params.transformationen.free;
+ params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xmin,xmax,tmin,tmax);
+ params.maxW:=0;
+ params.minW:=0;
+ params.np:=original^.params.np;
+ params.beta:=original^.params.beta;
+ params.refreshKnownValues;
+ if not st then begin
+ holeRam(0);
+ for i:=xmin to xmax do
+ for j:=tmin to tmax do
+ werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
+ end;
end;
procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteDouble; xmin,xmax,tmin,tmax: longint);
-var i,j: longint;
+var
+ i,j: longint;
begin
- inherited create;
- tmax:=min(tmax,original^.params.tsiz-1);
- tmin:=max(tmin,0);
- params.tsiz:=tmax+1-tmin;
- xmax:=min(xmax,original^.params.xsteps-1);
- xmin:=max(xmin,0);
- params.xsteps:=xmax+1-xmin;
- params.transformationen.kopiereVon(original^.params.transformationen);
- params.transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
- params.maxW:=0;
- params.minW:=0;
- params.np:=original^.params.np;
- params.beta:=original^.params.beta;
- params.refreshKnownValues;
- if not st then begin
- holeRam(0);
- for i:=xmin to xmax do
- for j:=tmin to tmax do
- werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
- end;
+ inherited create;
+ tmax:=min(tmax,original^.params.tsiz-1);
+ tmin:=max(tmin,0);
+ params.tsiz:=tmax+1-tmin;
+ xmax:=min(xmax,original^.params.xsteps-1);
+ xmin:=max(xmin,0);
+ params.xsteps:=xmax+1-xmin;
+ if not params.transformationen.hatNachfolger then
+ params.transformationen.free;
+ params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xmin,xmax,tmin,tmax);
+ params.maxW:=0;
+ params.minW:=0;
+ params.np:=original^.params.np;
+ params.beta:=original^.params.beta;
+ params.refreshKnownValues;
+ if not st then begin
+ holeRam(0);
+ for i:=xmin to xmax do
+ for j:=tmin to tmax do
+ werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
+ end;
end;
procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteExtended; xmin,xmax,tmin,tmax: longint);
-var i,j: longint;
+var
+ i,j: longint;
begin
- inherited create;
- tmax:=min(tmax,original^.params.tsiz-1);
- tmin:=max(tmin,0);
- params.tsiz:=tmax+1-tmin;
- xmax:=min(xmax,original^.params.xsteps-1);
- xmin:=max(xmin,0);
- params.xsteps:=xmax+1-xmin;
- params.transformationen.kopiereVon(original^.params.transformationen);
- params.transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
- params.maxW:=0;
- params.minW:=0;
- params.np:=original^.params.np;
- params.beta:=original^.params.beta;
- params.refreshKnownValues;
- if not st then begin
- holeRam(0);
- for i:=xmin to xmax do
- for j:=tmin to tmax do
- werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
- end;
+ inherited create;
+ tmax:=min(tmax,original^.params.tsiz-1);
+ tmin:=max(tmin,0);
+ params.tsiz:=tmax+1-tmin;
+ xmax:=min(xmax,original^.params.xsteps-1);
+ xmin:=max(xmin,0);
+ params.xsteps:=xmax+1-xmin;
+ if not params.transformationen.hatNachfolger then
+ params.transformationen.free;
+ params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xmin,xmax,tmin,tmax);
+ params.maxW:=0;
+ params.minW:=0;
+ params.np:=original^.params.np;
+ params.beta:=original^.params.beta;
+ params.refreshKnownValues;
+ if not st then begin
+ holeRam(0);
+ for i:=xmin to xmax do
+ for j:=tmin to tmax do
+ werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
+ end;
end;
procedure tLLWerte.kopiereVonNach(original: pTLLWerteSingle; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint);
var
i,j: longint;
begin
- inherited create;
- for i:=qxmin to qxmax do
- for j:=qtmin to qtmax do
- werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
- original^.werte[i+j*original^.params.xsteps];
+ inherited create;
+ for i:=qxmin to qxmax do
+ for j:=qtmin to qtmax do
+ werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
+ original^.werte[i+j*original^.params.xsteps];
end;
procedure tLLWerte.kopiereVonNach(original: pTLLWerteDouble; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint);
var
i,j: longint;
begin
- inherited create;
- for i:=qxmin to qxmax do
- for j:=qtmin to qtmax do
- werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
- original^.werte[i+j*original^.params.xsteps];
+ inherited create;
+ for i:=qxmin to qxmax do
+ for j:=qtmin to qtmax do
+ werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
+ original^.werte[i+j*original^.params.xsteps];
end;
procedure tLLWerte.kopiereVonNach(original: pTLLWerteExtended; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint);
var
i,j: longint;
begin
- inherited create;
- for i:=qxmin to qxmax do
- for j:=qtmin to qtmax do
- werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
- original^.werte[i+j*original^.params.xsteps];
+ inherited create;
+ for i:=qxmin to qxmax do
+ for j:=qtmin to qtmax do
+ werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
+ original^.werte[i+j*original^.params.xsteps];
end;
-procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteSingle; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen);
-var i,j,k,l: longint;
- tmp: extended;
+procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteSingle; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint);
+var
+ i,j,k: longint;
+ tmp: extended;
begin
for i:=tmin to tmax do
for j:=xmin to xmax do
@@ -260,12 +267,12 @@ begin
for j:=0 to 1 do
for k:=0 to 1 do
if (ZPs[i]['x']+j>=xmin) and (ZPs[i]['x']+j<=xmax) and
- (ZPs[i]['y']+k>=tmin) and (ZPs[i]['y']+k<=tmax) then begin
+ (ZPs[i]['y']+k>=tmin) and (ZPs[i]['y']+k<=tmax) then begin
tmp:=original^.werte[i];
- if (vb.count>0) or (nb.count>0) then
+ if (va>0) or (na>0) then
tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
- for l:=0 to vb.count-1 do
- tmp:=vb[l].transformiereWert(tmp);
+ if va>0 then
+ vb.transformiereWert(tmp,va-1);
tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
@@ -274,351 +281,355 @@ begin
for i:=tmin to tmax do
for j:=xmin to xmax do begin
tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
- for k:=0 to nb.count-1 do
- tmp:=nb[k].transformiereWert(tmp);
+ if na>0 then
+ tmp:=nb.transformiereWert(tmp,na-1);
werte[j + i*params.xsteps]:=tmp;
end;
end;
-procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteDouble; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen);
-var i,j,k,l: longint;
- tmp: extended;
+procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteDouble; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint);
+var
+ i,j,k: longint;
+ tmp: extended;
begin
- for i:=tmin to tmax do
- for j:=xmin to xmax do
- werte[j+i*params.xsteps]:=0;
- for i:=0 to length(ZPs)-1 do
- for j:=0 to 1 do
- for k:=0 to 1 do
- if (ZPs[i]['x']+j>=xmin) and (ZPs[i]['x']+j<=xmax) and
+ for i:=tmin to tmax do
+ for j:=xmin to xmax do
+ werte[j+i*params.xsteps]:=0;
+ for i:=0 to length(ZPs)-1 do
+ for j:=0 to 1 do
+ for k:=0 to 1 do
+ if (ZPs[i]['x']+j>=xmin) and (ZPs[i]['x']+j<=xmax) and
(ZPs[i]['y']+k>=tmin) and (ZPs[i]['y']+k<=tmax) then begin
- tmp:=original^.werte[i];
- if (vb.count>0) or (nb.count>0) then
- tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
- for l:=0 to vb.count-1 do
- tmp:=vb[l].transformiereWert(tmp);
- tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
- werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
- werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
- tmp;
- end;
- for i:=tmin to tmax do
- for j:=xmin to xmax do begin
- tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
- for k:=0 to nb.count-1 do
- tmp:=nb[k].transformiereWert(tmp);
- werte[j + i*params.xsteps]:=tmp;
- end;
+ tmp:=original^.werte[i];
+ if (va>0) or (na>0) then
+ tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
+ if va>0 then
+ vb.transformiereWert(tmp,va-1);
+ tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
+ werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
+ werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
+ tmp;
+ end;
+ for i:=tmin to tmax do
+ for j:=xmin to xmax do begin
+ tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
+ if na>0 then
+ tmp:=nb.transformiereWert(tmp,na-1);
+ werte[j + i*params.xsteps]:=tmp;
+ end;
end;
-procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteExtended; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen);
-var i,j,k,l: longint;
- tmp: extended;
+procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteExtended; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint);
+var
+ i,j,k: longint;
+ tmp: extended;
begin
- for i:=tmin to tmax do
- for j:=xmin to xmax do
- werte[j+i*params.xsteps]:=0;
- for i:=0 to length(ZPs)-1 do
- for j:=0 to 1 do
- for k:=0 to 1 do
- if (ZPs[i]['x']+j>=xmin) and (ZPs[i]['x']+j<=xmax) and
+ for i:=tmin to tmax do
+ for j:=xmin to xmax do
+ werte[j+i*params.xsteps]:=0;
+ for i:=0 to length(ZPs)-1 do
+ for j:=0 to 1 do
+ for k:=0 to 1 do
+ if (ZPs[i]['x']+j>=xmin) and (ZPs[i]['x']+j<=xmax) and
(ZPs[i]['y']+k>=tmin) and (ZPs[i]['y']+k<=tmax) then begin
- tmp:=original^.werte[i];
- if (vb.count>0) or (nb.count>0) then
- tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
- for l:=0 to vb.count-1 do
- tmp:=vb[l].transformiereWert(tmp);
- tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
- werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
- werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
- tmp;
- end;
- for i:=tmin to tmax do
- for j:=xmin to xmax do begin
- tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
- for k:=0 to nb.count-1 do
- tmp:=nb[k].transformiereWert(tmp);
- werte[j + i*params.xsteps]:=tmp;
- end;
+ tmp:=original^.werte[i];
+ if (va>0) or (na>0) then
+ tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
+ if va>0 then
+ vb.transformiereWert(tmp,va-1);
+ tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
+ werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
+ werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
+ tmp;
+ end;
+ for i:=tmin to tmax do
+ for j:=xmin to xmax do begin
+ tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
+ if na>0 then
+ tmp:=nb.transformiereWert(tmp,na-1);
+ werte[j + i*params.xsteps]:=tmp;
+ end;
end;
destructor tLLWerte.destroy;
begin
- setlength(werte,0);
- inherited destroy;
+ setlength(werte,0);
+ inherited destroy;
end;
function tLLWerte.liesDateien(dateien: tGenerischeInputDateiInfoArray): boolean;
-var i,j,k,l,tmpi,etsiz,spAnz,br: longint;
- f: file;
- tmps: single;
- tmpd: double;
- tmpe,Zeit: extended;
- sa: tSingleArray;
- da: tDoubleArray;
- ea: tExtendedArray;
- ipp: tProcess;
- buf: tByteArray;
- etwasGelesen: boolean;
+var
+ i,j,k,l,tmpi,etsiz,spAnz,br: longint;
+ f: file;
+ tmps: single;
+ tmpd: double;
+ tmpe,Zeit: extended;
+ sa: tSingleArray;
+ da: tDoubleArray;
+ ea: tExtendedArray;
+ ipp: tProcess;
+ buf: tByteArray;
+ etwasGelesen: boolean;
begin
- result:=false;
- gibAus('... Dateien einlesen ...',1);
- zeit:=now;
- tmpi:=0;
- tmps:=0;
- tmpd:=0;
- etsiz:=0;
- spAnz:=-1;
- for i:=0 to length(dateien)-1 do begin
- gibAus(' '+dateien[i].Name,1);
- etwasGelesen:=false;
- if dateien[i] is tPipeInputDateiInfo then begin
- if ((dateien[i] as tPipeInputDateiInfo).bytesPerSample<>4) or
+ result:=false;
+ gibAus('... Dateien einlesen ...',1);
+ zeit:=now;
+ tmpi:=0;
+ tmps:=0;
+ tmpd:=0;
+ etsiz:=0;
+ spAnz:=-1;
+ for i:=0 to length(dateien)-1 do begin
+ gibAus(' '+dateien[i].Name,1);
+ etwasGelesen:=false;
+ if dateien[i] is tPipeInputDateiInfo then begin
+ if ((dateien[i] as tPipeInputDateiInfo).bytesPerSample<>4) or
((dateien[i] as tPipeInputDateiInfo).Kodierung<>k32BitSignedInteger) then begin
- gibAus('Ich kann nur vier Bytes mit einem mal als Integer interpretiert aus einer Pipe einlesen!',3);
- exit;
- end;
- tmpe:=power(2,-31);
- ipp:=tProcess.create(nil);
- ipp.Options:=ipp.Options + [poUsePipes];
- ipp.Executable:=(dateien[i] as tPipeInputDateiInfo).Executable;
- ipp.Parameters.Text:=(dateien[i] as tPipeInputDateiInfo).ParametersText;
- ipp.execute;
- setlength(buf,0);
- br:=0;
- while ipp.running or (ipp.Output.NumBytesAvailable>0) do begin
- if ipp.Output.NumBytesAvailable > 0 then begin
- if br+ipp.Output.NumBytesAvailable>=length(buf) then
- setlength(buf,br+ipp.Output.NumBytesAvailable+65536*1024);
- tmpi:=ipp.Output.Read(buf[br],min(ipp.Output.NumBytesAvailable,length(buf)-br));
- if ((br+tmpi) shr 24) > (br shr 24) then gibAus(inttostr(br+tmpi)+' von '+inttostr(dateien[i].tsiz*dateien[i].xsteps*4)+' Bytes bisher gelesen ('+floattostrtrunc((br+tmpi)/(dateien[i].tsiz*dateien[i].xsteps*4)*100,2,true)+'%).',1);
- br:=br+tmpi;
- end
- else
- sleep(10);
- end;
- ipp.free;
- gibAus('insgesamt '+inttostr(br div 1024 div 1024)+' MB gelesen.',1);
- setlength(buf,br);
- if dateien[i].tsiz*dateien[i].xsteps*4>length(buf) then begin
- gibAus('Ich habe '+inttostr(length(buf))+' Bytes aus der Pipe gelesen, anstelle von wenigstens '+inttostr(dateien[i].tsiz*dateien[i].xsteps*4)+', wie erwartet!',3);
- setlength(buf,0);
- exit;
- end;
- tmpi:=length(buf)-4*dateien[i].tsiz*dateien[i].xsteps; // der Offset des ersten Daten-Wortes
- for j:=dateien[i].tmin to dateien[i].tmax do
- for k:=dateien[i].xmin to dateien[i].xmax do
- werte[dateien[i].t0abs+ k-dateien[i].xmin + (j-dateien[i].tmin)*(dateien[i].xmax-dateien[i].xmin+1)]:=
- int32((((((buf[tmpi+3+4*(k+j*dateien[i].xsteps)] shl 8) or
- buf[tmpi+2+4*(k+j*dateien[i].xsteps)]) shl 8) or
+ gibAus('Ich kann nur vier Bytes mit einem mal als Integer interpretiert aus einer Pipe einlesen!',3);
+ exit;
+ end;
+ tmpe:=power(2,-31);
+ ipp:=tProcess.create(nil);
+ ipp.Options:=ipp.Options + [poUsePipes];
+ ipp.Executable:=(dateien[i] as tPipeInputDateiInfo).Executable;
+ ipp.Parameters.Text:=(dateien[i] as tPipeInputDateiInfo).ParametersText;
+ ipp.execute;
+ setlength(buf,0);
+ br:=0;
+ while ipp.running or (ipp.Output.NumBytesAvailable>0) do begin
+ if ipp.Output.NumBytesAvailable > 0 then begin
+ if br+ipp.Output.NumBytesAvailable>=length(buf) then
+ setlength(buf,br+ipp.Output.NumBytesAvailable+65536*1024);
+ tmpi:=ipp.Output.Read(buf[br],min(ipp.Output.NumBytesAvailable,length(buf)-br));
+ if ((br+tmpi) shr 24) > (br shr 24) then gibAus(inttostr(br+tmpi)+' von '+inttostr(dateien[i].tsiz*dateien[i].xsteps*4)+' Bytes bisher gelesen ('+floattostrtrunc((br+tmpi)/(dateien[i].tsiz*dateien[i].xsteps*4)*100,2,true)+'%).',1);
+ br:=br+tmpi;
+ end
+ else
+ sleep(10);
+ end;
+ ipp.free;
+ gibAus('insgesamt '+inttostr(br div 1024 div 1024)+' MB gelesen.',1);
+ setlength(buf,br);
+ if dateien[i].tsiz*dateien[i].xsteps*4>length(buf) then begin
+ gibAus('Ich habe '+inttostr(length(buf))+' Bytes aus der Pipe gelesen, anstelle von wenigstens '+inttostr(dateien[i].tsiz*dateien[i].xsteps*4)+', wie erwartet!',3);
+ setlength(buf,0);
+ exit;
+ end;
+ tmpi:=length(buf)-4*dateien[i].tsiz*dateien[i].xsteps; // der Offset des ersten Daten-Wortes
+ for j:=dateien[i].tmin to dateien[i].tmax do
+ for k:=dateien[i].xmin to dateien[i].xmax do
+ werte[dateien[i].t0abs+ k-dateien[i].xmin + (j-dateien[i].tmin)*(dateien[i].xmax-dateien[i].xmin+1)]:=
+ int32((((((buf[tmpi+3+4*(k+j*dateien[i].xsteps)] shl 8) or
+ buf[tmpi+2+4*(k+j*dateien[i].xsteps)]) shl 8) or
buf[tmpi+1+4*(k+j*dateien[i].xsteps)]) shl 8) or
- buf[tmpi+4*(k+j*dateien[i].xsteps)]) * tmpe;
- setlength(buf,0);
- if etwasGelesen then begin
- gibAus('Ich habe diese Runde schon Daten gelesen!',3);
- exit;
- end;
- etwasGelesen:=true;
- end;
- if (dateien[i] is tSpaceTimeInputDateiInfo) or
+ buf[tmpi+4*(k+j*dateien[i].xsteps)]) * tmpe;
+ setlength(buf,0);
+ if etwasGelesen then begin
+ gibAus('Ich habe diese Runde schon Daten gelesen!',3);
+ exit;
+ end;
+ etwasGelesen:=true;
+ end;
+ if (dateien[i] is tSpaceTimeInputDateiInfo) or
(dateien[i] is tTraceInputDateiInfo) then begin
- assign(f,dateien[i].Name);
- reset(f,1);
- blockread(f,tmpi,sizeof(integer));
- dec(tmpi);
- if tmpi-round(params.tstart/dateien[i].groeszenFaktor)<>i then begin
- gibAus('Datei '''+dateien[i].Name+''' kommt nicht an '+inttostr(i)+'-ter Stelle, wie sie sollte, sondern an '+inttostr(tmpi-round(params.tstart/dateien[i].groeszenFaktor))+'-ter.',3);
- writeln(tmpi);
- close(f);
- exit;
- end;
- if dateien[i] is tTraceInputDateiInfo then begin
- blockread(f,tmpi,sizeof(integer)); // #Traces
- spAnz:=tmpi;
- end;
- blockread(f,etsiz,sizeof(integer));
- if dateien[i] is tSpaceTimeInputDateiInfo then begin
- for j:=0 to etsiz-1 do begin
- case Dateien[i].Genauigkeit of
- gSingle: begin
- blockread(f,tmps,sizeof(single)); // xstart
- tmpe:=tmps;
- end;
- gDouble: begin
- blockread(f,tmpd,sizeof(double)); // xstart
- tmpe:=tmpd;
- end;
- gExtended:
- blockread(f,tmpe,sizeof(extended)); // xstart
- end{of Case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- if j=0 then params.transformationen.xstart:=tmpe;
- if tmpe<>params.transformationen.xstart then begin
- gibAus('Falscher linker Rand in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(params.transformationen.xstart)+'!',3);
- close(f);
- exit;
- end;
- case Dateien[i].Genauigkeit of
- gSingle: begin
- blockread(f,tmps,sizeof(single)); // xstop
- tmpe:=tmps;
- end;
- gDouble: begin
- blockread(f,tmpd,sizeof(double)); // xstop
- tmpe:=tmpd;
- end;
- gExtended:
- blockread(f,tmpe,sizeof(extended)); // xstop
- end{of Case};
- tmpe:=tmpe*dateien[i].groeszenFaktor;
- if j=0 then params.transformationen.xstop:=tmpe;
- if tmpe<>params.transformationen.xstop then begin
- gibAus('Falscher rechter Rand in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(params.transformationen.xstop)+'!',3);
- close(f);
- exit;
- end;
- blockread(f,tmpi,sizeof(integer)); // xsteps
- if tmpi<>params.xsteps then begin
- gibAus('Falsche Anzahl an x-Schritten in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+inttostr(tmpi)+' statt '+myfloattostr(params.xsteps)+'!',3);
- close(f);
- exit;
- end;
- if ((sizeof(wgen) = sizeof(single)) and (Dateien[i].Genauigkeit=gSingle)) or
+ assign(f,dateien[i].Name);
+ reset(f,1);
+ blockread(f,tmpi,sizeof(integer));
+ dec(tmpi);
+ if tmpi-round(params.tstart/dateien[i].groeszenFaktor)<>i then begin
+ gibAus('Datei '''+dateien[i].Name+''' kommt nicht an '+inttostr(i)+'-ter Stelle, wie sie sollte, sondern an '+inttostr(tmpi-round(params.tstart/dateien[i].groeszenFaktor))+'-ter.',3);
+ writeln(tmpi);
+ close(f);
+ exit;
+ end;
+ if dateien[i] is tTraceInputDateiInfo then begin
+ blockread(f,tmpi,sizeof(integer)); // #Traces
+ spAnz:=tmpi;
+ end;
+ blockread(f,etsiz,sizeof(integer));
+ if dateien[i] is tSpaceTimeInputDateiInfo then begin
+ for j:=0 to etsiz-1 do begin
+ case Dateien[i].Genauigkeit of
+ gSingle: begin
+ blockread(f,tmps,sizeof(single)); // xstart
+ tmpe:=tmps;
+ end;
+ gDouble: begin
+ blockread(f,tmpd,sizeof(double)); // xstart
+ tmpe:=tmpd;
+ end;
+ gExtended:
+ blockread(f,tmpe,sizeof(extended)); // xstart
+ end{of Case};
+ tmpe:=tmpe*dateien[i].groeszenFaktor;
+ if j=0 then params.transformationen.xstart:=tmpe;
+ if tmpe<>params.transformationen.xstart then begin
+ gibAus('Falscher linker Rand in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(params.transformationen.xstart)+'!',3);
+ close(f);
+ exit;
+ end;
+ case Dateien[i].Genauigkeit of
+ gSingle: begin
+ blockread(f,tmps,sizeof(single)); // xstop
+ tmpe:=tmps;
+ end;
+ gDouble: begin
+ blockread(f,tmpd,sizeof(double)); // xstop
+ tmpe:=tmpd;
+ end;
+ gExtended:
+ blockread(f,tmpe,sizeof(extended)); // xstop
+ end{of Case};
+ tmpe:=tmpe*dateien[i].groeszenFaktor;
+ if j=0 then params.transformationen.xstop:=tmpe;
+ if tmpe<>params.transformationen.xstop then begin
+ gibAus('Falscher rechter Rand in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(params.transformationen.xstop)+'!',3);
+ close(f);
+ exit;
+ end;
+ blockread(f,tmpi,sizeof(integer)); // xsteps
+ if tmpi<>params.xsteps then begin
+ gibAus('Falsche Anzahl an x-Schritten in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+inttostr(tmpi)+' statt '+myfloattostr(params.xsteps)+'!',3);
+ close(f);
+ exit;
+ end;
+ if ((sizeof(wgen) = sizeof(single)) and (Dateien[i].Genauigkeit=gSingle)) or
((sizeof(wgen) = sizeof(double)) and (Dateien[i].Genauigkeit=gDouble)) or
((sizeof(wgen) = sizeof(extended)) and (Dateien[i].Genauigkeit=gExtended)) then
- blockread(f,werte[(j+Dateien[i].t0abs)*params.xsteps],params.xsteps*sizeof(wgen))
- else begin
- setlength(sa,params.xsteps);
- blockread(f,sa[0],params.xsteps*sizeof(single));
- for k:=0 to params.xsteps-1 do
- werte[(j+Dateien[i].t0abs)*params.xsteps+k]:=sa[k];
- end;
- if power(dateien[i].gamma,3)/sqr(dateien[i].groeszenFaktor)<>1 then // gamma^3 als Skalierungsfaktor für Dichten ?
- for k:=0 to params.xsteps-1 do
- werte[(j+Dateien[i].t0abs)*params.xsteps+k]:=werte[(j+Dateien[i].t0abs)*params.xsteps+k]*power(dateien[i].gamma,3)/sqr(dateien[i].groeszenFaktor);
- end;
- if etwasGelesen then begin
- gibAus('Ich habe diese Runde schon Daten gelesen!',3);
- exit;
- end;
- etwasGelesen:=true;
- end;
- if dateien[i] is tTraceInputDateiInfo then begin
- case Dateien[i].Genauigkeit of
- gSingle: begin
- setlength(sa,etsiz);
- setlength(da,0);
- setlength(ea,0);
- end;
- gDouble: begin
- setlength(sa,0);
- setlength(da,etsiz);
- setlength(ea,0);
- end;
- gExtended: begin
- setlength(sa,0);
- setlength(da,0);
- setlength(ea,etsiz);
- end;
- end{of case};
- for j:=0 to spAnz-1 do
- case Dateien[i].Genauigkeit of
- gSingle: begin
- blockread(f,tmps,sizeof(single)); // x
- if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
- params.transformationen.xstop:=tmps;
- params.transformationen.xstart:=params.xstop;
- end;
- for k:=0 to length(FeldgroeszenNamen)-1 do begin
- blockread(f,sa[0],sizeof(single)*length(sa));
- if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
+ blockread(f,werte[(j+Dateien[i].t0abs)*params.xsteps],params.xsteps*sizeof(wgen))
+ else begin
+ setlength(sa,params.xsteps);
+ blockread(f,sa[0],params.xsteps*sizeof(single));
+ for k:=0 to params.xsteps-1 do
+ werte[(j+Dateien[i].t0abs)*params.xsteps+k]:=sa[k];
+ end;
+ if power(dateien[i].gamma,3)/sqr(dateien[i].groeszenFaktor)<>1 then // gamma^3 als Skalierungsfaktor für Dichten ?
+ for k:=0 to params.xsteps-1 do
+ werte[(j+Dateien[i].t0abs)*params.xsteps+k]:=werte[(j+Dateien[i].t0abs)*params.xsteps+k]*power(dateien[i].gamma,3)/sqr(dateien[i].groeszenFaktor);
+ end;
+ if etwasGelesen then begin
+ gibAus('Ich habe diese Runde schon Daten gelesen!',3);
+ exit;
+ end;
+ etwasGelesen:=true;
+ end;
+ if dateien[i] is tTraceInputDateiInfo then begin
+ case Dateien[i].Genauigkeit of
+ gSingle: begin
+ setlength(sa,etsiz);
+ setlength(da,0);
+ setlength(ea,0);
+ end;
+ gDouble: begin
+ setlength(sa,0);
+ setlength(da,etsiz);
+ setlength(ea,0);
+ end;
+ gExtended: begin
+ setlength(sa,0);
+ setlength(da,0);
+ setlength(ea,etsiz);
+ end;
+ end{of case};
+ for j:=0 to spAnz-1 do
+ case Dateien[i].Genauigkeit of
+ gSingle: begin
+ blockread(f,tmps,sizeof(single)); // x
+ if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
+ params.transformationen.xstop:=tmps;
+ params.transformationen.xstart:=params.xstop;
+ end;
+ for k:=0 to length(FeldgroeszenNamen)-1 do begin
+ blockread(f,sa[0],sizeof(single)*length(sa));
+ if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
(k=(Dateien[i] as tTraceInputDateiInfo).Feldnummer) then begin
- for l:=0 to length(sa)-1 do
- werte[l+Dateien[i].t0abs]:=sa[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
- if etwasGelesen then begin
- gibAus('Ich habe diese Runde schon Daten gelesen!',3);
- exit;
- end;
- etwasGelesen:=true;
- end;
- end;
- end;
- gDouble: begin
- blockread(f,tmpd,sizeof(double)); // x
- if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
- params.transformationen.xstop:=tmpd;
- params.transformationen.xstart:=params.xstop;
- end;
- for k:=0 to length(FeldgroeszenNamen)-1 do begin
- blockread(f,da[0],sizeof(double)*length(da));
- if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
+ for l:=0 to length(sa)-1 do
+ werte[l+Dateien[i].t0abs]:=sa[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
+ if etwasGelesen then begin
+ gibAus('Ich habe diese Runde schon Daten gelesen!',3);
+ exit;
+ end;
+ etwasGelesen:=true;
+ end;
+ end;
+ end;
+ gDouble: begin
+ blockread(f,tmpd,sizeof(double)); // x
+ if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
+ params.transformationen.xstop:=tmpd;
+ params.transformationen.xstart:=params.xstop;
+ end;
+ for k:=0 to length(FeldgroeszenNamen)-1 do begin
+ blockread(f,da[0],sizeof(double)*length(da));
+ if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
(k=(Dateien[i] as tTraceInputDateiInfo).Feldnummer) then begin
- for l:=0 to length(da)-1 do
- werte[l+dateien[i].t0abs]:=da[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
- if etwasGelesen then begin
- gibAus('Ich habe diese Runde schon Daten gelesen!',3);
- exit;
- end;
- etwasGelesen:=true;
- end;
- end;
- end;
- gExtended: begin
- blockread(f,tmpe,sizeof(extended)); // x
- if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
- params.transformationen.xstop:=tmpe;
- params.transformationen.xstart:=params.xstop;
- end;
- for k:=0 to length(FeldgroeszenNamen)-1 do begin
- blockread(f,ea[0],sizeof(extended)*length(ea));
- if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
+ for l:=0 to length(da)-1 do
+ werte[l+dateien[i].t0abs]:=da[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
+ if etwasGelesen then begin
+ gibAus('Ich habe diese Runde schon Daten gelesen!',3);
+ exit;
+ end;
+ etwasGelesen:=true;
+ end;
+ end;
+ end;
+ gExtended: begin
+ blockread(f,tmpe,sizeof(extended)); // x
+ if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
+ params.transformationen.xstop:=tmpe;
+ params.transformationen.xstart:=params.xstop;
+ end;
+ for k:=0 to length(FeldgroeszenNamen)-1 do begin
+ blockread(f,ea[0],sizeof(extended)*length(ea));
+ if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
(k=(Dateien[i] as tTraceInputDateiInfo).Feldnummer) then begin
- for l:=0 to length(ea)-1 do
- werte[l+dateien[i].t0abs]:=ea[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
- if etwasGelesen then begin
- gibAus('Ich habe diese Runde schon Daten gelesen!',3);
- exit;
- end;
- etwasGelesen:=true;
- end;
- end;
- end;
- end{of Case};
- end;
- if not eof(f) then begin
- gibAus('Zu viele Daten in '''+dateien[i].Name+'''!',3);
- close(f);
- exit;
- end;
- close(f);
- end;
- if dateien[i] is tPhaseSpaceInputDateiInfo then begin
- if i<>0 then begin
- gibAus('Ich kann Phasenraumdateien nicht kaskadieren!',3);
- close(f);
- exit;
- end;
- assign(f,dateien[i].Name);
- reset(f,1);
- seek(f,filepos(f)
- + 4*wertGroesze(dateien[i].genauigkeit) // xstart,xstop,tstart,tstop
- + 2*sizeof(longint)); // xsteps,tsiz
- blockread(f,werte[0],params.xsteps*params.tsiz*wertGroesze(dateien[i].genauigkeit));
- close(f);
- etwasGelesen:=true;
- end;
- if not etwasGelesen then begin
- gibAus('Ich habe diese Runde keine Daten gelesen!',3);
- exit;
- end;
- end;
- params.refreshKnownValues;
- gibAus('... fertig '+timetostr(now-Zeit),1);
- result:=true;
+ for l:=0 to length(ea)-1 do
+ werte[l+dateien[i].t0abs]:=ea[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
+ if etwasGelesen then begin
+ gibAus('Ich habe diese Runde schon Daten gelesen!',3);
+ exit;
+ end;
+ etwasGelesen:=true;
+ end;
+ end;
+ end;
+ end{of Case};
+ end;
+ if not eof(f) then begin
+ gibAus('Zu viele Daten in '''+dateien[i].Name+'''!',3);
+ close(f);
+ exit;
+ end;
+ close(f);
+ end;
+ if dateien[i] is tPhaseSpaceInputDateiInfo then begin
+ if i<>0 then begin
+ gibAus('Ich kann Phasenraumdateien nicht kaskadieren!',3);
+ close(f);
+ exit;
+ end;
+ assign(f,dateien[i].Name);
+ reset(f,1);
+ seek(f,filepos(f)
+ + 4*wertGroesze(dateien[i].genauigkeit) // xstart,xstop,tstart,tstop
+ + 2*sizeof(longint)); // xsteps,tsiz
+ blockread(f,werte[0],params.xsteps*params.tsiz*wertGroesze(dateien[i].genauigkeit));
+ close(f);
+ etwasGelesen:=true;
+ end;
+ if not etwasGelesen then begin
+ gibAus('Ich habe diese Runde keine Daten gelesen!',3);
+ exit;
+ end;
+ end;
+ params.refreshKnownValues;
+ gibAus('... fertig '+timetostr(now-Zeit),1);
+ result:=true;
end;
procedure tLLWerte.gibMinMaxDichten(out wMi,wMa: extended; xmin,xmax,tmin,tmax: longint);
-var i,j: longint;
+var
+ i,j: longint;
begin
wMi:=werte[xmin+tmin*params.xsteps];
wMa:=Werte[xmin+tmin*params.xsteps];
@@ -630,7 +641,8 @@ begin
end;
function tLLWerte.fft(senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; const fen: tFenster; out pvFehler: extended): boolean;
-var len: longint;
+var
+ len: longint;
begin
len:=1;
if senkrecht then begin
@@ -646,12 +658,13 @@ begin
end;
function tLLWerte.fft(xmin,xmax,tmin,tmax: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; const fen: tFenster; out pvFehler: extended): boolean;
-var i,j,k,n,dist,absch,wnum,wstep,haL,
- pmax,pmin,smax,smin: longint;
- in0,out0: boolean;
- ims,wRe,wIm: tExtendedArray;
- t1,t2,vorher,nachher,fenavg: extended;
- umsortierung: tLongintArray;
+var
+ i,j,k,n,dist,absch,wnum,wstep,haL,
+ pmax,pmin,smax,smin: longint;
+ in0,out0: boolean;
+ ims,wRe,wIm: tExtendedArray;
+ t1,t2,vorher,nachher,fenavg: extended;
+ umsortierung: tLongintArray;
const faktoren: array[tFFTDatenordnung,0..2] of longint = // (doResIms,doResSmi,doRes,doBetr,doBetrQdr);
((2,1,1),(2,1,1),(1,1,1),(1,1,1),(1,1,1));
begin
@@ -710,7 +723,7 @@ begin
vorher:=vorher + werte[i+j*params.xsteps]*werte[i+j*params.xsteps]
*faktoren[vor,
Byte(((not senkrecht) and (i=xmin)) or (senkrecht and (j=tmin)))
- +2*Byte(((not senkrecht) and (2*i=xmin+xmax+1)) or (senkrecht and (2*j=tmin+tmax+1)))];
+ +2*Byte(((not senkrecht) and (2*i=xmin+xmax+1)) or (senkrecht and (2*j=tmin+tmax+1)))];
end;
setlength(umsortierung,pmax+1-pmin);
@@ -944,7 +957,7 @@ begin
nachher:=nachher + werte[i+j*params.xsteps]*werte[i+j*params.xsteps]
*faktoren[nach,
Byte(((not senkrecht) and (i=xmin)) or (senkrecht and (j=tmin)))
- +2*Byte(((not senkrecht) and (2*i=xmin+xmax+1)) or (senkrecht and (2*j=tmin+tmax+1)))];
+ +2*Byte(((not senkrecht) and (2*i=xmin+xmax+1)) or (senkrecht and (2*j=tmin+tmax+1)))];
end;
if (nachher=0) and (vorher=0) then pvFehler:=0
else pvFehler:=abs(nachher-vorher)/(nachher+vorher);
@@ -957,68 +970,71 @@ end;
procedure tLLWerte.schreibeWert(var f: textfile; x,y: longint);
begin
- schreibeWert(f,x,y,werte[x+y*params.xsteps]);
+ schreibeWert(f,x,y,werte[x+y*params.xsteps]);
end;
procedure tLLWerte.schreibeWert(var f: textfile; x,y,wert: extended);
-var xa,ta: extended;
+var
+ xa,ta: extended;
begin
- if params.xstop=params.xstart then
- xa:=params.xstop
- else
- xa:=params.xstart+x/(params.xsteps-1)*(params.xstop-params.xstart);
- if params.tstop=params.tstart then
- ta:=params.tstop
- else
- ta:=params.tstart+y/(params.tsiz-1)*(params.tstop-params.tstart);
- writeln(f,floattostr(xa)+' '+floattostr(ta)+' '+floattostr(wert));
+ if params.xstop=params.xstart then
+ xa:=params.xstop
+ else
+ xa:=params.xstart+x/(params.xsteps-1)*(params.xstop-params.xstart);
+ if params.tstop=params.tstart then
+ ta:=params.tstop
+ else
+ ta:=params.tstart+y/(params.tsiz-1)*(params.tstop-params.tstart);
+ writeln(f,floattostr(xa)+' '+floattostr(ta)+' '+floattostr(wert));
end;
procedure tLLWerte.schreibeWertIntegriert(var f: textfile; i: longint; hor: boolean);
-var j: longint;
- tmp: extended;
+var
+ j: longint;
+ tmp: extended;
begin
- tmp:=0;
- if hor then begin
- for j:=0 to params.xsteps-1 do
- tmp:=tmp+werte[j+i*params.xsteps];
- schreibeWert(f,(params.xsteps-1)/2,i,tmp);
- end
- else begin
- for j:=0 to params.tsiz-1 do
- tmp:=tmp+werte[i+j*params.xsteps];
- schreibeWert(f,i,(params.tsiz-1)/2,tmp);
- end;
+ tmp:=0;
+ if hor then begin
+ for j:=0 to params.xsteps-1 do
+ tmp:=tmp+werte[j+i*params.xsteps];
+ schreibeWert(f,(params.xsteps-1)/2,i,tmp);
+ end
+ else begin
+ for j:=0 to params.tsiz-1 do
+ tmp:=tmp+werte[i+j*params.xsteps];
+ schreibeWert(f,i,(params.tsiz-1)/2,tmp);
+ end;
end;
procedure tLLWerte.erzeugeBinning(senkrecht,linien: boolean; x0,dx: extended; s: string);
-var f: textfile;
- i: longint;
- sum,x: extended;
+var
+ f: textfile;
+ i: longint;
+ sum,x: extended;
begin
- assignfile(f,s);
- rewrite(f);
- sum:=0;
- while x0<0 do
- x0:=x0+dx;
- for i:=0 to params.xsteps*params.tsiz-1 do
- if i+1>x0 then begin
- sum:=sum+werte[i]*(x0-i);
- if senkrecht then
- x:=x0/(params.tsiz-1)*(params.tstop-params.tstart)+params.tstart
- else
- x:=x0/(params.xsteps-1)*(params.xstop-params.xstart)+params.xstart;
- writeln(f,floattostr(x)+' '+floattostr(sum/dx));
- if linien then begin
- writeln(f,floattostr(x)+' 0');
- writeln(f)
- end;
- sum:=werte[i]*(i+1-x0);
- x0:=x0+dx;
- end
- else
- sum:=sum+werte[i];
- closefile(f);
+ assignfile(f,s);
+ rewrite(f);
+ sum:=0;
+ while x0<0 do
+ x0:=x0+dx;
+ for i:=0 to params.xsteps*params.tsiz-1 do
+ if i+1>x0 then begin
+ sum:=sum+werte[i]*(x0-i);
+ if senkrecht then
+ x:=x0/(params.tsiz-1)*(params.tstop-params.tstart)+params.tstart
+ else
+ x:=x0/(params.xsteps-1)*(params.xstop-params.xstart)+params.xstart;
+ writeln(f,floattostr(x)+' '+floattostr(sum/dx));
+ if linien then begin
+ writeln(f,floattostr(x)+' 0');
+ writeln(f)
+ end;
+ sum:=werte[i]*(i+1-x0);
+ x0:=x0+dx;
+ end
+ else
+ sum:=sum+werte[i];
+ closefile(f);
end;
procedure tLLWerte.spiegle;
@@ -1027,8 +1043,9 @@ begin
end;
procedure tLLWerte.spiegle(tmin,tmax: longint);
-var i,j: longint;
- tmp: wgen;
+var
+ i,j: longint;
+ tmp: wgen;
begin
for i:=tmin to tmax do
for j:=0 to params.xsteps div 2 -1 do begin
@@ -1039,7 +1056,8 @@ begin
end;
procedure tLLWerte.fft2dNachbearbeitungA(nb: tFFTDatenordnung);
-var i: longint;
+var
+ i: longint;
begin
case NB of
doResIms,doResSmi: ;
@@ -1089,7 +1107,8 @@ begin
end;
procedure tLLWerte.fft2dNachbearbeitungB(xmin,xmax: longint; nb: tFFTDatenordnung);
-var i,j: longint;
+var
+ i,j: longint;
begin // bearbeitet nur den Hauptteil (außer erster und mittlerer Zeile/Spalte) nach!
case nb of
doBetr: begin
@@ -1104,10 +1123,10 @@ begin // bearbeitet nur den Hauptteil (außer erster und mittlerer Zeile/Spalte)
end;
end;
doBetrQdr: begin
- for i:=xmin to xmax do
+ for i:=xmin to xmax do
for j:=1 to params.tsiz div 2 -1 do begin
werte[i+j*params.xsteps]:=
- sqr(extended(werte[i+j*params.xsteps]-werte[params.xsteps-i+(params.tsiz-j)*params.xsteps])) // Re^2
+ sqr(extended(werte[i+j*params.xsteps]-werte[params.xsteps-i+(params.tsiz-j)*params.xsteps])) // Re^2
+sqr(extended(werte[params.xsteps-i+j*params.xsteps]+werte[i+(params.tsiz-j)*params.xsteps])); // Im^2
werte[params.xsteps-i+j*params.xsteps]:=werte[i+j*params.xsteps];
werte[i+(params.tsiz-j)*params.xsteps]:=werte[i+j*params.xsteps];
@@ -1128,8 +1147,9 @@ begin
end;
procedure tLLWerte.holeRam(ausgaben: byte; gemaeszTXMinMax: boolean);
-var Zeit: extended;
- br,ho: longint;
+var
+ Zeit: extended;
+ br,ho: longint;
begin
Zeit:=now;
if gemaeszTXMinMax then begin
@@ -1149,9 +1169,10 @@ begin
end;
function tLLWerte.zuPixelWerten(whoehe,wbreite,xpmi,xmi,tmi: longint; xz,yz: extended; pPWerte: pTExtendedArray; pPAnzahlen: pTLongintArray): boolean;
-var i,j,k,l,
- xv,xb,tv,tb: longint;
- b: boolean;
+var
+ i,j,k,l,
+ xv,xb,tv,tb: longint;
+ b: boolean;
begin
result:=false;
for i:=0 to length(pPWerte^)-1 do begin
@@ -1190,8 +1211,9 @@ begin
end;
function tLLWerte.findeSchwellwerte(xmi,xma,tmi,tma: longint; Schw: extended): tExtPointArray;
-var i,j,k,l,m,vz: longint;
- dx,dy,x0,y0: extended;
+var
+ i,j,k,l,m,vz: longint;
+ dx,dy,x0,y0: extended;
begin
setlength(result,0);
gibAus('Schwellwerte finden ('+inttostr(xmi)+'-'+inttostr(xma)+') '+floattostr(Schw)+' ...',1);
@@ -1206,7 +1228,7 @@ begin
for l:=0 to 1 do
for m:=0 to 1 do
vz:=
- vz or (byte(werte[j-l+(k-m)*params.xsteps]>=Schw) shl 1) or
+ vz or (byte(werte[j-l+(k-m)*params.xsteps]>=Schw) shl 1) or
byte(werte[j-l+(k-m)*params.xsteps]<=Schw);
if vz=3 then begin
if i>=length(result) then
@@ -1224,8 +1246,9 @@ begin
end;
procedure tLLWerte.integriereSingle(qu: pTLLWerteSingle; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
-var i,j: longint;
- int,faktor: extended;
+var
+ i,j: longint;
+ int,faktor: extended;
begin
case richtung of
irHorizontal: begin
@@ -1296,8 +1319,9 @@ begin
end;
procedure tLLWerte.integriereDouble(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
-var i,j: longint;
- int,faktor: extended;
+var
+ i,j: longint;
+ int,faktor: extended;
begin
case richtung of
irHorizontal: begin
@@ -1368,8 +1392,9 @@ begin
end;
procedure tLLWerte.integriereExtended(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
-var i,j: longint;
- int,faktor: extended;
+var
+ i,j: longint;
+ int,faktor: extended;
begin
case richtung of
irHorizontal: begin
@@ -1457,10 +1482,11 @@ begin
end;
function tWavelet.berechneWerte: boolean;
-var i: longint;
- tmp: extended;
- fenster: tFenster;
- nur0: boolean;
+var
+ i: longint;
+ tmp: extended;
+ fenster: tFenster;
+ nur0: boolean;
begin
result:=false;
werte.params.xsteps:=2;
@@ -1510,9 +1536,9 @@ begin
(* gibAus('dump:',3);
for i:=0 to werte.tsiz-1 do
if (i=0) or (i=werte.tsiz-1) or
- (werte.werte[2*i+1]<>0) or
- (werte.werte[2*i]<>werte.werte[2*(i-1)]) or
- (werte.werte[2*i]<>werte.werte[2*(i+1)]) then
+ (werte.werte[2*i+1]<>0) or
+ (werte.werte[2*i]<>werte.werte[2*(i-1)]) or
+ (werte.werte[2*i]<>werte.werte[2*(i+1)]) then
gibAus(inttostr(i)+' '+floattostr(werte.werte[2*i])+' '+floattostr(werte.werte[2*i+1]),3);
gibAus('ende',3);
exit; *)
@@ -1542,7 +1568,8 @@ begin
end;
constructor tWavelet.create;
-var ps: tExtrainfos;
+var
+ ps: tExtrainfos;
begin
inherited create;
ps:=tExtrainfos.create;
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-11-01 22:31:42 +0000