diff options
Diffstat (limited to 'werteunit.pas')
| -rw-r--r-- | werteunit.pas | 1650 |
1 files changed, 899 insertions, 751 deletions
diff --git a/werteunit.pas b/werteunit.pas index 340d3a7..e8761e2 100644 --- a/werteunit.pas +++ b/werteunit.pas @@ -5,7 +5,7 @@ unit werteunit; interface uses - Classes, SysUtils, typenunit, math, process, lowlevelunit, matheunit, fftunit; + classes, sysutils, typenunit, math, process, lowlevelunit, matheunit, fftunit; type // tLLWerte ******************************************************************** @@ -22,53 +22,55 @@ type procedure sortiereMaxima(var maxima: tIntPointArray); public werte: array of wgen; - params: tExtrainfos; - constructor create(ps: tExtrainfos); overload; - constructor create(original: pTLLWerteSingle; ps: tExtrainfos; xmin,xmax: longint); overload; - constructor create(original: pTLLWerteDouble; ps: tExtrainfos; xmin,xmax: longint); overload; - constructor create(original: pTLLWerteExtended; ps: tExtrainfos; xmin,xmax: longint); overload; - procedure kopiereVon(st: boolean; original: pTLLWerteSingle); overload; - procedure kopiereVon(st: boolean; original: pTLLWerteDouble); overload; - procedure kopiereVon(st: boolean; original: pTLLWerteExtended); overload; - procedure kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax: longint); overload; - procedure kopiereVon(st: boolean; original: pTLLWerteDouble; xmin,xmax: longint); overload; - procedure kopiereVon(st: boolean; original: pTLLWerteExtended; xmin,xmax: longint); overload; - procedure kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax,tmin,tmax: longint); overload; - procedure kopiereVon(st: boolean; original: pTLLWerteDouble; xmin,xmax,tmin,tmax: longint); overload; - procedure kopiereVon(st: boolean; original: pTLLWerteExtended; xmin,xmax,tmin,tmax: longint); overload; + params: tExtraInfos; + constructor create(ps: tExtraInfos); overload; + constructor create(original: pTLLWerteSingle; ps: tExtraInfos; xMin,xMax: longint); overload; + constructor create(original: pTLLWerteDouble; ps: tExtraInfos; xMin,xMax: longint); overload; + constructor create(original: pTLLWerteExtended; ps: tExtraInfos; xMin,xMax: longint); overload; + procedure kopiereVon(sT: boolean; original: pTLLWerteSingle); overload; + procedure kopiereVon(sT: boolean; original: pTLLWerteDouble); overload; + procedure kopiereVon(sT: boolean; original: pTLLWerteExtended); overload; + procedure kopiereVon(sT: boolean; original: pTLLWerteSingle; xMin,xMax: longint); overload; + procedure kopiereVon(sT: boolean; original: pTLLWerteDouble; xMin,xMax: longint); overload; + procedure kopiereVon(sT: boolean; original: pTLLWerteExtended; xMin,xMax: longint); overload; + procedure kopiereVon(sT: boolean; original: pTLLWerteSingle; xMin,xMax,tMin,tMax: longint); overload; + procedure kopiereVon(sT: boolean; original: pTLLWerteDouble; xMin,xMax,tMin,tMax: longint); overload; + procedure kopiereVon(sT: boolean; original: pTLLWerteExtended; xMin,xMax,tMin,tMax: longint); overload; 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: 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; - procedure kopiereLOVerzerrt(original: pTLLWerteSingle; xmin,xmax,tmin,tmax: longint; verhHo,verhVe: extended); overload; - procedure kopiereLOVerzerrt(original: pTLLWerteDouble; xmin,xmax,tmin,tmax: longint; verhHo,verhVe: extended); overload; - procedure kopiereLOVerzerrt(original: pTLLWerteExtended; xmin,xmax,tmin,tmax: longint; verhHo,verhVe: extended); 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; + procedure kopiereLOVerzerrt(original: pTLLWerteSingle; xMin,xMax,tMin,tMax: longint; verhHo,verhVe: extended); overload; + procedure kopiereLOVerzerrt(original: pTLLWerteDouble; xMin,xMax,tMin,tMax: longint; verhHo,verhVe: extended); overload; + procedure kopiereLOVerzerrt(original: pTLLWerteExtended; xMin,xMax,tMin,tMax: longint; verhHo,verhVe: extended); overload; destructor destroy; override; function liesDateien(dateien: tGenerischeInputDateiInfoArray): boolean; function fft(senkrecht,invers: boolean; algo: tFFTAlgorithmus; fen: tFenster; hg: extended; out pvFehler: extended): boolean; overload; inline; function fft(smin,smax: longint; senkrecht,invers: boolean; algo: tFFTAlgorithmus; fen: tFenster; hg: extended; out pvFehler: extended): boolean; overload; procedure spiegle; overload; - procedure spiegle(tmin,tmax: longint); overload; - procedure fft2dNachbearbeitungA(nb: tFFTDatenordnung); - procedure fft2dNachbearbeitungB(xmin,xmax: longint; nb: tFFTDatenordnung); + procedure spiegle(tMin,tMax: longint); overload; + procedure fft2dNachbearbeitungA(nB: tFFTDatenordnung); + procedure fft2dNachbearbeitungB(xMin,xMax: longint; nB: tFFTDatenordnung); + procedure fft2dNachbearbeitungVerdoppeln(nB: tFFTDatenordnung); procedure schreibeWert(var f: textfile; x,y: longint); overload; procedure schreibeWert(var f: textfile; x,y,wert: extended); overload; procedure schreibeWertIntegriert(var f: textfile; i: longint; hor: boolean); procedure erzeugeBinning(senkrecht,linien: boolean; x0,dx: extended; s: string); - procedure holeRam; inline; overload; - procedure holeRam(ausgaben: byte); inline; overload; - procedure holeRam(ausgaben: byte; gemaeszTXMinMax: boolean); inline; overload; - procedure gibMinMaxDichten(out wMi,wMa: extended; xmin,xmax,tmin,tmax: longint); - function zuPixelWerten(whoehe,wbreite,xpmi,xmi,tmi: longint; xz,yz: extended; pPWerte: pTExtendedArray; pPAnzahlen: pTLongintArray): boolean; - function findeSchwellwerte(xmi,xma,tmi,tma: longint; Schw: extended): tExtPointArray; - procedure integriereSingle(qu: pTLLWerteSingle; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung); - procedure integriereDouble(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung); - procedure integriereExtended(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung); + procedure holeRAM; inline; overload; + procedure holeRAM(ausgaben: byte); inline; overload; + procedure holeRAM(ausgaben: byte; gemaeszTXMinMax: boolean); inline; overload; + procedure gibMinMaxDichten(out wMi,wMa: extended; xMin,xMax,tMin,tMax: longint); + function zuPixelWerten(wHoehe,wBreite,xPMi,xMi,tMi: longint; xZ,yZ: extended; pPWerte: pTExtendedArray; pPAnzahlen: pTLongintArray): boolean; + function findeSchwellwerte(xMi,xMa,tMi,tMa: longint; Schw: extended): tExtPointArray; + procedure integriereSingle(qu: pTLLWerteSingle; xMi,xMa,tMi,tMa,xOf,tOf: longint; richtung: tIntegrationsRichtung); + procedure integriereDouble(qu: pTLLWerteDouble; xMi,xMa,tMi,tMa,xOf,tOf: longint; richtung: tIntegrationsRichtung); + procedure integriereExtended(qu: pTLLWerteDouble; xMi,xMa,tMi,tMa,xOf,tOf: longint; richtung: tIntegrationsRichtung); procedure gauszFit(amplituden,breiten,positionen,ueberlappe,hintergruende: pTLLWerteExtended; von,bis: longint; senkrecht: boolean; fensterBreite,maxBreite,maxVerschiebung: extended; positionsMitten: tExtendedArray); function ermittleHintergrund: extended; - procedure filtereHoheFrequenzen(betraege: tLLWerte; xFak,yFak: extended); + procedure kantenFilter(betraege: tLLWerte; xFak,yFak: extended; filterTyp: tKantenFilterTyp); overload; + procedure kantenFilter(betraege: tLLWerte; xFak,yFak: extended; filterTyp: tKantenFilterTyp; einseitig: boolean; out maxPos: tIntPoint); overload; procedure fenstereWerte(xMi,xMa,tMi,tMa: int64; xFen,tFen: tFenster; hg: extended); end; tLLWerteSingle = specialize tLLWerte<single>; @@ -77,7 +79,7 @@ type // andere Typen **************************************************************** tWavelet = class(tObject) freq,tfwhm,pvFehler: extended; - hlen: longint; + hLen: longint; typ: tWaveletTyp; werte: tLLWerteDouble; mitFFT: boolean; @@ -104,16 +106,16 @@ var tmp: tIntPoint; i,li,re,cnt: int64; begin - setlength(vons,1); + setLength(vons,1); vons[0]:=0; - setlength(biss,1); + setLength(biss,1); biss[0]:=length(maxima)-1; - setlength(mins,1); - setlength(maxs,1); + setLength(mins,1); + setLength(maxs,1); mins[0]:=0; maxs[0]:=0; for i:=vons[0] to biss[0] do begin - wert:=werte[maxima[i]['x']+maxima[i]['y']*params.xsteps]; + wert:=werte[maxima[i]['x']+maxima[i]['y']*params.xSteps]; if (i=vons[0]) or (wert>maxs[0]) then maxs[0]:=wert; if (i=vons[0]) or (wert<mins[0]) then @@ -131,10 +133,10 @@ begin end; if cnt>=length(vons) then begin - setlength(vons,cnt+100); - setlength(biss,cnt+100); - setlength(mins,cnt+100); - setlength(maxs,cnt+100); + setLength(vons,cnt+100); + setLength(biss,cnt+100); + setLength(mins,cnt+100); + setLength(maxs,cnt+100); end; pivot:=sqrt(maxs[cnt-1]*mins[cnt-1]);//(maxs[cnt-1]+mins[cnt-1])/2; @@ -145,14 +147,14 @@ begin mins[cnt-1]:=maxs[cnt-1]; while li<=re do begin - wertLi:=werte[maxima[li]['x']+maxima[li]['y']*params.xsteps]; + wertLi:=werte[maxima[li]['x']+maxima[li]['y']*params.xSteps]; if wertLi>=pivot then begin if wertLi<mins[cnt-1] then mins[cnt-1]:=wertLi; inc(li); continue; end; - wertRe:=werte[maxima[re]['x']+maxima[re]['y']*params.xsteps]; + wertRe:=werte[maxima[re]['x']+maxima[re]['y']*params.xSteps]; if wertRe<=pivot then begin if wertRe>maxs[cnt] then maxs[cnt]:=wertRe; @@ -180,139 +182,139 @@ begin end; end; -constructor tLLWerte.create(ps: tExtrainfos); +constructor tLLWerte.create(ps: tExtraInfos); begin inherited create; params:=ps; - setlength(werte,0); + setLength(werte,0); end; -constructor tLLWerte.create(original: pTLLWerteSingle; ps: tExtrainfos; xmin,xmax: longint); +constructor tLLWerte.create(original: pTLLWerteSingle; ps: tExtraInfos; xMin,xMax: longint); begin inherited create; params:=ps; - kopiereVon(false,original,xmin,xmax); + kopiereVon(false,original,xMin,xMax); end; -constructor tLLWerte.create(original: pTLLWerteDouble; ps: tExtrainfos; xmin,xmax: longint); +constructor tLLWerte.create(original: pTLLWerteDouble; ps: tExtraInfos; xMin,xMax: longint); begin inherited create; params:=ps; - kopiereVon(false,original,xmin,xmax); + kopiereVon(false,original,xMin,xMax); end; -constructor tLLWerte.create(original: pTLLWerteExtended; ps: tExtrainfos; xmin,xmax: longint); +constructor tLLWerte.create(original: pTLLWerteExtended; ps: tExtraInfos; xMin,xMax: longint); begin inherited create; params:=ps; - kopiereVon(false,original,xmin,xmax); + kopiereVon(false,original,xMin,xMax); end; -procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteSingle); +procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteSingle); begin - kopiereVon(st,original,0,original^.params.xsteps-1); + kopiereVon(sT,original,0,original^.params.xSteps-1); end; -procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteDouble); +procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteDouble); begin - kopiereVon(st,original,0,original^.params.xsteps-1); + kopiereVon(sT,original,0,original^.params.xSteps-1); end; -procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteExtended); +procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteExtended); begin - kopiereVon(st,original,0,original^.params.xsteps-1); + kopiereVon(sT,original,0,original^.params.xSteps-1); end; -procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax: longint); +procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteSingle; xMin,xMax: longint); begin - kopiereVon(st,original,xmin,xmax,0,original^.params.tsiz-1); + kopiereVon(sT,original,xMin,xMax,0,original^.params.tSiz-1); end; -procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteDouble; xmin,xmax: longint); +procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteDouble; xMin,xMax: longint); begin - kopiereVon(st,original,xmin,xmax,0,original^.params.tsiz-1); + kopiereVon(sT,original,xMin,xMax,0,original^.params.tSiz-1); end; -procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteExtended; xmin,xmax: longint); +procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteExtended; xMin,xMax: longint); begin - kopiereVon(st,original,xmin,xmax,0,original^.params.tsiz-1); + kopiereVon(sT,original,xMin,xMax,0,original^.params.tSiz-1); end; -procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax,tmin,tmax: longint); +procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteSingle; xMin,xMax,tMin,tMax: 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; + 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; zerstoereTransformationWennObsolet(params.transformationen); - params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xmin,xmax,tmin,tmax); + 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]; + 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); +procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteDouble; xMin,xMax,tMin,tMax: 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; + 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; zerstoereTransformationWennObsolet(params.transformationen); - params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xmin,xmax,tmin,tmax); + 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]; + 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); +procedure tLLWerte.kopiereVon(sT: boolean; original: pTLLWerteExtended; xMin,xMax,tMin,tMax: 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; + 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; zerstoereTransformationWennObsolet(params.transformationen); - params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xmin,xmax,tmin,tmax); + 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]; + 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; @@ -323,8 +325,8 @@ 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]; + 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); @@ -334,8 +336,8 @@ 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]; + 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); @@ -345,125 +347,125 @@ 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]; + 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: tTransformation; va,na: longint); +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 - werte[j+i*params.xsteps]:=0; - for i:=0 to length(ZPs)-1 do + 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 + 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 (va>0) or (na>0) then + 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] + + 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; + 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: pTLLWerteDouble; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint); +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 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 + 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 (va>0) or (na>0) then + 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] + + 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; + 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: tTransformation; va,na: longint); +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 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 + 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 (va>0) or (na>0) then + 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] + + 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; + 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.kopiereLOVerzerrt(original: pTLLWerteSingle; xmin,xmax,tmin,tmax: longint; verhHo,verhVe: extended); overload; +procedure tLLWerte.kopiereLOVerzerrt(original: pTLLWerteSingle; xMin,xMax,tMin,tMax: longint; verhHo,verhVe: extended); overload; var i,j,hV,hB,vV,vB,h,v: int64; begin - writeln(xmin,' .. ',xmax,' x ',tmin,' .. ',tmax); - for i:=tmin to tmax do begin + writeln(xMin,' .. ',xMax,' x ',tMin,' .. ',tMax); + for i:=tMin to tMax do begin if verhVe>0 then begin vV:=max( 0, round( - (params.tsiz-1-i+0.5)/ - (1 + (i+0.5)/verhVe/(params.tsiz-1)) + (params.tSiz-1-i+0.5)/ + (1 + (i+0.5)/verhVe/(params.tSiz-1)) ) ); vB:=min( - params.tsiz-1, + params.tSiz-1, round( - (params.tsiz-1-i+0.5)/ - (1 + (i-0.5)/verhVe/(params.tsiz-1)) + (params.tSiz-1-i+0.5)/ + (1 + (i-0.5)/verhVe/(params.tSiz-1)) ) ); end @@ -471,20 +473,20 @@ begin vV:=i; vB:=i; end; - for j:=xmin to xmax do begin + for j:=xMin to xMax do begin if verhHo>0 then begin hV:=max( 0, round( - (params.xsteps-1-(j+0.5))/ - (1 + (j+0.5)/verhHo/(params.xsteps-1)) + (params.xSteps-1-(j+0.5))/ + (1 + (j+0.5)/verhHo/(params.xSteps-1)) ) ); hB:=min( - params.xsteps-1, + params.xSteps-1, round( - (params.xsteps-1-(j-0.5))/ - (1 + (j-0.5)/verhHo/(params.xsteps-1)) + (params.xSteps-1-(j-0.5))/ + (1 + (j-0.5)/verhHo/(params.xSteps-1)) ) ); end @@ -492,38 +494,38 @@ begin hV:=j; hB:=j; end; - werte[j+i*params.xsteps]:=0; + werte[j+i*params.xSteps]:=0; for h:=hV to hB do for v:=vV to vB do - werte[j+i*params.xsteps]:= - werte[j+i*params.xsteps]+ - original^.werte[h+v*params.xsteps]; + werte[j+i*params.xSteps]:= + werte[j+i*params.xSteps]+ + original^.werte[h+v*params.xSteps]; if (hB>=hV) and (vB>=vV) then - werte[j+i*params.xsteps]:= - werte[j+i*params.xsteps] / (hB+1-hV) / (vB+1-vV); + werte[j+i*params.xSteps]:= + werte[j+i*params.xSteps] / (hB+1-hV) / (vB+1-vV); end; end; end; -procedure tLLWerte.kopiereLOVerzerrt(original: pTLLWerteDouble; xmin,xmax,tmin,tmax: longint; verhHo,verhVe: extended); overload; +procedure tLLWerte.kopiereLOVerzerrt(original: pTLLWerteDouble; xMin,xMax,tMin,tMax: longint; verhHo,verhVe: extended); overload; var i,j,hV,hB,vV,vB,h,v: int64; begin - writeln(xmin,' .. ',xmax,' x ',tmin,' .. ',tmax); - for i:=tmin to tmax do begin + writeln(xMin,' .. ',xMax,' x ',tMin,' .. ',tMax); + for i:=tMin to tMax do begin if verhVe>0 then begin vV:=max( 0, round( - (params.tsiz-1-i+0.5)/ - (1 + (i+0.5)/verhVe/(params.tsiz-1)) + (params.tSiz-1-i+0.5)/ + (1 + (i+0.5)/verhVe/(params.tSiz-1)) ) ); vB:=min( - params.tsiz-1, + params.tSiz-1, round( - (params.tsiz-1-i+0.5)/ - (1 + (i-0.5)/verhVe/(params.tsiz-1)) + (params.tSiz-1-i+0.5)/ + (1 + (i-0.5)/verhVe/(params.tSiz-1)) ) ); end @@ -531,20 +533,20 @@ begin vV:=i; vB:=i; end; - for j:=xmin to xmax do begin + for j:=xMin to xMax do begin if verhHo>0 then begin hV:=max( 0, round( - (params.xsteps-1-(j+0.5))/ - (1 + (j+0.5)/verhHo/(params.xsteps-1)) + (params.xSteps-1-(j+0.5))/ + (1 + (j+0.5)/verhHo/(params.xSteps-1)) ) ); hB:=min( - params.xsteps-1, + params.xSteps-1, round( - (params.xsteps-1-(j-0.5))/ - (1 + (j-0.5)/verhHo/(params.xsteps-1)) + (params.xSteps-1-(j-0.5))/ + (1 + (j-0.5)/verhHo/(params.xSteps-1)) ) ); end @@ -552,38 +554,38 @@ begin hV:=j; hB:=j; end; - werte[j+i*params.xsteps]:=0; + werte[j+i*params.xSteps]:=0; for h:=hV to hB do for v:=vV to vB do - werte[j+i*params.xsteps]:= - werte[j+i*params.xsteps]+ - original^.werte[h+v*params.xsteps]; + werte[j+i*params.xSteps]:= + werte[j+i*params.xSteps]+ + original^.werte[h+v*params.xSteps]; if (hB>=hV) and (vB>=vV) then - werte[j+i*params.xsteps]:= - werte[j+i*params.xsteps] / (hB+1-hV) / (vB+1-vV); + werte[j+i*params.xSteps]:= + werte[j+i*params.xSteps] / (hB+1-hV) / (vB+1-vV); end; end; end; -procedure tLLWerte.kopiereLOVerzerrt(original: pTLLWerteExtended; xmin,xmax,tmin,tmax: longint; verhHo,verhVe: extended); overload; +procedure tLLWerte.kopiereLOVerzerrt(original: pTLLWerteExtended; xMin,xMax,tMin,tMax: longint; verhHo,verhVe: extended); overload; var i,j,hV,hB,vV,vB,h,v: int64; begin - writeln(xmin,' .. ',xmax,' x ',tmin,' .. ',tmax); - for i:=tmin to tmax do begin + writeln(xMin,' .. ',xMax,' x ',tMin,' .. ',tMax); + for i:=tMin to tMax do begin if verhVe>0 then begin vV:=max( 0, round( - (params.tsiz-1-i+0.5)/ - (1 + (i+0.5)/verhVe/(params.tsiz-1)) + (params.tSiz-1-i+0.5)/ + (1 + (i+0.5)/verhVe/(params.tSiz-1)) ) ); vB:=min( - params.tsiz-1, + params.tSiz-1, round( - (params.tsiz-1-i+0.5)/ - (1 + (i-0.5)/verhVe/(params.tsiz-1)) + (params.tSiz-1-i+0.5)/ + (1 + (i-0.5)/verhVe/(params.tSiz-1)) ) ); end @@ -591,20 +593,20 @@ begin vV:=i; vB:=i; end; - for j:=xmin to xmax do begin + for j:=xMin to xMax do begin if verhHo>0 then begin hV:=max( 0, round( - (params.xsteps-1-(j+0.5))/ - (1 + (j+0.5)/verhHo/(params.xsteps-1)) + (params.xSteps-1-(j+0.5))/ + (1 + (j+0.5)/verhHo/(params.xSteps-1)) ) ); hB:=min( - params.xsteps-1, + params.xSteps-1, round( - (params.xsteps-1-(j-0.5))/ - (1 + (j-0.5)/verhHo/(params.xsteps-1)) + (params.xSteps-1-(j-0.5))/ + (1 + (j-0.5)/verhHo/(params.xSteps-1)) ) ); end @@ -612,50 +614,50 @@ begin hV:=j; hB:=j; end; - werte[j+i*params.xsteps]:=0; + werte[j+i*params.xSteps]:=0; for h:=hV to hB do for v:=vV to vB do - werte[j+i*params.xsteps]:= - werte[j+i*params.xsteps]+ - original^.werte[h+v*params.xsteps]; + werte[j+i*params.xSteps]:= + werte[j+i*params.xSteps]+ + original^.werte[h+v*params.xSteps]; if (hB>=hV) and (vB>=vV) then - werte[j+i*params.xsteps]:= - werte[j+i*params.xsteps] / (hB+1-hV) / (vB+1-vV); + werte[j+i*params.xSteps]:= + werte[j+i*params.xSteps] / (hB+1-hV) / (vB+1-vV); end; end; end; destructor tLLWerte.destroy; begin - setlength(werte,0); + setLength(werte,0); inherited destroy; end; function tLLWerte.liesDateien(dateien: tGenerischeInputDateiInfoArray): boolean; var - i,j,k,l,tmpi,etsiz,spAnz,br: longint; + i,j,k,l,tmpI,etsiz,spAnz,br: longint; f: file; - tmps: single; - tmpd: double; - tmpe,Zeit: extended; - sa: tSingleArray; + tmpS: single; + tmpD: double; + tmpE,Zeit: extended; + sA: tSingleArray; da: tDoubleArray; ea: tExtendedArray; - ipp: tProcess; + iPP: tProcess; buf: tByteArray; etwasGelesen: boolean; s: string; begin result:=false; gibAus('... Dateien einlesen ...',1); - zeit:=now; - tmpi:=0; - tmps:=0; - tmpd:=0; + 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); + gibAus(' '+dateien[i].name,1); etwasGelesen:=false; if dateien[i] is tPipeInputDateiInfo then begin if ((dateien[i] as tPipeInputDateiInfo).bytesPerSample<>4) or @@ -663,42 +665,42 @@ 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); + 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; + 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); + 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); + 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; @@ -707,77 +709,77 @@ begin end; if (dateien[i] is tSpaceTimeInputDateiInfo) or (dateien[i] is tTraceInputDateiInfo) then begin - assign(f,dateien[i].Name); + 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); + 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); close(f); exit; end; if dateien[i] is tTraceInputDateiInfo then begin - blockread(f,tmpi,sizeof(integer)); // #Traces - spAnz:=tmpi; + blockread(f,tmpI,sizeOf(integer)); // #Traces + spAnz:=tmpI; end; - blockread(f,etsiz,sizeof(integer)); + 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 + case dateien[i].genauigkeit of gSingle: begin - blockread(f,tmps,sizeof(single)); // xstart - tmpe:=tmps; + blockread(f,tmpS,sizeOf(single)); // xStart + tmpE:=tmpS; end; gDouble: begin - blockread(f,tmpd,sizeof(double)); // xstart - tmpe:=tmpd; + blockread(f,tmpD,sizeOf(double)); // xStart + tmpE:=tmpD; end; gExtended: - blockread(f,tmpe,sizeof(extended)); // xstart + 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); + 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 + case dateien[i].genauigkeit of gSingle: begin - blockread(f,tmps,sizeof(single)); // xstop - tmpe:=tmps; + blockread(f,tmpS,sizeOf(single)); // xStop + tmpE:=tmpS; end; gDouble: begin - blockread(f,tmpd,sizeof(double)); // xstop - tmpe:=tmpd; + blockread(f,tmpD,sizeOf(double)); // xStop + tmpE:=tmpD; end; gExtended: - blockread(f,tmpe,sizeof(extended)); // xstop + 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); + 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); + 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) = wertGroesze(Dateien[i].Genauigkeit) then - blockread(f,werte[(j+Dateien[i].t0abs)*params.xsteps],params.xsteps*sizeof(wgen)) + if sizeOf(wgen) = wertGroesze(dateien[i].genauigkeit) 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]; + 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); + 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); @@ -786,37 +788,37 @@ begin etwasGelesen:=true; end; if dateien[i] is tTraceInputDateiInfo then begin - case Dateien[i].Genauigkeit of + case dateien[i].genauigkeit of gSingle: begin - setlength(sa,etsiz); - setlength(da,0); - setlength(ea,0); + setLength(sA,etsiz); + setLength(da,0); + setLength(ea,0); end; gDouble: begin - setlength(sa,0); - setlength(da,etsiz); - setlength(ea,0); + setLength(sA,0); + setLength(da,etsiz); + setLength(ea,0); end; gExtended: begin - setlength(sa,0); - setlength(da,0); - setlength(ea,etsiz); + 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 + 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; + 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); + 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; @@ -826,17 +828,17 @@ begin 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; + 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 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); + 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; @@ -846,17 +848,17 @@ begin 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; + 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 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); + 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; @@ -868,7 +870,7 @@ begin end{of Case}; end; if not eof(f) then begin - gibAus('Zu viele Daten in '''+dateien[i].Name+'''!',3); + gibAus('Zu viele Daten in '''+dateien[i].name+'''!',3); close(f); exit; end; @@ -880,50 +882,50 @@ begin close(f); exit; end; - assign(f,dateien[i].Name); + 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)); + 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 dateien[i] is tSergeyInputDateiInfo then begin - etsiz:=Dateien[i].tsiz; + etsiz:=dateien[i].tSiz; - setlength(buf,sizeof(extended)*anzSergeyFelder); - tmpi:=wertGroesze(Dateien[i].Genauigkeit); + setLength(buf,sizeOf(extended)*anzSergeyFelder); + tmpI:=wertGroesze(dateien[i].genauigkeit); - assign(f,dateien[i].Name+'traces/traces.dat'); + assign(f,dateien[i].name+'traces/traces.dat'); reset(f,1); - setlength(buf,tmpi*anzSergeyFelder); + setLength(buf,tmpI*anzSergeyFelder); for j:=0 to etsiz-1 do begin - if (Dateien[i] as tSergeyInputDateiInfo).Feldnummer>0 then - blockread(f,buf[0],(Dateien[i] as tSergeyInputDateiInfo).Feldnummer*tmpi); + if (dateien[i] as tSergeyInputDateiInfo).feldNummer>0 then + blockread(f,buf[0],(dateien[i] as tSergeyInputDateiInfo).feldNummer*tmpI); case dateien[i].genauigkeit of gSingle: begin - blockread(f,tmps,tmpi); - werte[j]:=tmps; + blockread(f,tmpS,tmpI); + werte[j]:=tmpS; end; gDouble: begin - blockread(f,tmpd,tmpi); - werte[j]:=tmpd; + blockread(f,tmpD,tmpI); + werte[j]:=tmpD; end; gExtended: begin - blockread(f,tmpe,tmpi); - werte[j]:=tmpe; + blockread(f,tmpE,tmpI); + werte[j]:=tmpE; end; end{of Case}; - if (Dateien[i] as tSergeyInputDateiInfo).Feldnummer<anzSergeyFelder-1 then - blockread(f,buf[0],(anzSergeyFelder-1-(Dateien[i] as tSergeyInputDateiInfo).Feldnummer)*tmpi); + if (dateien[i] as tSergeyInputDateiInfo).feldNummer<anzSergeyFelder-1 then + blockread(f,buf[0],(anzSergeyFelder-1-(dateien[i] as tSergeyInputDateiInfo).feldNummer)*tmpI); end; - setlength(buf,0); + setLength(buf,0); if not eof(f) then begin - gibAus('Zu viele Daten in '''+dateien[i].Name+'traces/traces.dat''!',3); + gibAus('Zu viele Daten in '''+dateien[i].name+'traces/traces.dat''!',3); close(f); exit; end; @@ -931,29 +933,29 @@ begin etwasGelesen:=true; end; if dateien[i] is tAndorInputDateiInfo then begin - etsiz:=dateien[i].tsiz; + etsiz:=dateien[i].tSiz; - assign(f,dateien[i].Name); + assign(f,dateien[i].name); reset(f,1); seek(f,(dateien[i] as tAndorInputDateiInfo).datenStart); - tmpi:=wertGroesze(dateien[i].genauigkeit); - if tmpi = sizeOf(wgen) then - blockread(f,werte[0],dateien[i].xsteps*dateien[i].tsiz*tmpi) + tmpI:=wertGroesze(dateien[i].genauigkeit); + if tmpI = sizeOf(wgen) then + blockread(f,werte[0],dateien[i].xSteps*dateien[i].tSiz*tmpI) else case dateien[i].genauigkeit of gSingle: - for j:=0 to dateien[i].xsteps*dateien[i].tsiz-1 do begin - blockread(f,tmps,tmpi); - werte[j]:=tmps; + for j:=0 to dateien[i].xSteps*dateien[i].tSiz-1 do begin + blockread(f,tmpS,tmpI); + werte[j]:=tmpS; end; gDouble: - for j:=0 to dateien[i].xsteps*dateien[i].tsiz-1 do begin - blockread(f,tmpd,tmpi); - werte[j]:=tmpd; + for j:=0 to dateien[i].xSteps*dateien[i].tSiz-1 do begin + blockread(f,tmpD,tmpI); + werte[j]:=tmpD; end; gExtended: - for j:=0 to dateien[i].xsteps*dateien[i].tsiz-1 do begin - blockread(f,tmpe,tmpi); - werte[j]:=tmpe; + for j:=0 to dateien[i].xSteps*dateien[i].tSiz-1 do begin + blockread(f,tmpE,tmpI); + werte[j]:=tmpE; end; end{of case}; try @@ -962,8 +964,8 @@ begin s:='falsch'; end; if s<>'' then begin - gibAus('Syntax-Fehler in '''+dateien[i].Name+''': vmtl. zu viele/wenige Daten.',3); - closefile(f); + gibAus('Syntax-Fehler in '''+dateien[i].name+''': vmtl. zu viele/wenige Daten.',3); + closeFile(f); exit; end; close(f); @@ -979,25 +981,25 @@ begin result:=true; end; -procedure tLLWerte.gibMinMaxDichten(out wMi,wMa: extended; xmin,xmax,tmin,tmax: longint); +procedure tLLWerte.gibMinMaxDichten(out wMi,wMa: extended; xMin,xMax,tMin,tMax: longint); var i,j: longint; begin - wMi:=werte[xmin+tmin*params.xsteps]; - wMa:=Werte[xmin+tmin*params.xsteps]; - for i:=xmin to xmax do - for j:=tmin to tmax do begin - wMi:=min(wMi,werte[i+j*params.xsteps]); - wMa:=max(wMa,werte[i+j*params.xsteps]); + wMi:=werte[xMin+tMin*params.xSteps]; + wMa:=werte[xMin+tMin*params.xSteps]; + for i:=xMin to xMax do + for j:=tMin to tMax do begin + wMi:=min(wMi,werte[i+j*params.xSteps]); + wMa:=max(wMa,werte[i+j*params.xSteps]); end; end; function tLLWerte.fft(senkrecht,invers: boolean; algo: tFFTAlgorithmus; fen: tFenster; hg: extended; out pvFehler: extended): boolean; begin if senkrecht then - result:=fft(0,params.xsteps-1,senkrecht,invers,algo,fen,hg,pvFehler) + result:=fft(0,params.xSteps-1,senkrecht,invers,algo,fen,hg,pvFehler) else - result:=fft(0,params.tsiz-1,senkrecht,invers,algo,fen,hg,pvFehler); + result:=fft(0,params.tSiz-1,senkrecht,invers,algo,fen,hg,pvFehler); end; function tLLWerte.fft(smin,smax: longint; senkrecht,invers: boolean; algo: tFFTAlgorithmus; fen: tFenster; hg: extended; out pvFehler: extended): boolean; @@ -1008,28 +1010,28 @@ var begin result:=false; if senkrecht then begin - pmax:=params.tsiz-1; - pstep:=params.xsteps; + pmax:=params.tSiz-1; + pstep:=params.xSteps; sstep:=1; end else begin - pmax:=params.xsteps-1; + pmax:=params.xSteps-1; pstep:=1; - sstep:=params.xsteps; + sstep:=params.xSteps; end; if assigned(fen) and fen.aktiv then begin if invers then gibAus('fft: Warnung, hier wird bei einer inversen FFT gefenstert - soll das so sein?',1); offset:=byte(not invers)*hg; - if length(fen.Werte)<>pmax+1 then begin - gibAus('Die Breite des FFT-Fensters ('+inttostr(length(fen.Werte))+') ist nicht gleich der Breite der Werte ('+inttostr(pmax+1)+')!',1); + if length(fen.werte)<>pmax+1 then begin + gibAus('Die Breite des FFT-Fensters ('+intToStr(length(fen.werte))+') ist nicht gleich der Breite der Werte ('+intToStr(pmax+1)+')!',1); exit; end; - for i:=smin to smax do // Werte fenstern + for i:=smin to smax do // werte fenstern for j:=0 to pmax do werte[i*sstep+j*pstep]:= - (werte[i*sstep+j*pstep]-offset)*fen.Werte[j]; + (werte[i*sstep+j*pstep]-offset)*fen.werte[j]; end; vorher:=0; @@ -1037,8 +1039,8 @@ begin in0:=true; out0:=true; - case sizeof(wgen) of - sizeof(single): + case sizeOf(wgen) of + sizeOf(single): for i:=smin to smax do begin algo.laden(invers,pSingle(@(werte[i*sstep])),pstep); algo.summen(true,vorher,in0); @@ -1046,7 +1048,7 @@ begin algo.summen(false,nachher,out0); algo.speichern(invers,pSingle(@(werte[i*sstep])),pstep); end; - sizeof(double): + sizeOf(double): for i:=smin to smax do begin algo.laden(invers,pDouble(@(werte[i*sstep])),pstep); algo.summen(true,vorher,in0); @@ -1054,7 +1056,7 @@ begin algo.summen(false,nachher,out0); algo.speichern(invers,pDouble(@(werte[i*sstep])),pstep); end; - sizeof(extended): + sizeOf(extended): for i:=smin to smax do begin algo.laden(invers,pExtended(@(werte[i*sstep])),pstep); algo.summen(true,vorher,in0); @@ -1073,7 +1075,7 @@ begin werte[i*sstep+j*pstep]:= werte[i*sstep+j*pstep]+hg; - gibAus(inttostr(byte(senkrecht))+' '+inttostr(byte(invers))+' (Parseval-Fehler = '+floattostr(pvFehler)+') ... nämlich von '+floattostr(vorher)+' zu '+floattostr(nachher),1); + gibAus(intToStr(byte(senkrecht))+' '+intToStr(byte(invers))+' (Parseval-Fehler = '+floatToStr(pvFehler)+') ... nämlich von '+floatToStr(vorher)+' zu '+floatToStr(nachher),1); if in0 then gibAus('Nur Nullen im Input der FFT!',1); if out0 then gibAus('Nur Nullen im Output der FFT!',1); result:=not (in0 or out0); @@ -1081,22 +1083,22 @@ 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; begin - if params.xstop=params.xstart then - xa:=params.xstop + 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 + 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)); + 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); @@ -1106,14 +1108,14 @@ var 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); + 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); + 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; @@ -1123,21 +1125,21 @@ var i: longint; sum,x: extended; begin - assignfile(f,s); + assignFile(f,s); rewrite(f); sum:=0; while x0<0 do x0:=x0+dx; - for i:=0 to params.xsteps*params.tsiz-1 do + 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 + 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)); + 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,floatToStr(x)+' 0'); writeln(f) end; sum:=werte[i]*(i+1-x0); @@ -1145,144 +1147,229 @@ begin end else sum:=sum+werte[i]; - closefile(f); + closeFile(f); end; procedure tLLWerte.spiegle; begin - spiegle(0,params.tsiz-1); + spiegle(0,params.tSiz-1); end; -procedure tLLWerte.spiegle(tmin,tmax: longint); +procedure tLLWerte.spiegle(tMin,tMax: longint); var i,j: longint; tmp: wgen; begin - for i:=tmin to tmax do - for j:=0 to params.xsteps div 2 -1 do begin - tmp:=werte[j+i*params.xsteps]; - werte[j+i*params.xsteps]:=werte[params.xsteps-j-1+i*params.xsteps]; - werte[params.xsteps-j-1+i*params.xsteps]:=tmp; + for i:=tMin to tMax do + for j:=0 to params.xSteps div 2 -1 do begin + tmp:=werte[j+i*params.xSteps]; + werte[j+i*params.xSteps]:=werte[params.xSteps-j-1+i*params.xSteps]; + werte[params.xSteps-j-1+i*params.xSteps]:=tmp; end; end; -procedure tLLWerte.fft2dNachbearbeitungA(nb: tFFTDatenordnung); +procedure tLLWerte.fft2dNachbearbeitungA(nB: tFFTDatenordnung); var i: longint; begin - case NB of + case nB of doResIms,doResSmi: ; doBetr: begin werte[0]:=abs(extended(werte[0])); // rein reell - for i:=1 to params.xsteps div 2 -1 do begin // unterste Zeile ist reell in t - werte[i]:=sqrt(sqr(extended(werte[i]))+sqr(extended(werte[params.xsteps-i]))); - werte[params.xsteps-i]:=werte[i]; + for i:=1 to params.xSteps div 2 -1 do begin // unterste Zeile ist reell in t + werte[i]:=sqrt(sqr(extended(werte[i]))+sqr(extended(werte[params.xSteps-i]))); + werte[params.xSteps-i]:=werte[i]; end; - for i:=1 to params.xsteps div 2 -1 do begin // mittlere Zeile ist reell in t - werte[i+(params.tsiz div 2)*params.xsteps]:=sqrt(sqr(extended(werte[i+(params.tsiz div 2)*params.xsteps]))+sqr(extended(werte[params.xsteps-i+(params.tsiz div 2)*params.xsteps]))); - werte[params.xsteps-i+(params.tsiz div 2)*params.xsteps]:=werte[i+(params.tsiz div 2)*params.xsteps]; + for i:=1 to params.xSteps div 2 -1 do begin // mittlere Zeile ist reell in t + werte[i+(params.tSiz div 2)*params.xSteps]:=sqrt(sqr(extended(werte[i+(params.tSiz div 2)*params.xSteps]))+sqr(extended(werte[params.xSteps-i+(params.tSiz div 2)*params.xSteps]))); + werte[params.xSteps-i+(params.tSiz div 2)*params.xSteps]:=werte[i+(params.tSiz div 2)*params.xSteps]; end; - werte[params.xsteps div 2]:=abs(extended(werte[params.xsteps div 2])); // rein reell - werte[params.tsiz div 2]:=abs(extended(werte[params.tsiz div 2])); // rein reell - for i:=1 to params.tsiz div 2 -1 do begin // linkeste Spalte ist reell in x - werte[i*params.xsteps]:=sqrt(sqr(extended(werte[i*params.xsteps]))+sqr(extended(werte[(params.tsiz-i)*params.xsteps]))); - werte[(params.tsiz-i)*params.xsteps]:=werte[i*params.xsteps]; + werte[params.xSteps div 2]:=abs(extended(werte[params.xSteps div 2])); // rein reell + werte[params.tSiz div 2]:=abs(extended(werte[params.tSiz div 2])); // rein reell + for i:=1 to params.tSiz div 2 -1 do begin // linkeste Spalte ist reell in x + werte[i*params.xSteps]:=sqrt(sqr(extended(werte[i*params.xSteps]))+sqr(extended(werte[(params.tSiz-i)*params.xSteps]))); + werte[(params.tSiz-i)*params.xSteps]:=werte[i*params.xSteps]; end; - for i:=1 to params.tsiz div 2 -1 do begin // mittlere Spalte ist reell in x - werte[params.xsteps div 2 + i*params.xsteps]:=sqrt(sqr(extended(werte[params.xsteps div 2 + i*params.xsteps]))+sqr(extended(werte[params.xsteps div 2 + (params.tsiz-i)*params.xsteps]))); - werte[params.xsteps div 2 + (params.tsiz-i)*params.xsteps]:=werte[params.xsteps div 2 + i*params.xsteps]; + for i:=1 to params.tSiz div 2 -1 do begin // mittlere Spalte ist reell in x + werte[params.xSteps div 2 + i*params.xSteps]:=sqrt(sqr(extended(werte[params.xSteps div 2 + i*params.xSteps]))+sqr(extended(werte[params.xSteps div 2 + (params.tSiz-i)*params.xSteps]))); + werte[params.xSteps div 2 + (params.tSiz-i)*params.xSteps]:=werte[params.xSteps div 2 + i*params.xSteps]; end; end; doBetrQdr: begin werte[0]:=sqr(extended(werte[0])); // rein reell - for i:=1 to params.xsteps div 2 -1 do begin // unterste Zeile ist reell in t - werte[i]:=sqr(extended(werte[i]))+sqr(extended(werte[params.xsteps-i])); - werte[params.xsteps-i]:=werte[i]; + for i:=1 to params.xSteps div 2 -1 do begin // unterste Zeile ist reell in t + werte[i]:=sqr(extended(werte[i]))+sqr(extended(werte[params.xSteps-i])); + werte[params.xSteps-i]:=werte[i]; end; - for i:=1 to params.xsteps div 2 -1 do begin // mittlere Zeile ist reell in t - werte[i+(params.tsiz div 2)*params.xsteps]:=sqr(extended(werte[i+(params.tsiz div 2)*params.xsteps]))+sqr(extended(werte[params.xsteps-i+(params.tsiz div 2)*params.xsteps])); - werte[params.xsteps-i+(params.tsiz div 2)*params.xsteps]:=werte[i+(params.tsiz div 2)*params.xsteps]; + for i:=1 to params.xSteps div 2 -1 do begin // mittlere Zeile ist reell in t + werte[i+(params.tSiz div 2)*params.xSteps]:=sqr(extended(werte[i+(params.tSiz div 2)*params.xSteps]))+sqr(extended(werte[params.xSteps-i+(params.tSiz div 2)*params.xSteps])); + werte[params.xSteps-i+(params.tSiz div 2)*params.xSteps]:=werte[i+(params.tSiz div 2)*params.xSteps]; end; - werte[params.xsteps div 2]:=sqr(extended(werte[params.xsteps div 2])); // rein reell - werte[params.tsiz div 2]:=sqr(extended(werte[params.tsiz div 2])); // rein reell - for i:=1 to params.tsiz div 2 -1 do begin // linkeste Spalte ist reell in x - werte[i*params.xsteps]:=sqr(extended(werte[i*params.xsteps]))+sqr(extended(werte[(params.tsiz-i)*params.xsteps])); - werte[(params.tsiz-i)*params.xsteps]:=werte[i*params.xsteps]; + werte[params.xSteps div 2]:=sqr(extended(werte[params.xSteps div 2])); // rein reell + werte[params.tSiz div 2]:=sqr(extended(werte[params.tSiz div 2])); // rein reell + for i:=1 to params.tSiz div 2 -1 do begin // linkeste Spalte ist reell in x + werte[i*params.xSteps]:=sqr(extended(werte[i*params.xSteps]))+sqr(extended(werte[(params.tSiz-i)*params.xSteps])); + werte[(params.tSiz-i)*params.xSteps]:=werte[i*params.xSteps]; end; - for i:=1 to params.tsiz div 2 -1 do begin // mittlere Spalte ist reell in x - werte[params.xsteps div 2 + i*params.xsteps]:=sqr(extended(werte[params.xsteps div 2 + i*params.xsteps]))+sqr(extended(werte[params.xsteps div 2 + (params.tsiz-i)*params.xsteps])); - werte[params.xsteps div 2 + (params.tsiz-i)*params.xsteps]:=werte[params.xsteps div 2 + i*params.xsteps]; + for i:=1 to params.tSiz div 2 -1 do begin // mittlere Spalte ist reell in x + werte[params.xSteps div 2 + i*params.xSteps]:=sqr(extended(werte[params.xSteps div 2 + i*params.xSteps]))+sqr(extended(werte[params.xSteps div 2 + (params.tSiz-i)*params.xSteps])); + werte[params.xSteps div 2 + (params.tSiz-i)*params.xSteps]:=werte[params.xSteps div 2 + i*params.xSteps]; end; end; + else + raise exception.create('Nachbearbeitungsmethode '+fftDoToStr(nB)+' nicht implementiert!'); end{of case}; end; -procedure tLLWerte.fft2dNachbearbeitungB(xmin,xmax: longint; nb: tFFTDatenordnung); +procedure tLLWerte.fft2dNachbearbeitungB(xMin,xMax: longint; nB: tFFTDatenordnung); var i,j: longint; begin // bearbeitet nur den Hauptteil (außer erster und mittlerer Zeile/Spalte) nach! - case nb of + case nB of + doResIms,doResSmi: ; doBetr: begin - for i:=xmin to xmax do - for j:=1 to params.tsiz div 2 -1 do begin - werte[i+j*params.xsteps]:= - sqrt(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]; - werte[params.xsteps-i+(params.tsiz-j)*params.xsteps]:=werte[i+j*params.xsteps]; + for i:=xMin to xMax do + for j:=1 to params.tSiz div 2 -1 do begin + werte[i+j*params.xSteps]:= + sqrt(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]; + werte[params.xSteps-i+(params.tSiz-j)*params.xSteps]:=werte[i+j*params.xSteps]; end; end; doBetrQdr: begin - 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[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]; - werte[params.xsteps-i+(params.tsiz-j)*params.xsteps]:=werte[i+j*params.xsteps]; + 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[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]; + werte[params.xSteps-i+(params.tSiz-j)*params.xSteps]:=werte[i+j*params.xSteps]; end; end; + else + raise exception.create('Nachbearbeitungsmethode '+fftDoToStr(nB)+' nicht implementiert!'); end{of case} end; -procedure tLLWerte.holeRam; +procedure tLLWerte.fft2dNachbearbeitungVerdoppeln(nB: tFFTDatenordnung); +var + i,j,xS2,tS4: int64; + reRe,reIm,imRe,imIm: extended; begin - holeRam(1); + // Vorsicht: + // Spalten sind zuerst tSiz/2 lang und dann tSiz. + // Zeilen behalten ihre Länge von xSteps. + xS2:=params.xSteps div 2; + tS4:=params.tSiz div 4; + case nB of + doAlleResSmi: + for j:=tS4 downto 0 do + for i:=xS2 downto 0 do begin + reRe:=werte[i + j*xS2]; + if (i<>0) and (i<>xS2) then + imRe:=werte[-i + (j+1)*xS2] + else + imRe:=0; // erste und mittlere Spalte ist x-reell + if (j<>0) and (j<>tS4) then + reIm:=werte[i + (2*tS4-j)*xS2] + else + reIm:=0; // erste und mittlere Zeile ist t-reell + if (i<>0) and (i<>xS2) and (j<>0) and (j<>tS4) then + imIm:=werte[-i + (2*tS4-j+1)*xS2] + else + imIm:=0; // erste und mittlere Zeile und Spalte sind x-t-reell + + werte[i + j *2*xS2]:=reRe-imIm; + werte[i + (4*tS4-j)*2*xS2]:=reIm+imRe; + if (i<>0) and (i<>xS2) then begin + werte[2*xS2-i + j *2*xS2]:= reRe+imIm; + werte[2*xS2-i + (4*tS4-j)*2*xS2]:=-imRe+reIm; + end; + if (j<>0) and (j<>2*tS4) then begin + werte[i + (2*tS4-j)*2*xS2]:=reRe+imIm; + werte[i + (2*tS4+j)*2*xS2]:=imRe-reIm; + if (i<>0) and (i<>xS2) then begin + werte[2*xS2-i + (2*tS4-j)*2*xS2]:= reRe-imIm; + werte[2*xS2-i + (2*tS4+j)*2*xS2]:=-imRe-reIm; + end; + end; + end; + doAlleResIms: + for j:=tS4 downto 0 do + for i:=xS2 downto 0 do begin + reRe:=werte[i + j*xS2]; + if (i<>0) and (i<>xS2) then + imRe:=werte[-i + (j+1)*xS2] + else + imRe:=0; // erste und mittlere Spalte ist x-reell + if (j<>0) and (j<>tS4) then + reIm:=werte[i + (2*tS4-j)*xS2] + else + reIm:=0; // erste und mittlere Zeile ist t-reell + if (i<>0) and (i<>xS2) and (j<>0) and (j<>tS4) then + imIm:=werte[-i + (2*tS4-j+1)*xS2] + else + imIm:=0; // erste und mittlere Zeile und Spalte sind x-t-reell + + werte[i + j *2*xS2]:=reRe-imIm; + werte[i + (2*tS4+j)*2*xS2]:=reIm+imRe; + if (i<>0) and (i<>xS2) then begin + werte[2*xS2-i + j *2*xS2]:= reRe+imIm; + werte[2*xS2-i + (2*tS4+j)*2*xS2]:=-imRe+reIm; + end; + if (j<>0) and (j<>2*tS4) then begin + werte[i + (2*tS4-j)*2*xS2]:=reRe+imIm; + werte[i + (4*tS4-j)*2*xS2]:=imRe-reIm; + if (i<>0) and (i<>xS2) then begin + werte[2*xS2-i + (2*tS4-j)*2*xS2]:= reRe-imIm; + werte[2*xS2-i + (4*tS4-j)*2*xS2]:=-imRe-reIm; + end; + end; + end; + else + raise exception.create('Nachbearbeitungsmethode '+fftDoToStr(nB)+' verdoppelt die Anzahl der Daten nicht!'); + end{of case}; +end; + +procedure tLLWerte.holeRAM; +begin + holeRAM(1); end; -procedure tLLWerte.holeRam(ausgaben: byte); +procedure tLLWerte.holeRAM(ausgaben: byte); begin - holeRam(ausgaben,false); + holeRAM(ausgaben,false); end; -procedure tLLWerte.holeRam(ausgaben: byte; gemaeszTXMinMax: boolean); +procedure tLLWerte.holeRAM(ausgaben: byte; gemaeszTXMinMax: boolean); var Zeit: extended; br,ho: longint; begin Zeit:=now; if gemaeszTXMinMax then begin - br:=params.xsteps_; - ho:=params.tsiz_; + br:=params.xSteps_; + ho:=params.tSiz_; end else begin - br:=params.xsteps; - ho:=params.tsiz; + br:=params.xSteps; + ho:=params.tSiz; end; if (ausgaben and __ausgabenMaske) <> 0 then - gibAus('Fordere '+inttostr(floor(ho*br*sizeof(wgen)/1024/1024))+' MB RAM an ('+inttostr(br)+' x-Schritte mal '+inttostr(ho)+' t-Schritte; bisher '+inttostr(belegterSpeicher div 1024)+' MB belegt). ...',ausgaben); + gibAus('Fordere '+intToStr(floor(ho*br*sizeOf(wgen)/1024/1024))+' MB RAM an ('+intToStr(br)+' x-Schritte mal '+intToStr(ho)+' t-Schritte; bisher '+intToStr(belegterSpeicher div 1024)+' MB belegt). ...',ausgaben); - setlength(werte,br*ho); + setLength(werte,br*ho); if (ausgaben and __ausgabenMaske) <> 0 then gibAus('... fertig '+timetostr(now-Zeit),ausgaben); end; -function tLLWerte.zuPixelWerten(whoehe,wbreite,xpmi,xmi,tmi: longint; xz,yz: extended; pPWerte: pTExtendedArray; pPAnzahlen: pTLongintArray): boolean; +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; + xV,xB,tV,tB: longint; b: boolean; begin result:=false; @@ -1291,33 +1378,33 @@ begin pPAnzahlen^[i]:=0; end; b:=false; - for j:=0 to whoehe-1 do - for i:=0 to wbreite-1 do begin - xv:=min(params.xsteps-1,max(0,ceil((i+max(0,xpmi)-1/2)/xz+xmi))); - xb:=min(params.xsteps-1,max(0,ceil((i+max(0,xpmi)+1/2)/xz+xmi-1))); - tv:=min(params.tsiz-1,max(0,ceil((j-1/2)/yz+tmi))); - tb:=min(params.tsiz-1,max(0,ceil((j+1/2)/yz+tmi-1))); - if xv>xb then begin - if (i>0) or (xpmi>0) then - dec(xv) + for j:=0 to wHoehe-1 do + for i:=0 to wBreite-1 do begin + xV:=min(params.xSteps-1,max(0,ceil((i+max(0,xPMi)-1/2)/xZ+xMi))); + xB:=min(params.xSteps-1,max(0,ceil((i+max(0,xPMi)+1/2)/xZ+xMi-1))); + tV:=min(params.tSiz-1,max(0,ceil((j-1/2)/yZ+tMi))); + tB:=min(params.tSiz-1,max(0,ceil((j+1/2)/yZ+tMi-1))); + if xV>xB then begin + if (i>0) or (xPMi>0) then + dec(xV) else - inc(xb); + inc(xB); end; - if tv>tb then begin + if tV>tB then begin if j>0 then - dec(tv) + dec(tV) else - inc(tb); + inc(tB); end; - if (xv>xb) or (tv>tb) then begin - gibAus('Keine Inputwerte für Position '+inttostr(i)+':'+inttostr(j)+'!',1); + if (xV>xB) or (tV>tB) then begin + gibAus('Keine Inputwerte für Position '+intToStr(i)+':'+intToStr(j)+'!',1); exit; end; - pPanzahlen^[j*wbreite+i]:=(xb-xv+1)*(tb-tv+1); - for k:=xv to xb do - for l:=tv to tb do begin - b:=b or (werte[k+l*params.xsteps]<>0); - pPWerte^[j*wbreite+i]:=pPWerte^[j*wbreite+i]+min(params.maxW,max(params.minW,werte[k+l*params.xsteps])); + pPAnzahlen^[j*wBreite+i]:=(xB-xV+1)*(tB-tV+1); + for k:=xV to xB do + for l:=tV to tB do begin + b:=b or (werte[k+l*params.xSteps]<>0); + pPWerte^[j*wBreite+i]:=pPWerte^[j*wBreite+i]+min(params.maxW,max(params.minW,werte[k+l*params.xSteps])); end; end; if not b then @@ -1325,254 +1412,254 @@ begin result:=true; end; -function tLLWerte.findeSchwellwerte(xmi,xma,tmi,tma: longint; Schw: extended): tExtPointArray; +function tLLWerte.findeSchwellwerte(xMi,xMa,tMi,tMa: longint; Schw: extended): tExtPointArray; 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); + setLength(result,0); + gibAus('Schwellwerte finden ('+intToStr(xMi)+'-'+intToStr(xMa)+') '+floatToStr(Schw)+' ...',1); i:=0; - dx:=(params.xstop-params.xstart)/(params.xsteps-1); - x0:=params.xstart; - dy:=(params.tstop-params.tstart)/(params.tsiz-1); - y0:=params.tstart; - for j:=xmi to xma do begin - for k:=tmi to tma do begin + dx:=(params.xStop-params.xStart)/(params.xSteps-1); + x0:=params.xStart; + dy:=(params.tStop-params.tStart)/(params.tSiz-1); + y0:=params.tStart; + for j:=xMi to xMa do begin + for k:=tMi to tMa do begin vz:=0; 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 - byte(werte[j-l+(k-m)*params.xsteps]<=Schw); + 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 - setlength(result,length(result)+Speicherhappen); + setLength(result,length(result)+speicherHappen); result[i]['x']:=j*dx+x0; result[i]['y']:=k*dy+y0; inc(i); end; end; - if (xma-j) and $ff = 0 then - gibAus('x = '+inttostr(j)+' ('+inttostr(xmi)+'-'+inttostr(xma)+')',1); + if (xMa-j) and $ff = 0 then + gibAus('x = '+intToStr(j)+' ('+intToStr(xMi)+'-'+intToStr(xMa)+')',1); end; gibAus('... fertig!',1); - setlength(result,i); + setLength(result,i); end; -procedure tLLWerte.integriereSingle(qu: pTLLWerteSingle; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung); +procedure tLLWerte.integriereSingle(qu: pTLLWerteSingle; xMi,xMa,tMi,tMa,xOf,tOf: longint; richtung: tIntegrationsRichtung); var i,j: longint; int,faktor: extended; begin case richtung of irHorizontal: begin - faktor:=(qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1); - for i:=tmi to tma do begin + faktor:=(qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1); + for i:=tMi to tMa do begin int:=0; - for j:=0 to xmi-1 do - int:=int+qu^.werte[j + i*qu^.params.xsteps]; - for j:=xmi to xma do begin - int:=int+qu^.werte[j + i*qu^.params.xsteps]; - werte[j-xof + (i-tof)*params.xsteps]:=int*faktor; + for j:=0 to xMi-1 do + int:=int+qu^.werte[j + i*qu^.params.xSteps]; + for j:=xMi to xMa do begin + int:=int+qu^.werte[j + i*qu^.params.xSteps]; + werte[j-xOf + (i-tOf)*params.xSteps]:=int*faktor; end; end; end; irEinfall: begin faktor:= sqrt( - sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) + - sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1))); - gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1); - gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1); - for i:=tmi to tma do begin // von links eintretendes (inkl. Ecke links unten) + sqr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)) + + sqr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1))); + gibAus('dx = '+floatToStr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)),1); + gibAus('dt = '+floatToStr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)),1); + for i:=tMi to tMa do begin // von links eintretendes (inkl. Ecke links unten) int:=0; - for j:=1 to min(xmi,i) do - int:=int+qu^.werte[xmi-j + (i-j)*qu^.params.xsteps]; - for j:=0 to min(tma-i,xma-xmi) do begin - int:=int+qu^.werte[xmi+j + (i+j)*qu^.params.xsteps]; - werte[j+xmi-xof + (i+j-tof)*params.xsteps]:=int*faktor; + for j:=1 to min(xMi,i) do + int:=int+qu^.werte[xMi-j + (i-j)*qu^.params.xSteps]; + for j:=0 to min(tMa-i,xMa-xMi) do begin + int:=int+qu^.werte[xMi+j + (i+j)*qu^.params.xSteps]; + werte[j+xMi-xOf + (i+j-tOf)*params.xSteps]:=int*faktor; end; end; - for i:=xmi+1 to xma do begin // von unten eintretendes (exkl. Ecke links unten) + for i:=xMi+1 to xMa do begin // von unten eintretendes (exkl. Ecke links unten) int:=0; - for j:=1 to min(tmi,i) do - int:=int+qu^.werte[i-j + (tmi-j)*qu^.params.xsteps]; - for j:=0 to min(tma-tmi,xma-i) do begin - int:=int+qu^.werte[i+j + (tmi+j)*qu^.params.xsteps]; - werte[i+j-xof + (tmi+j-tof)*params.xsteps]:=int*faktor; + for j:=1 to min(tMi,i) do + int:=int+qu^.werte[i-j + (tMi-j)*qu^.params.xSteps]; + for j:=0 to min(tMa-tMi,xMa-i) do begin + int:=int+qu^.werte[i+j + (tMi+j)*qu^.params.xSteps]; + werte[i+j-xOf + (tMi+j-tOf)*params.xSteps]:=int*faktor; end; end; end; irAusfall: begin faktor:= sqrt( - sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) + - sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1))); - gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1); - gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1); - for i:=tmi to tma do begin // nach links austretendes (inkl. Ecke links oben) + sqr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)) + + sqr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1))); + gibAus('dx = '+floatToStr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)),1); + gibAus('dt = '+floatToStr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)),1); + for i:=tMi to tMa do begin // nach links austretendes (inkl. Ecke links oben) int:=0; - for j:=1 to min(xmi,qu^.params.tsiz-1-i) do - int:=int+qu^.werte[xmi-j + (i+j)*qu^.params.xsteps]; - for j:=0 to min(i-tmi,xma-xmi) do begin - int:=int+qu^.werte[xmi+j + (i-j)*qu^.params.xsteps]; - werte[j+xmi-xof + (i-j-tof)*params.xsteps]:=int*faktor; + for j:=1 to min(xMi,qu^.params.tSiz-1-i) do + int:=int+qu^.werte[xMi-j + (i+j)*qu^.params.xSteps]; + for j:=0 to min(i-tMi,xMa-xMi) do begin + int:=int+qu^.werte[xMi+j + (i-j)*qu^.params.xSteps]; + werte[j+xMi-xOf + (i-j-tOf)*params.xSteps]:=int*faktor; end; end; - for i:=xmi+1 to xma do begin // nach oben austretendes (exkl. Ecke links oben) + for i:=xMi+1 to xMa do begin // nach oben austretendes (exkl. Ecke links oben) int:=0; - for j:=1 to min(qu^.params.tsiz-1-tma,i) do - int:=int+qu^.werte[i-j + (tma+j)*qu^.params.xsteps]; - for j:=0 to min(tma-tmi,xma-i) do begin - int:=int+qu^.werte[i+j + (tma-j)*qu^.params.xsteps]; - werte[i+j-xof + (tma-j-tof)*params.xsteps]:=int*faktor; + for j:=1 to min(qu^.params.tSiz-1-tMa,i) do + int:=int+qu^.werte[i-j + (tMa+j)*qu^.params.xSteps]; + for j:=0 to min(tMa-tMi,xMa-i) do begin + int:=int+qu^.werte[i+j + (tMa-j)*qu^.params.xSteps]; + werte[i+j-xOf + (tMa-j-tOf)*params.xSteps]:=int*faktor; end; end; end; end{of case}; end; -procedure tLLWerte.integriereDouble(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung); +procedure tLLWerte.integriereDouble(qu: pTLLWerteDouble; xMi,xMa,tMi,tMa,xOf,tOf: longint; richtung: tIntegrationsRichtung); var i,j: longint; int,faktor: extended; begin case richtung of irHorizontal: begin - faktor:=(qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1); - for i:=tmi to tma do begin + faktor:=(qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1); + for i:=tMi to tMa do begin int:=0; - for j:=0 to xmi-1 do - int:=int+qu^.werte[j + i*qu^.params.xsteps]; - for j:=xmi to xma do begin - int:=int+qu^.werte[j + i*qu^.params.xsteps]; - werte[j-xof + (i-tof)*params.xsteps]:=int*faktor; + for j:=0 to xMi-1 do + int:=int+qu^.werte[j + i*qu^.params.xSteps]; + for j:=xMi to xMa do begin + int:=int+qu^.werte[j + i*qu^.params.xSteps]; + werte[j-xOf + (i-tOf)*params.xSteps]:=int*faktor; end; end; end; irEinfall: begin faktor:= sqrt( - sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) + - sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1))); - gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1); - gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1); - for i:=tmi to tma do begin // von links eintretendes (inkl. Ecke links unten) + sqr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)) + + sqr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1))); + gibAus('dx = '+floatToStr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)),1); + gibAus('dt = '+floatToStr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)),1); + for i:=tMi to tMa do begin // von links eintretendes (inkl. Ecke links unten) int:=0; - for j:=1 to min(xmi,i) do - int:=int+qu^.werte[xmi-j + (i-j)*qu^.params.xsteps]; - for j:=0 to min(tma-i,xma-xmi) do begin - int:=int+qu^.werte[xmi+j + (i+j)*qu^.params.xsteps]; - werte[j+xmi-xof + (i+j-tof)*params.xsteps]:=int*faktor; + for j:=1 to min(xMi,i) do + int:=int+qu^.werte[xMi-j + (i-j)*qu^.params.xSteps]; + for j:=0 to min(tMa-i,xMa-xMi) do begin + int:=int+qu^.werte[xMi+j + (i+j)*qu^.params.xSteps]; + werte[j+xMi-xOf + (i+j-tOf)*params.xSteps]:=int*faktor; end; end; - for i:=xmi+1 to xma do begin // von unten eintretendes (exkl. Ecke links unten) + for i:=xMi+1 to xMa do begin // von unten eintretendes (exkl. Ecke links unten) int:=0; - for j:=1 to min(tmi,i) do - int:=int+qu^.werte[i-j + (tmi-j)*qu^.params.xsteps]; - for j:=0 to min(tma-tmi,xma-i) do begin - int:=int+qu^.werte[i+j + (tmi+j)*qu^.params.xsteps]; - werte[i+j-xof + (tmi+j-tof)*params.xsteps]:=int*faktor; + for j:=1 to min(tMi,i) do + int:=int+qu^.werte[i-j + (tMi-j)*qu^.params.xSteps]; + for j:=0 to min(tMa-tMi,xMa-i) do begin + int:=int+qu^.werte[i+j + (tMi+j)*qu^.params.xSteps]; + werte[i+j-xOf + (tMi+j-tOf)*params.xSteps]:=int*faktor; end; end; end; irAusfall: begin faktor:= sqrt( - sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) + - sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1))); - gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1); - gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1); - for i:=tmi to tma do begin // nach links austretendes (inkl. Ecke links oben) + sqr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)) + + sqr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1))); + gibAus('dx = '+floatToStr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)),1); + gibAus('dt = '+floatToStr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)),1); + for i:=tMi to tMa do begin // nach links austretendes (inkl. Ecke links oben) int:=0; - for j:=1 to min(xmi,qu^.params.tsiz-1-i) do - int:=int+qu^.werte[xmi-j + (i+j)*qu^.params.xsteps]; - for j:=0 to min(i-tmi,xma-xmi) do begin - int:=int+qu^.werte[xmi+j + (i-j)*qu^.params.xsteps]; - werte[j+xmi-xof + (i-j-tof)*params.xsteps]:=int*faktor; + for j:=1 to min(xMi,qu^.params.tSiz-1-i) do + int:=int+qu^.werte[xMi-j + (i+j)*qu^.params.xSteps]; + for j:=0 to min(i-tMi,xMa-xMi) do begin + int:=int+qu^.werte[xMi+j + (i-j)*qu^.params.xSteps]; + werte[j+xMi-xOf + (i-j-tOf)*params.xSteps]:=int*faktor; end; end; - for i:=xmi+1 to xma do begin // nach oben austretendes (exkl. Ecke links oben) + for i:=xMi+1 to xMa do begin // nach oben austretendes (exkl. Ecke links oben) int:=0; - for j:=1 to min(qu^.params.tsiz-1-tma,i) do - int:=int+qu^.werte[i-j + (tma+j)*qu^.params.xsteps]; - for j:=0 to min(tma-tmi,xma-i) do begin - int:=int+qu^.werte[i+j + (tma-j)*qu^.params.xsteps]; - werte[i+j-xof + (tma-j-tof)*params.xsteps]:=int*faktor; + for j:=1 to min(qu^.params.tSiz-1-tMa,i) do + int:=int+qu^.werte[i-j + (tMa+j)*qu^.params.xSteps]; + for j:=0 to min(tMa-tMi,xMa-i) do begin + int:=int+qu^.werte[i+j + (tMa-j)*qu^.params.xSteps]; + werte[i+j-xOf + (tMa-j-tOf)*params.xSteps]:=int*faktor; end; end; end; end{of case}; end; -procedure tLLWerte.integriereExtended(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung); +procedure tLLWerte.integriereExtended(qu: pTLLWerteDouble; xMi,xMa,tMi,tMa,xOf,tOf: longint; richtung: tIntegrationsRichtung); var i,j: longint; int,faktor: extended; begin case richtung of irHorizontal: begin - faktor:=(qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1); - for i:=tmi to tma do begin + faktor:=(qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1); + for i:=tMi to tMa do begin int:=0; - for j:=0 to xmi-1 do - int:=int+qu^.werte[j + i*qu^.params.xsteps]; - for j:=xmi to xma do begin - int:=int+qu^.werte[j + i*qu^.params.xsteps]; - werte[j-xof + (i-tof)*params.xsteps]:=int*faktor; + for j:=0 to xMi-1 do + int:=int+qu^.werte[j + i*qu^.params.xSteps]; + for j:=xMi to xMa do begin + int:=int+qu^.werte[j + i*qu^.params.xSteps]; + werte[j-xOf + (i-tOf)*params.xSteps]:=int*faktor; end; end; end; irEinfall: begin faktor:= sqrt( - sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) + - sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1))); - gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1); - gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1); - for i:=tmi to tma do begin // von links eintretendes (inkl. Ecke links unten) + sqr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)) + + sqr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1))); + gibAus('dx = '+floatToStr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)),1); + gibAus('dt = '+floatToStr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)),1); + for i:=tMi to tMa do begin // von links eintretendes (inkl. Ecke links unten) int:=0; - for j:=1 to min(xmi,i) do - int:=int+qu^.werte[xmi-j + (i-j)*qu^.params.xsteps]; - for j:=0 to min(tma-i,xma-xmi) do begin - int:=int+qu^.werte[xmi+j + (i+j)*qu^.params.xsteps]; - werte[j+xmi-xof + (i+j-tof)*params.xsteps]:=int*faktor; + for j:=1 to min(xMi,i) do + int:=int+qu^.werte[xMi-j + (i-j)*qu^.params.xSteps]; + for j:=0 to min(tMa-i,xMa-xMi) do begin + int:=int+qu^.werte[xMi+j + (i+j)*qu^.params.xSteps]; + werte[j+xMi-xOf + (i+j-tOf)*params.xSteps]:=int*faktor; end; end; - for i:=xmi+1 to xma do begin // von unten eintretendes (exkl. Ecke links unten) + for i:=xMi+1 to xMa do begin // von unten eintretendes (exkl. Ecke links unten) int:=0; - for j:=1 to min(tmi,i) do - int:=int+qu^.werte[i-j + (tmi-j)*qu^.params.xsteps]; - for j:=0 to min(tma-tmi,xma-i) do begin - int:=int+qu^.werte[i+j + (tmi+j)*qu^.params.xsteps]; - werte[i+j-xof + (tmi+j-tof)*params.xsteps]:=int*faktor; + for j:=1 to min(tMi,i) do + int:=int+qu^.werte[i-j + (tMi-j)*qu^.params.xSteps]; + for j:=0 to min(tMa-tMi,xMa-i) do begin + int:=int+qu^.werte[i+j + (tMi+j)*qu^.params.xSteps]; + werte[i+j-xOf + (tMi+j-tOf)*params.xSteps]:=int*faktor; end; end; end; irAusfall: begin faktor:= sqrt( - sqr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)) + - sqr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1))); - gibAus('dx = '+floattostr((qu^.params.xstop-qu^.params.xstart)/(qu^.params.xsteps-1)),1); - gibAus('dt = '+floattostr((qu^.params.tstop-qu^.params.tstart)/(qu^.params.tsiz-1)),1); - for i:=tmi to tma do begin // nach links austretendes (inkl. Ecke links oben) + sqr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)) + + sqr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1))); + gibAus('dx = '+floatToStr((qu^.params.xStop-qu^.params.xStart)/(qu^.params.xSteps-1)),1); + gibAus('dt = '+floatToStr((qu^.params.tStop-qu^.params.tStart)/(qu^.params.tSiz-1)),1); + for i:=tMi to tMa do begin // nach links austretendes (inkl. Ecke links oben) int:=0; - for j:=1 to min(xmi,qu^.params.tsiz-1-i) do - int:=int+qu^.werte[xmi-j + (i+j)*qu^.params.xsteps]; - for j:=0 to min(i-tmi,xma-xmi) do begin - int:=int+qu^.werte[xmi+j + (i-j)*qu^.params.xsteps]; - werte[j+xmi-xof + (i-j-tof)*params.xsteps]:=int*faktor; + for j:=1 to min(xMi,qu^.params.tSiz-1-i) do + int:=int+qu^.werte[xMi-j + (i+j)*qu^.params.xSteps]; + for j:=0 to min(i-tMi,xMa-xMi) do begin + int:=int+qu^.werte[xMi+j + (i-j)*qu^.params.xSteps]; + werte[j+xMi-xOf + (i-j-tOf)*params.xSteps]:=int*faktor; end; end; - for i:=xmi+1 to xma do begin // nach oben austretendes (exkl. Ecke links oben) + for i:=xMi+1 to xMa do begin // nach oben austretendes (exkl. Ecke links oben) int:=0; - for j:=1 to min(qu^.params.tsiz-1-tma,i) do - int:=int+qu^.werte[i-j + (tma+j)*qu^.params.xsteps]; - for j:=0 to min(tma-tmi,xma-i) do begin - int:=int+qu^.werte[i+j + (tma-j)*qu^.params.xsteps]; - werte[i+j-xof + (tma-j-tof)*params.xsteps]:=int*faktor; + for j:=1 to min(qu^.params.tSiz-1-tMa,i) do + int:=int+qu^.werte[i-j + (tMa+j)*qu^.params.xSteps]; + for j:=0 to min(tMa-tMi,xMa-i) do begin + int:=int+qu^.werte[i+j + (tMa-j)*qu^.params.xSteps]; + werte[i+j-xOf + (tMa-j-tOf)*params.xSteps]:=int*faktor; end; end; end; @@ -1590,7 +1677,7 @@ var aParams,nParams: longint; // Index der alten und neuen Parameter parameter: array[0..1,boolean,0..3] of extended; // dim0 nummeriert Parametersätze - // dim1: Ableitung (true) oder Werte (false) + // dim1: Ableitung (true) oder werte (false) // dim2: position, 1/breite, amplitude, hintergrund fehlers: array[0..1] of extended; t0,t1,t2,t3, // Zwischenergebnisse @@ -1600,22 +1687,22 @@ var ignBr,ignVersch: boolean; // Breite/Verschiebung am Anschlag! begin if senkrecht then begin - qpSchritt:=params.xsteps; // Schritt in der Quelle parallel zur Fit-Richtung + qpSchritt:=params.xSteps; // Schritt in der Quelle parallel zur Fit-Richtung qsSchritt:=1; // Schritt in der Quelle senkrecht zur Fit-Richtung - zpSchritt:=params.xsteps; // Schritt im Ziel in positionsMitten-Richtung + zpSchritt:=params.xSteps; // Schritt im Ziel in positionsMitten-Richtung zdSchritt:=1; // Schritt im Ziel in Daten-Richtung (= senkrecht zur Fit-Richtung) - pMi:=params.tstart; - pMa:=params.tstop; - pLen:=params.tsiz; + pMi:=params.tStart; + pMa:=params.tStop; + pLen:=params.tSiz; end else begin - qsSchritt:=params.xsteps; + qsSchritt:=params.xSteps; qpSchritt:=1; zdSchritt:=length(positionsMitten); zpSchritt:=1; - pMi:=params.xstart; - pMa:=params.xstop; - pLen:=params.xsteps; + pMi:=params.xStart; + pMa:=params.xStop; + pLen:=params.xSteps; end; maxBreite:=1/maxBreite; @@ -1660,7 +1747,7 @@ begin nParams:=aParams; {$DEFINE gauszFitBerechneWerte} - {$I gauszFit.inc} // Werte + Gradienten berechnen + {$I gauszFit.inc} // werte + Gradienten berechnen {$UNDEF} schrittFaktor:=1; @@ -1696,7 +1783,7 @@ begin end; {$DEFINE gauszFitBerechneWerte} - {$I gauszFit.inc} // Werte + Gradienten berechnen + {$I gauszFit.inc} // werte + Gradienten berechnen {$UNDEF} if fehlers[aParams]>2*fehlers[nParams] then begin @@ -1718,20 +1805,20 @@ begin end; if schrittFaktor<1e-50 then - fehler('Sehr kleiner Schrittfaktor ('+floattostr(schrittFaktor)+') beim Fitten!'); + fehler('Sehr kleiner Schrittfaktor ('+floatToStr(schrittFaktor)+') beim Fitten!'); inc(zaehl); {$IFDEF gauszFitStatus} if (zaehl mod 10000)=0 then gibAus( - floattostr(fehlers[aParams])+' '+ - floattostr(qdrSumm)+' '+ - inttostr(byte((verbesserung<-10) or (fehlers[aParams]*100<qdrSumm)))+' '+ - inttostr(byte(ignVersch or (abs(schrittFaktor*parameter[aParams,true,0])<1)))+' '+ - inttostr(byte(ignBr or (abs(schrittFaktor*parameter[aParams,true,1]/parameter[aParams,false,1])<0.01)))+' '+ - inttostr(byte(abs(schrittFaktor*parameter[aParams,true,2]/parameter[aParams,false,2])<0.01))+' '+ - inttostr(byte(abs(schrittFaktor*parameter[aParams,true,3]/max(abs(parameter[aParams,false,3]),1e-10))<0.01))+' '+ - inttostr(verbesserung), + floatToStr(fehlers[aParams])+' '+ + floatToStr(qdrSumm)+' '+ + intToStr(byte((verbesserung<-10) or (fehlers[aParams]*100<qdrSumm)))+' '+ + intToStr(byte(ignVersch or (abs(schrittFaktor*parameter[aParams,true,0])<1)))+' '+ + intToStr(byte(ignBr or (abs(schrittFaktor*parameter[aParams,true,1]/parameter[aParams,false,1])<0.01)))+' '+ + intToStr(byte(abs(schrittFaktor*parameter[aParams,true,2]/parameter[aParams,false,2])<0.01))+' '+ + intToStr(byte(abs(schrittFaktor*parameter[aParams,true,3]/max(abs(parameter[aParams,false,3]),1e-10))<0.01))+' '+ + intToStr(verbesserung), 3); {$ENDIF} @@ -1762,49 +1849,72 @@ var i: int64; begin result:=0; - for i:=0 to params.xsteps-1 do + for i:=0 to params.xSteps-1 do result:=result + werte[i]; - for i:=1 to params.tsiz-2 do - result:=result + werte[i*params.xsteps]; - for i:=0 to params.xsteps-1 do - result:=result + werte[i + (params.tsiz-1)*params.xsteps]; - for i:=1 to params.tsiz-2 do - result:=result + werte[params.xsteps-1 + i*params.xsteps]; + for i:=1 to params.tSiz-2 do + result:=result + werte[i*params.xSteps]; + for i:=0 to params.xSteps-1 do + result:=result + werte[i + (params.tSiz-1)*params.xSteps]; + for i:=1 to params.tSiz-2 do + result:=result + werte[params.xSteps-1 + i*params.xSteps]; result:= - result/2/(params.xsteps+params.tsiz-2); + result/2/(params.xSteps+params.tSiz-2); end; -procedure tLLWerte.filtereHoheFrequenzen(betraege: tLLWerte; xFak,yFak: extended); +procedure tLLWerte.kantenFilter(betraege: tLLWerte; xFak,yFak: extended; filterTyp: tKantenFilterTyp); +var + dummy: tIntPoint; +begin + kantenFilter(betraege,xFak,yFak,filterTyp,false,dummy); +end; + +procedure tLLWerte.kantenFilter(betraege: tLLWerte; xFak,yFak: extended; filterTyp: tKantenFilterTyp; einseitig: boolean; out maxPos: tIntPoint); var maxima: tIntPointArray; - i,im,j,jm,mCnt: int64; + i,iM,j,jM,mCnt,di,dj: int64; wert,minWert,maxWert: extended; + istVollKomplex: byte; // 1=nein, 2=ja + schiebung: tIntPoint; begin - setlength(maxima,0); + istVollKomplex:=(params.tSiz div betraege.params.tSiz); + if (betraege.params.tSiz*istVollKomplex <> params.tSiz) or + (betraege.params.xSteps <> params.xSteps) or + (not (istVollKomplex in [1,2])) then + raise exception.create( + 'Die Dimension der Beträge ('+intToStr(betraege.params.xSteps)+' x '+intToStr(betraege.params.tSiz)+') stimmt nicht mit '+ + 'der Dimension der Werte ('+intToStr(params.xSteps)+' x '+intToStr(params.tSiz)+') -- oder deren ersten t-Hälfte -- überein ('+intToStr(istVollKomplex)+')!'); + if einseitig then begin + if istVollKomplex<>2 then + raise exception.create('Kann nur voll komplexe Werte einseitig per Kantenfilter filtern!'); + if filterTyp<>kfHochpass then + raise exception.create('Kann nur einen Hochpass als einseitigen Kantenfilter verwenden!'); + end; + + setLength(maxima,0); mCnt:=0; - for j:=0 to params.tsiz div 2 + 1 do begin - jm:=j - 1 + params.tsiz*byte(j=0); - for i:=0 to params.xsteps div 2 + 1 do begin - im:=i - 1 + params.xsteps*byte(i=0); - wert:=betraege.werte[i+j*params.xsteps]; + for j:=0 to betraege.params.tSiz div 2 + 1 do begin + jM:=j - 1 + betraege.params.tSiz*byte(j=0); + for i:=0 to betraege.params.xSteps div 2 + 1 do begin + iM:=i - 1 + betraege.params.xSteps*byte(i=0); + wert:=betraege.werte[i+j*betraege.params.xSteps]; if - (wert > betraege.werte[im+j*params.xsteps]) and - (wert > betraege.werte[i+jm*params.xsteps]) and - (wert > betraege.werte[(i+1)+j*params.xsteps]) and - (wert > betraege.werte[i+(j+1)*params.xsteps]) then begin + (wert > betraege.werte[iM+j*betraege.params.xSteps]) and + (wert > betraege.werte[i+jM*betraege.params.xSteps]) and + (wert > betraege.werte[(i+1)+j*betraege.params.xSteps]) and + (wert > betraege.werte[i+(j+1)*betraege.params.xSteps]) then begin if length(maxima)<=mCnt then - setlength(maxima,length(maxima)+1024); + setLength(maxima,length(maxima)+1024); maxima[mCnt]['x']:=i; maxima[mCnt]['y']:=j; inc(mCnt); end; end; end; - setlength(maxima,mCnt); - writeln(length(maxima),' (von ',params.xsteps*params.tsiz,')'); + setLength(maxima,mCnt); + writeln(length(maxima),' (von ',betraege.params.xSteps*betraege.params.tSiz,')'); betraege.sortiereMaxima(maxima); - mCnt:=1; + maxPos:=maxima[1]; maxWert:=0; for i:=1 to length(maxima)-1 do begin minWert:=0; @@ -1818,34 +1928,72 @@ begin end; if (i=1) or (minWert>maxWert) then begin maxWert:=minWert; - mCnt:=i; + maxPos:=maxima[i]; end; end; - im:=params.xsteps div 2 + 1; - jm:=params.tsiz div 2 + 1; - for j:=0 to jm do - for i:=0 to im do begin - wert:=(sqr(i)*xFak+sqr(j)*yFak)/(sqr(maxima[mCnt]['x'])*xFak+sqr(maxima[mCnt]['y'])*yFak); - if wert > 0.6 then - wert:=0 - else if wert > 0.4 then - wert:=(1+cos((wert-0.4)/0.2*pi))/2 - else - wert:=1; - - werte[i+j*params.xsteps]:= - werte[i+j*params.xsteps]*wert; - if (i>0) and (i<im) then - werte[params.xsteps-i+j*params.xsteps]:= - werte[params.xsteps-i+j*params.xsteps]*wert; - if (j>0) and (j<jm) then - werte[i+(params.tsiz-j)*params.xsteps]:= - werte[i+(params.tsiz-j)*params.xsteps]*wert; - if (i>0) and (i<im) and (j>0) and (j<jm) then - werte[params.xsteps-i+(params.tsiz-j)*params.xsteps]:= - werte[params.xsteps-i+(params.tsiz-j)*params.xsteps]*wert; + if istVollKomplex=1 then begin + iM:=params.xSteps div 2 + 1; + jM:=params.tSiz div 2 + 1; + for j:=0 to jM do + for i:=0 to iM do begin + wert:=(sqr(i)*xFak+sqr(j)*yFak)/(sqr(maxPos['x'])*xFak+sqr(maxPos['y'])*yFak); + if wert > 0.6 then + wert:=0 + else if wert > 0.4 then + wert:=(1+cos((wert-0.4)/0.2*pi))/2 + else + wert:=1; + if filterTyp=kfHochpass then + wert:=1-wert; + + werte[i+j*params.xSteps]:= + werte[i+j*params.xSteps]*wert; + if (i>0) and (i<iM) then + werte[params.xSteps-i+j*params.xSteps]:= + werte[params.xSteps-i+j*params.xSteps]*wert; + if (j>0) and (j<jM) then + werte[i+(params.tSiz-j)*params.xSteps]:= + werte[i+(params.tSiz-j)*params.xSteps]*wert; + if (i>0) and (i<iM) and (j>0) and (j<jM) then + werte[params.xSteps-i+(params.tSiz-j)*params.xSteps]:= + werte[params.xSteps-i+(params.tSiz-j)*params.xSteps]*wert; + end; + end + else begin + if einseitig then begin + schiebung:=maxPos; + filterTyp:=kfTiefpass; + end + else + schiebung:=intPoint(0,0); + iM:=params.xSteps; + jM:=params.tSiz div 2; + for j:=0 to jM-1 do begin + dj:=abs(j-schiebung['y']); + if jM-dj<dj then + dj:=jM-dj; + for i:=0 to iM-1 do begin + di:=abs(i-schiebung['x']); + if iM-di<di then + di:=iM-di; + wert:=(sqr(di)*xFak+sqr(dj)*yFak)/(sqr(maxPos['x'])*xFak+sqr(maxPos['y'])*yFak); + if wert > 0.6 then + wert:=0 + else if wert > 0.4 then + wert:=(1+cos((wert-0.4)/0.2*pi))/2 + else + wert:=1; + if filterTyp=kfHochpass then + wert:=1-wert; + + werte[i+j*params.xSteps]:= // Re + werte[i+j*params.xSteps]*wert; + werte[i+(jM+j)*params.xSteps]:= // Im + werte[i+(jM+j)*params.xSteps]*wert; + end; end; + end; end; procedure tLLWerte.fenstereWerte(xMi,xMa,tMi,tMa: int64; xFen,tFen: tFenster; hg: extended); @@ -1854,8 +2002,8 @@ var begin for j:=tMi to tMa do for i:=xMi to xMa do - werte[i+j*params.xsteps]:= - (werte[i+j*params.xsteps]-hg)*xFen.Werte[i]*tFen.Werte[j]; + werte[i+j*params.xSteps]:= + (werte[i+j*params.xSteps]-hg)*xFen.werte[i]*tFen.werte[j]; end; // tWavelet ******************************************************************** @@ -1883,46 +2031,46 @@ var tmpFFTAlgo: tFFTAlgorithmus; begin result:=false; - werte.params.xsteps:=2; - werte.params.transformationen.xstart:=0; - werte.params.transformationen.xstop:=1; - werte.params.transformationen.tstart:=0; - werte.params.transformationen.tstop:=1; + werte.params.xSteps:=2; + werte.params.transformationen.xStart:=0; + werte.params.transformationen.xStop:=1; + werte.params.transformationen.tStart:=0; + werte.params.transformationen.tStop:=1; if mitFFT then begin - if round(power(2,round(ln(werte.params.tsiz)/ln(2))))<>werte.params.tsiz then begin - gibAus('Waveletlänge muss eine Zweierpotenz sein bei Faltung mittels FFT, '+inttostr(werte.params.tsiz)+' ist das nicht!',3); + if round(power(2,round(ln(werte.params.tSiz)/ln(2))))<>werte.params.tSiz then begin + gibAus('Waveletlänge muss eine Zweierpotenz sein bei Faltung mittels FFT, '+intToStr(werte.params.tSiz)+' ist das nicht!',3); exit; end; - werte.holeRam(1); + werte.holeRAM(1); case typ of wtSin2: begin - hlen:=round(tfwhm); - for i:=0 to hlen do begin + hLen:=round(tfwhm); + for i:=0 to hLen do begin tmp:=sqr(cos(i*pi/2/tfwhm)); if i>0 then begin - werte.werte[(werte.params.tsiz-i)*2]:= tmp*cos(-i*freq*2*pi); - werte.werte[(werte.params.tsiz-i)*2+1]:=tmp*sin(-i*freq*2*pi); + werte.werte[(werte.params.tSiz-i)*2]:= tmp*cos(-i*freq*2*pi); + werte.werte[(werte.params.tSiz-i)*2+1]:=tmp*sin(-i*freq*2*pi); end; werte.werte[2*i]:= tmp*cos(i*freq*2*pi); werte.werte[2*i+1]:=tmp*sin(i*freq*2*pi); end; - for i:=hlen+1 to werte.params.tsiz-1-hlen do begin + for i:=hLen+1 to werte.params.tSiz-1-hLen do begin werte.werte[2*i]:=0; werte.werte[2*i+1]:=0; end; - gibAus(inttostr(werte.params.xsteps)+' '+inttostr(werte.params.tsiz)+' '+inttostr(length(werte.werte)),1); - tmpFFTAlgo:=createFFTAlgorithmus(2*hlen,doRes,doResIms); + gibAus(intToStr(werte.params.xSteps)+' '+intToStr(werte.params.tSiz)+' '+intToStr(length(werte.werte)),1); + tmpFFTAlgo:=createFFTAlgorithmus(2*hLen,doRes,doResIms); werte.fft(true,false,tmpFFTAlgo,nil,0,pvFehler); tmpFFTAlgo.free; end; wtFrequenzfenster: begin - hlen:=werte.params.tsiz div 2; - for i:=0 to hlen do begin - werte.werte[2*i]:=Byte(tfwhm*Abs(i/werte.params.tsiz-freq)<=1); // Re=1 <=> |f-f_Mitte| < Laenge/T_fwhm + hLen:=werte.params.tSiz div 2; + for i:=0 to hLen do begin + werte.werte[2*i]:=byte(tfwhm*abs(i/werte.params.tSiz-freq)<=1); // Re=1 <=> |f-f_Mitte| < Laenge/T_fwhm werte.werte[2*i+1]:=0; // Dummy-Wavelet end; - for i:=hlen+1 to 2*hlen-1 do begin + for i:=hLen+1 to 2*hLen-1 do begin werte.werte[2*i]:=0; // Ims = 0 werte.werte[2*i+1]:=0; // Dummy-Wavelet end; @@ -1934,13 +2082,13 @@ begin gibAus('Ich kann nur das ''Sin2''-Wavelet im Zeitbereich definieren!',3); exit; end; - hlen:=round(tfwhm); - werte.params.tsiz:=2*hlen+1; - setlength(werte.werte,werte.params.xsteps*werte.params.tsiz); - for i:=-hlen to hlen do begin + hLen:=round(tfwhm); + werte.params.tSiz:=2*hLen+1; + setLength(werte.werte,werte.params.xSteps*werte.params.tSiz); + for i:=-hLen to hLen do begin tmp:=sqr(cos(i*pi/2/tfwhm)); - werte.werte[2*(i+hlen)]:= tmp*cos(i*freq*2*pi); - werte.werte[2*(i+hlen)+1]:=tmp*sin(i*freq*2*pi); + werte.werte[2*(i+hLen)]:= tmp*cos(i*freq*2*pi); + werte.werte[2*(i+hLen)+1]:=tmp*sin(i*freq*2*pi); end; end; nur0:=true; @@ -1953,17 +2101,17 @@ end; constructor tWavelet.create; var - ps: tExtrainfos; + ps: tExtraInfos; begin inherited create; - ps:=tExtrainfos.create; + ps:=tExtraInfos.create; werte:=tLLWerteDouble.create(ps); pvFehler:=0; end; destructor tWavelet.destroy; begin - werte.params.Free; + werte.params.free; werte.free; inherited destroy; end; |