ich fühl mich unwohl, wenn die Arbeit nicht im git liegt

1 files changed, 521 insertions, 494 deletions

diff --git a/werteunit.pas b/werteunit.pas
index b1d46f5..c1b66ec 100644
--- a/werteunit.pas
+++ b/werteunit.pas
@@ -38,9 +38,9 @@ type
     procedure kopiereVonNach(original: pTLLWerteSingle; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint); overload;
     procedure kopiereVonNach(original: pTLLWerteDouble; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint); overload;
     procedure kopiereVonNach(original: pTLLWerteExtended; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint); overload;
-    procedure kopiereVerzerrt(original: pTLLWerteSingle; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen); overload;
-    procedure kopiereVerzerrt(original: pTLLWerteDouble; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen); overload;
-    procedure kopiereVerzerrt(original: pTLLWerteExtended; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen); overload;
+    procedure kopiereVerzerrt(original: pTLLWerteSingle; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint); overload;
+    procedure kopiereVerzerrt(original: pTLLWerteDouble; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint); overload;
+    procedure kopiereVerzerrt(original: pTLLWerteExtended; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint); overload;
     destructor destroy; override;
     function liesDateien(dateien: tGenerischeInputDateiInfoArray): boolean;
     function fft(senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; const fen: tFenster; out pvFehler: extended): boolean; overload;
@@ -85,9 +85,9 @@ uses systemunit;
 
 constructor tLLWerte.create(ps: tExtrainfos);
 begin
- inherited create;
- params:=ps;
- setlength(werte,0);
+  inherited create;
+  params:=ps;
+  setlength(werte,0);
 end;
 
 constructor tLLWerte.create(original: pTLLWerteSingle; ps: tExtrainfos; xmin,xmax: longint);
@@ -142,116 +142,123 @@ begin
 end;
 
 procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteSingle; xmin,xmax,tmin,tmax: longint);
-var i,j: longint;
+var
+  i,j: longint;
 begin
- inherited create;
- tmax:=min(tmax,original^.params.tsiz-1);
- tmin:=max(tmin,0);
- params.tsiz:=tmax+1-tmin;
- xmax:=min(xmax,original^.params.xsteps-1);
- xmin:=max(xmin,0);
- params.xsteps:=xmax+1-xmin;
- params.transformationen.kopiereVon(original^.params.transformationen);
- params.transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
- params.maxW:=0;
- params.minW:=0;
- params.np:=original^.params.np;
- params.beta:=original^.params.beta;
- params.refreshKnownValues;
- if not st then begin
-   holeRam(0);
-   for i:=xmin to xmax do
-     for j:=tmin to tmax do
-       werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
- end;
+  inherited create;
+  tmax:=min(tmax,original^.params.tsiz-1);
+  tmin:=max(tmin,0);
+  params.tsiz:=tmax+1-tmin;
+  xmax:=min(xmax,original^.params.xsteps-1);
+  xmin:=max(xmin,0);
+  params.xsteps:=xmax+1-xmin;
+  if not params.transformationen.hatNachfolger then
+    params.transformationen.free;
+  params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xmin,xmax,tmin,tmax);
+  params.maxW:=0;
+  params.minW:=0;
+  params.np:=original^.params.np;
+  params.beta:=original^.params.beta;
+  params.refreshKnownValues;
+  if not st then begin
+    holeRam(0);
+    for i:=xmin to xmax do
+      for j:=tmin to tmax do
+        werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
+  end;
 end;
 
 procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteDouble; xmin,xmax,tmin,tmax: longint);
-var i,j: longint;
+var
+  i,j: longint;
 begin
- inherited create;
- tmax:=min(tmax,original^.params.tsiz-1);
- tmin:=max(tmin,0);
- params.tsiz:=tmax+1-tmin;
- xmax:=min(xmax,original^.params.xsteps-1);
- xmin:=max(xmin,0);
- params.xsteps:=xmax+1-xmin;
- params.transformationen.kopiereVon(original^.params.transformationen);
- params.transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
- params.maxW:=0;
- params.minW:=0;
- params.np:=original^.params.np;
- params.beta:=original^.params.beta;
- params.refreshKnownValues;
- if not st then begin
-   holeRam(0);
-   for i:=xmin to xmax do
-     for j:=tmin to tmax do
-       werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
- end;
+  inherited create;
+  tmax:=min(tmax,original^.params.tsiz-1);
+  tmin:=max(tmin,0);
+  params.tsiz:=tmax+1-tmin;
+  xmax:=min(xmax,original^.params.xsteps-1);
+  xmin:=max(xmin,0);
+  params.xsteps:=xmax+1-xmin;
+  if not params.transformationen.hatNachfolger then
+    params.transformationen.free;
+  params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xmin,xmax,tmin,tmax);
+  params.maxW:=0;
+  params.minW:=0;
+  params.np:=original^.params.np;
+  params.beta:=original^.params.beta;
+  params.refreshKnownValues;
+  if not st then begin
+    holeRam(0);
+    for i:=xmin to xmax do
+      for j:=tmin to tmax do
+        werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
+  end;
 end;
 
 procedure tLLWerte.kopiereVon(st: boolean; original: pTLLWerteExtended; xmin,xmax,tmin,tmax: longint);
-var i,j: longint;
+var
+  i,j: longint;
 begin
- inherited create;
- tmax:=min(tmax,original^.params.tsiz-1);
- tmin:=max(tmin,0);
- params.tsiz:=tmax+1-tmin;
- xmax:=min(xmax,original^.params.xsteps-1);
- xmin:=max(xmin,0);
- params.xsteps:=xmax+1-xmin;
- params.transformationen.kopiereVon(original^.params.transformationen);
- params.transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
- params.maxW:=0;
- params.minW:=0;
- params.np:=original^.params.np;
- params.beta:=original^.params.beta;
- params.refreshKnownValues;
- if not st then begin
-   holeRam(0);
-   for i:=xmin to xmax do
-     for j:=tmin to tmax do
-       werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
- end;
+  inherited create;
+  tmax:=min(tmax,original^.params.tsiz-1);
+  tmin:=max(tmin,0);
+  params.tsiz:=tmax+1-tmin;
+  xmax:=min(xmax,original^.params.xsteps-1);
+  xmin:=max(xmin,0);
+  params.xsteps:=xmax+1-xmin;
+  if not params.transformationen.hatNachfolger then
+    params.transformationen.free;
+  params.transformationen:=tKoordinatenAusschnitt.create(original^.params.transformationen,xmin,xmax,tmin,tmax);
+  params.maxW:=0;
+  params.minW:=0;
+  params.np:=original^.params.np;
+  params.beta:=original^.params.beta;
+  params.refreshKnownValues;
+  if not st then begin
+    holeRam(0);
+    for i:=xmin to xmax do
+      for j:=tmin to tmax do
+        werte[i-xmin+(j-tmin)*params.xsteps]:=original^.werte[i+j*original^.params.xsteps];
+  end;
 end;
 
 procedure tLLWerte.kopiereVonNach(original: pTLLWerteSingle; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint);
 var
   i,j: longint;
 begin
- inherited create;
- for i:=qxmin to qxmax do
-   for j:=qtmin to qtmax do
-     werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
-       original^.werte[i+j*original^.params.xsteps];
+  inherited create;
+  for i:=qxmin to qxmax do
+    for j:=qtmin to qtmax do
+      werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
+        original^.werte[i+j*original^.params.xsteps];
 end;
 
 procedure tLLWerte.kopiereVonNach(original: pTLLWerteDouble; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint);
 var
   i,j: longint;
 begin
- inherited create;
- for i:=qxmin to qxmax do
-   for j:=qtmin to qtmax do
-     werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
-       original^.werte[i+j*original^.params.xsteps];
+  inherited create;
+  for i:=qxmin to qxmax do
+    for j:=qtmin to qtmax do
+      werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
+        original^.werte[i+j*original^.params.xsteps];
 end;
 
 procedure tLLWerte.kopiereVonNach(original: pTLLWerteExtended; qxmin,qxmax,qtmin,qtmax,zxmin,ztmin: longint);
 var
   i,j: longint;
 begin
- inherited create;
- for i:=qxmin to qxmax do
-   for j:=qtmin to qtmax do
-     werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
-       original^.werte[i+j*original^.params.xsteps];
+  inherited create;
+  for i:=qxmin to qxmax do
+    for j:=qtmin to qtmax do
+      werte[i-qxmin+zxmin + (j-qtmin+ztmin)*params.xsteps]:=
+        original^.werte[i+j*original^.params.xsteps];
 end;
 
-procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteSingle; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen);
-var i,j,k,l: longint;
-    tmp:     extended;
+procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteSingle; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint);
+var
+  i,j,k: longint;
+  tmp:   extended;
 begin
   for i:=tmin to tmax do
     for j:=xmin to xmax do
@@ -260,12 +267,12 @@ begin
     for j:=0 to 1 do
       for k:=0 to 1 do
         if (ZPs[i]['x']+j>=xmin) and (ZPs[i]['x']+j<=xmax) and
-           (ZPs[i]['y']+k>=tmin) and (ZPs[i]['y']+k<=tmax) then begin
+            (ZPs[i]['y']+k>=tmin) and (ZPs[i]['y']+k<=tmax) then begin
           tmp:=original^.werte[i];
-          if (vb.count>0) or (nb.count>0) then
+          if (va>0) or (na>0) then
             tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
-          for l:=0 to vb.count-1 do
-            tmp:=vb[l].transformiereWert(tmp);
+          if va>0 then
+            vb.transformiereWert(tmp,va-1);
           tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
           werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
             werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
@@ -274,351 +281,355 @@ begin
   for i:=tmin to tmax do
     for j:=xmin to xmax do begin
       tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
-      for k:=0 to nb.count-1 do
-        tmp:=nb[k].transformiereWert(tmp);
+      if na>0 then
+        tmp:=nb.transformiereWert(tmp,na-1);
       werte[j + i*params.xsteps]:=tmp;
     end;
 end;
 
-procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteDouble; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen);
-var i,j,k,l: longint;
-    tmp:     extended;
+procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteDouble; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint);
+var
+  i,j,k: longint;
+  tmp:   extended;
 begin
- for i:=tmin to tmax do
-   for j:=xmin to xmax do
-     werte[j+i*params.xsteps]:=0;
- for i:=0 to length(ZPs)-1 do
-   for j:=0 to 1 do
-     for k:=0 to 1 do
-       if (ZPs[i]['x']+j>=xmin) and (ZPs[i]['x']+j<=xmax) and
+  for i:=tmin to tmax do
+    for j:=xmin to xmax do
+      werte[j+i*params.xsteps]:=0;
+  for i:=0 to length(ZPs)-1 do
+    for j:=0 to 1 do
+      for k:=0 to 1 do
+        if (ZPs[i]['x']+j>=xmin) and (ZPs[i]['x']+j<=xmax) and
           (ZPs[i]['y']+k>=tmin) and (ZPs[i]['y']+k<=tmax) then begin
-         tmp:=original^.werte[i];
-         if (vb.count>0) or (nb.count>0) then
-           tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
-         for l:=0 to vb.count-1 do
-           tmp:=vb[l].transformiereWert(tmp);
-         tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
-         werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
-           werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
-           tmp;
-       end;
- for i:=tmin to tmax do
-   for j:=xmin to xmax do begin
-     tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
-     for k:=0 to nb.count-1 do
-       tmp:=nb[k].transformiereWert(tmp);
-     werte[j + i*params.xsteps]:=tmp;
-   end;
+          tmp:=original^.werte[i];
+          if (va>0) or (na>0) then
+            tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
+          if va>0 then
+            vb.transformiereWert(tmp,va-1);
+          tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
+          werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
+            werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
+            tmp;
+        end;
+  for i:=tmin to tmax do
+    for j:=xmin to xmax do begin
+      tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
+      if na>0 then
+        tmp:=nb.transformiereWert(tmp,na-1);
+      werte[j + i*params.xsteps]:=tmp;
+    end;
 end;
 
-procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteExtended; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformationen);
-var i,j,k,l: longint;
-    tmp:     extended;
+procedure tLLWerte.kopiereVerzerrt(original: pTLLWerteExtended; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; xmin,xmax,tmin,tmax: longint; vb,nb: tTransformation; va,na: longint);
+var
+  i,j,k: longint;
+  tmp:   extended;
 begin
- for i:=tmin to tmax do
-   for j:=xmin to xmax do
-     werte[j+i*params.xsteps]:=0;
- for i:=0 to length(ZPs)-1 do
-   for j:=0 to 1 do
-     for k:=0 to 1 do
-       if (ZPs[i]['x']+j>=xmin) and (ZPs[i]['x']+j<=xmax) and
+  for i:=tmin to tmax do
+    for j:=xmin to xmax do
+      werte[j+i*params.xsteps]:=0;
+  for i:=0 to length(ZPs)-1 do
+    for j:=0 to 1 do
+      for k:=0 to 1 do
+        if (ZPs[i]['x']+j>=xmin) and (ZPs[i]['x']+j<=xmax) and
           (ZPs[i]['y']+k>=tmin) and (ZPs[i]['y']+k<=tmax) then begin
-         tmp:=original^.werte[i];
-         if (vb.count>0) or (nb.count>0) then
-           tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
-         for l:=0 to vb.count-1 do
-           tmp:=vb[l].transformiereWert(tmp);
-         tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
-         werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
-           werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
-           tmp;
-       end;
- for i:=tmin to tmax do
-   for j:=xmin to xmax do begin
-     tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
-     for k:=0 to nb.count-1 do
-       tmp:=nb[k].transformiereWert(tmp);
-     werte[j + i*params.xsteps]:=tmp;
-   end;
+          tmp:=original^.werte[i];
+          if (va>0) or (na>0) then
+            tmp:=(tmp-original^.params.minW)/(original^.params.maxW-original^.params.minW);
+          if va>0 then
+            vb.transformiereWert(tmp,va-1);
+          tmp:=tmp * (ZGs[i]['x'] * (2*j-1) + 1-j) * (ZGs[i]['y'] * (2*k-1) + 1-k);
+          werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps]:=
+            werte[ZPs[i]['x']+j + (ZPs[i]['y']+k)*params.xsteps] +
+            tmp;
+        end;
+  for i:=tmin to tmax do
+    for j:=xmin to xmax do begin
+      tmp:=werte[j + i*params.xsteps] / ZAs[j + i*params.xsteps];
+      if na>0 then
+        tmp:=nb.transformiereWert(tmp,na-1);
+      werte[j + i*params.xsteps]:=tmp;
+    end;
 end;
 
 destructor tLLWerte.destroy;
 begin
- setlength(werte,0);
- inherited destroy;
+  setlength(werte,0);
+  inherited destroy;
 end;
 
 function tLLWerte.liesDateien(dateien: tGenerischeInputDateiInfoArray): boolean;
-var i,j,k,l,tmpi,etsiz,spAnz,br: longint;
-    f:                           file;
-    tmps:                        single;
-    tmpd:                        double;
-    tmpe,Zeit:                   extended;
-    sa:                          tSingleArray;
-    da:                          tDoubleArray;
-    ea:                          tExtendedArray;
-    ipp:                         tProcess;
-    buf:                         tByteArray;
-    etwasGelesen:                boolean;
+var
+  i,j,k,l,tmpi,etsiz,spAnz,br: longint;
+  f:                           file;
+  tmps:                        single;
+  tmpd:                        double;
+  tmpe,Zeit:                   extended;
+  sa:                          tSingleArray;
+  da:                          tDoubleArray;
+  ea:                          tExtendedArray;
+  ipp:                         tProcess;
+  buf:                         tByteArray;
+  etwasGelesen:                boolean;
 begin
- result:=false;
- gibAus('... Dateien einlesen ...',1);
- zeit:=now;
- tmpi:=0;
- tmps:=0;
- tmpd:=0;
- etsiz:=0;
- spAnz:=-1;
- for i:=0 to length(dateien)-1 do begin
-   gibAus(' '+dateien[i].Name,1);
-   etwasGelesen:=false;
-   if dateien[i] is tPipeInputDateiInfo then begin
-     if ((dateien[i] as tPipeInputDateiInfo).bytesPerSample<>4) or
+  result:=false;
+  gibAus('... Dateien einlesen ...',1);
+  zeit:=now;
+  tmpi:=0;
+  tmps:=0;
+  tmpd:=0;
+  etsiz:=0;
+  spAnz:=-1;
+  for i:=0 to length(dateien)-1 do begin
+    gibAus(' '+dateien[i].Name,1);
+    etwasGelesen:=false;
+    if dateien[i] is tPipeInputDateiInfo then begin
+      if ((dateien[i] as tPipeInputDateiInfo).bytesPerSample<>4) or
         ((dateien[i] as tPipeInputDateiInfo).Kodierung<>k32BitSignedInteger) then begin
-       gibAus('Ich kann nur vier Bytes mit einem mal als Integer interpretiert aus einer Pipe einlesen!',3);
-       exit;
-     end;
-     tmpe:=power(2,-31);
-     ipp:=tProcess.create(nil);
-     ipp.Options:=ipp.Options + [poUsePipes];
-     ipp.Executable:=(dateien[i] as tPipeInputDateiInfo).Executable;
-     ipp.Parameters.Text:=(dateien[i] as tPipeInputDateiInfo).ParametersText;
-     ipp.execute;
-     setlength(buf,0);
-     br:=0;
-     while ipp.running or (ipp.Output.NumBytesAvailable>0) do begin
-       if ipp.Output.NumBytesAvailable > 0 then begin
-         if br+ipp.Output.NumBytesAvailable>=length(buf) then
-           setlength(buf,br+ipp.Output.NumBytesAvailable+65536*1024);
-         tmpi:=ipp.Output.Read(buf[br],min(ipp.Output.NumBytesAvailable,length(buf)-br));
-         if ((br+tmpi) shr 24) > (br shr 24) then gibAus(inttostr(br+tmpi)+' von '+inttostr(dateien[i].tsiz*dateien[i].xsteps*4)+' Bytes bisher gelesen ('+floattostrtrunc((br+tmpi)/(dateien[i].tsiz*dateien[i].xsteps*4)*100,2,true)+'%).',1);
-         br:=br+tmpi;
-       end
-       else
-         sleep(10);
-     end;
-     ipp.free;
-     gibAus('insgesamt '+inttostr(br div 1024 div 1024)+' MB gelesen.',1);
-     setlength(buf,br);
-     if dateien[i].tsiz*dateien[i].xsteps*4>length(buf) then begin
-       gibAus('Ich habe '+inttostr(length(buf))+' Bytes aus der Pipe gelesen, anstelle von wenigstens '+inttostr(dateien[i].tsiz*dateien[i].xsteps*4)+', wie erwartet!',3);
-       setlength(buf,0);
-       exit;
-     end;
-     tmpi:=length(buf)-4*dateien[i].tsiz*dateien[i].xsteps;  // der Offset des ersten Daten-Wortes
-     for j:=dateien[i].tmin to dateien[i].tmax do
-       for k:=dateien[i].xmin to dateien[i].xmax do
-         werte[dateien[i].t0abs+ k-dateien[i].xmin + (j-dateien[i].tmin)*(dateien[i].xmax-dateien[i].xmin+1)]:=
-           int32((((((buf[tmpi+3+4*(k+j*dateien[i].xsteps)] shl 8) or
-                     buf[tmpi+2+4*(k+j*dateien[i].xsteps)]) shl 8) or
+        gibAus('Ich kann nur vier Bytes mit einem mal als Integer interpretiert aus einer Pipe einlesen!',3);
+        exit;
+      end;
+      tmpe:=power(2,-31);
+      ipp:=tProcess.create(nil);
+      ipp.Options:=ipp.Options + [poUsePipes];
+      ipp.Executable:=(dateien[i] as tPipeInputDateiInfo).Executable;
+      ipp.Parameters.Text:=(dateien[i] as tPipeInputDateiInfo).ParametersText;
+      ipp.execute;
+      setlength(buf,0);
+      br:=0;
+      while ipp.running or (ipp.Output.NumBytesAvailable>0) do begin
+        if ipp.Output.NumBytesAvailable > 0 then begin
+          if br+ipp.Output.NumBytesAvailable>=length(buf) then
+            setlength(buf,br+ipp.Output.NumBytesAvailable+65536*1024);
+          tmpi:=ipp.Output.Read(buf[br],min(ipp.Output.NumBytesAvailable,length(buf)-br));
+          if ((br+tmpi) shr 24) > (br shr 24) then gibAus(inttostr(br+tmpi)+' von '+inttostr(dateien[i].tsiz*dateien[i].xsteps*4)+' Bytes bisher gelesen ('+floattostrtrunc((br+tmpi)/(dateien[i].tsiz*dateien[i].xsteps*4)*100,2,true)+'%).',1);
+          br:=br+tmpi;
+        end
+        else
+          sleep(10);
+      end;
+      ipp.free;
+      gibAus('insgesamt '+inttostr(br div 1024 div 1024)+' MB gelesen.',1);
+      setlength(buf,br);
+      if dateien[i].tsiz*dateien[i].xsteps*4>length(buf) then begin
+        gibAus('Ich habe '+inttostr(length(buf))+' Bytes aus der Pipe gelesen, anstelle von wenigstens '+inttostr(dateien[i].tsiz*dateien[i].xsteps*4)+', wie erwartet!',3);
+        setlength(buf,0);
+        exit;
+      end;
+      tmpi:=length(buf)-4*dateien[i].tsiz*dateien[i].xsteps;  // der Offset des ersten Daten-Wortes
+      for j:=dateien[i].tmin to dateien[i].tmax do
+        for k:=dateien[i].xmin to dateien[i].xmax do
+          werte[dateien[i].t0abs+ k-dateien[i].xmin + (j-dateien[i].tmin)*(dateien[i].xmax-dateien[i].xmin+1)]:=
+            int32((((((buf[tmpi+3+4*(k+j*dateien[i].xsteps)] shl 8) or
+                      buf[tmpi+2+4*(k+j*dateien[i].xsteps)]) shl 8) or
                     buf[tmpi+1+4*(k+j*dateien[i].xsteps)]) shl 8) or
-                   buf[tmpi+4*(k+j*dateien[i].xsteps)]) * tmpe;
-     setlength(buf,0);
-     if etwasGelesen then begin
-       gibAus('Ich habe diese Runde schon Daten gelesen!',3);
-       exit;
-     end;
-     etwasGelesen:=true;
-   end;
-   if (dateien[i] is tSpaceTimeInputDateiInfo) or
+                    buf[tmpi+4*(k+j*dateien[i].xsteps)]) * tmpe;
+      setlength(buf,0);
+      if etwasGelesen then begin
+        gibAus('Ich habe diese Runde schon Daten gelesen!',3);
+        exit;
+      end;
+      etwasGelesen:=true;
+    end;
+    if (dateien[i] is tSpaceTimeInputDateiInfo) or
       (dateien[i] is tTraceInputDateiInfo) then begin
-     assign(f,dateien[i].Name);
-     reset(f,1);
-     blockread(f,tmpi,sizeof(integer));
-     dec(tmpi);
-     if tmpi-round(params.tstart/dateien[i].groeszenFaktor)<>i then begin
-       gibAus('Datei '''+dateien[i].Name+''' kommt nicht an '+inttostr(i)+'-ter Stelle, wie sie sollte, sondern an '+inttostr(tmpi-round(params.tstart/dateien[i].groeszenFaktor))+'-ter.',3);
-       writeln(tmpi);
-       close(f);
-       exit;
-     end;
-     if dateien[i] is tTraceInputDateiInfo then begin
-       blockread(f,tmpi,sizeof(integer));  // #Traces
-       spAnz:=tmpi;
-     end;
-     blockread(f,etsiz,sizeof(integer));
-     if dateien[i] is tSpaceTimeInputDateiInfo then begin
-       for j:=0 to etsiz-1 do begin
-         case Dateien[i].Genauigkeit of
-           gSingle: begin
-             blockread(f,tmps,sizeof(single)); // xstart
-             tmpe:=tmps;
-           end;
-           gDouble: begin
-             blockread(f,tmpd,sizeof(double)); // xstart
-             tmpe:=tmpd;
-           end;
-           gExtended:
-             blockread(f,tmpe,sizeof(extended)); // xstart
-         end{of Case};
-         tmpe:=tmpe*dateien[i].groeszenFaktor;
-         if j=0 then params.transformationen.xstart:=tmpe;
-         if tmpe<>params.transformationen.xstart then begin
-           gibAus('Falscher linker Rand in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(params.transformationen.xstart)+'!',3);
-           close(f);
-           exit;
-         end;
-         case Dateien[i].Genauigkeit of
-           gSingle: begin
-             blockread(f,tmps,sizeof(single)); // xstop
-             tmpe:=tmps;
-           end;
-           gDouble: begin
-             blockread(f,tmpd,sizeof(double)); // xstop
-             tmpe:=tmpd;
-           end;
-           gExtended:
-             blockread(f,tmpe,sizeof(extended)); // xstop
-         end{of Case};
-         tmpe:=tmpe*dateien[i].groeszenFaktor;
-         if j=0 then params.transformationen.xstop:=tmpe;
-         if tmpe<>params.transformationen.xstop then begin
-           gibAus('Falscher rechter Rand in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(params.transformationen.xstop)+'!',3);
-           close(f);
-           exit;
-         end;
-         blockread(f,tmpi,sizeof(integer)); // xsteps
-         if tmpi<>params.xsteps then begin
-           gibAus('Falsche Anzahl an x-Schritten in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+inttostr(tmpi)+' statt '+myfloattostr(params.xsteps)+'!',3);
-           close(f);
-           exit;
-         end;
-         if ((sizeof(wgen) = sizeof(single)) and (Dateien[i].Genauigkeit=gSingle)) or
+      assign(f,dateien[i].Name);
+      reset(f,1);
+      blockread(f,tmpi,sizeof(integer));
+      dec(tmpi);
+      if tmpi-round(params.tstart/dateien[i].groeszenFaktor)<>i then begin
+        gibAus('Datei '''+dateien[i].Name+''' kommt nicht an '+inttostr(i)+'-ter Stelle, wie sie sollte, sondern an '+inttostr(tmpi-round(params.tstart/dateien[i].groeszenFaktor))+'-ter.',3);
+        writeln(tmpi);
+        close(f);
+        exit;
+      end;
+      if dateien[i] is tTraceInputDateiInfo then begin
+        blockread(f,tmpi,sizeof(integer));  // #Traces
+        spAnz:=tmpi;
+      end;
+      blockread(f,etsiz,sizeof(integer));
+      if dateien[i] is tSpaceTimeInputDateiInfo then begin
+        for j:=0 to etsiz-1 do begin
+          case Dateien[i].Genauigkeit of
+            gSingle: begin
+              blockread(f,tmps,sizeof(single)); // xstart
+              tmpe:=tmps;
+            end;
+            gDouble: begin
+              blockread(f,tmpd,sizeof(double)); // xstart
+              tmpe:=tmpd;
+            end;
+            gExtended:
+              blockread(f,tmpe,sizeof(extended)); // xstart
+          end{of Case};
+          tmpe:=tmpe*dateien[i].groeszenFaktor;
+          if j=0 then params.transformationen.xstart:=tmpe;
+          if tmpe<>params.transformationen.xstart then begin
+            gibAus('Falscher linker Rand in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(params.transformationen.xstart)+'!',3);
+            close(f);
+            exit;
+          end;
+          case Dateien[i].Genauigkeit of
+            gSingle: begin
+              blockread(f,tmps,sizeof(single)); // xstop
+              tmpe:=tmps;
+            end;
+            gDouble: begin
+              blockread(f,tmpd,sizeof(double)); // xstop
+              tmpe:=tmpd;
+            end;
+            gExtended:
+              blockread(f,tmpe,sizeof(extended)); // xstop
+          end{of Case};
+          tmpe:=tmpe*dateien[i].groeszenFaktor;
+          if j=0 then params.transformationen.xstop:=tmpe;
+          if tmpe<>params.transformationen.xstop then begin
+            gibAus('Falscher rechter Rand in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(params.transformationen.xstop)+'!',3);
+            close(f);
+            exit;
+          end;
+          blockread(f,tmpi,sizeof(integer)); // xsteps
+          if tmpi<>params.xsteps then begin
+            gibAus('Falsche Anzahl an x-Schritten in '''+dateien[i].Name+''' im Schritt '+inttostr(j)+', nämlich '+inttostr(tmpi)+' statt '+myfloattostr(params.xsteps)+'!',3);
+            close(f);
+            exit;
+          end;
+          if ((sizeof(wgen) = sizeof(single)) and (Dateien[i].Genauigkeit=gSingle)) or
             ((sizeof(wgen) = sizeof(double)) and (Dateien[i].Genauigkeit=gDouble)) or
             ((sizeof(wgen) = sizeof(extended)) and (Dateien[i].Genauigkeit=gExtended)) then
-           blockread(f,werte[(j+Dateien[i].t0abs)*params.xsteps],params.xsteps*sizeof(wgen))
-         else begin
-           setlength(sa,params.xsteps);
-           blockread(f,sa[0],params.xsteps*sizeof(single));
-           for k:=0 to params.xsteps-1 do
-             werte[(j+Dateien[i].t0abs)*params.xsteps+k]:=sa[k];
-         end;
-         if power(dateien[i].gamma,3)/sqr(dateien[i].groeszenFaktor)<>1 then    // gamma^3 als Skalierungsfaktor für Dichten ?
-           for k:=0 to params.xsteps-1 do
-             werte[(j+Dateien[i].t0abs)*params.xsteps+k]:=werte[(j+Dateien[i].t0abs)*params.xsteps+k]*power(dateien[i].gamma,3)/sqr(dateien[i].groeszenFaktor);
-       end;
-       if etwasGelesen then begin
-         gibAus('Ich habe diese Runde schon Daten gelesen!',3);
-         exit;
-       end;
-       etwasGelesen:=true;
-     end;
-     if dateien[i] is tTraceInputDateiInfo then begin
-       case Dateien[i].Genauigkeit of
-         gSingle: begin
-           setlength(sa,etsiz);
-           setlength(da,0);
-           setlength(ea,0);
-         end;
-         gDouble: begin
-           setlength(sa,0);
-           setlength(da,etsiz);
-           setlength(ea,0);
-         end;
-         gExtended: begin
-           setlength(sa,0);
-           setlength(da,0);
-           setlength(ea,etsiz);
-         end;
-       end{of case};
-       for j:=0 to spAnz-1 do
-         case Dateien[i].Genauigkeit of
-           gSingle: begin
-             blockread(f,tmps,sizeof(single));   // x
-             if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
-               params.transformationen.xstop:=tmps;
-               params.transformationen.xstart:=params.xstop;
-             end;
-             for k:=0 to length(FeldgroeszenNamen)-1 do begin
-               blockread(f,sa[0],sizeof(single)*length(sa));
-               if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
+            blockread(f,werte[(j+Dateien[i].t0abs)*params.xsteps],params.xsteps*sizeof(wgen))
+          else begin
+            setlength(sa,params.xsteps);
+            blockread(f,sa[0],params.xsteps*sizeof(single));
+            for k:=0 to params.xsteps-1 do
+              werte[(j+Dateien[i].t0abs)*params.xsteps+k]:=sa[k];
+          end;
+          if power(dateien[i].gamma,3)/sqr(dateien[i].groeszenFaktor)<>1 then    // gamma^3 als Skalierungsfaktor für Dichten ?
+            for k:=0 to params.xsteps-1 do
+              werte[(j+Dateien[i].t0abs)*params.xsteps+k]:=werte[(j+Dateien[i].t0abs)*params.xsteps+k]*power(dateien[i].gamma,3)/sqr(dateien[i].groeszenFaktor);
+        end;
+        if etwasGelesen then begin
+          gibAus('Ich habe diese Runde schon Daten gelesen!',3);
+          exit;
+        end;
+        etwasGelesen:=true;
+      end;
+      if dateien[i] is tTraceInputDateiInfo then begin
+        case Dateien[i].Genauigkeit of
+          gSingle: begin
+            setlength(sa,etsiz);
+            setlength(da,0);
+            setlength(ea,0);
+          end;
+          gDouble: begin
+            setlength(sa,0);
+            setlength(da,etsiz);
+            setlength(ea,0);
+          end;
+          gExtended: begin
+            setlength(sa,0);
+            setlength(da,0);
+            setlength(ea,etsiz);
+          end;
+        end{of case};
+        for j:=0 to spAnz-1 do
+          case Dateien[i].Genauigkeit of
+            gSingle: begin
+              blockread(f,tmps,sizeof(single));   // x
+              if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
+                params.transformationen.xstop:=tmps;
+                params.transformationen.xstart:=params.xstop;
+              end;
+              for k:=0 to length(FeldgroeszenNamen)-1 do begin
+                blockread(f,sa[0],sizeof(single)*length(sa));
+                if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
                   (k=(Dateien[i] as tTraceInputDateiInfo).Feldnummer) then begin
-                 for l:=0 to length(sa)-1 do
-                   werte[l+Dateien[i].t0abs]:=sa[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
-                 if etwasGelesen then begin
-                   gibAus('Ich habe diese Runde schon Daten gelesen!',3);
-                   exit;
-                 end;
-                 etwasGelesen:=true;
-               end;
-             end;
-           end;
-           gDouble: begin
-             blockread(f,tmpd,sizeof(double)); // x
-             if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
-               params.transformationen.xstop:=tmpd;
-               params.transformationen.xstart:=params.xstop;
-             end;
-             for k:=0 to length(FeldgroeszenNamen)-1 do begin
-               blockread(f,da[0],sizeof(double)*length(da));
-               if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
+                  for l:=0 to length(sa)-1 do
+                    werte[l+Dateien[i].t0abs]:=sa[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
+                  if etwasGelesen then begin
+                    gibAus('Ich habe diese Runde schon Daten gelesen!',3);
+                    exit;
+                  end;
+                  etwasGelesen:=true;
+                end;
+              end;
+            end;
+            gDouble: begin
+              blockread(f,tmpd,sizeof(double)); // x
+              if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
+                params.transformationen.xstop:=tmpd;
+                params.transformationen.xstart:=params.xstop;
+              end;
+              for k:=0 to length(FeldgroeszenNamen)-1 do begin
+                blockread(f,da[0],sizeof(double)*length(da));
+                if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
                   (k=(Dateien[i] as tTraceInputDateiInfo).Feldnummer) then begin
-                 for l:=0 to length(da)-1 do
-                   werte[l+dateien[i].t0abs]:=da[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
-                 if etwasGelesen then begin
-                   gibAus('Ich habe diese Runde schon Daten gelesen!',3);
-                   exit;
-                 end;
-                 etwasGelesen:=true;
-               end;
-             end;
-           end;
-           gExtended: begin
-             blockread(f,tmpe,sizeof(extended)); // x
-             if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
-               params.transformationen.xstop:=tmpe;
-               params.transformationen.xstart:=params.xstop;
-             end;
-             for k:=0 to length(FeldgroeszenNamen)-1 do begin
-               blockread(f,ea[0],sizeof(extended)*length(ea));
-               if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
+                  for l:=0 to length(da)-1 do
+                    werte[l+dateien[i].t0abs]:=da[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
+                  if etwasGelesen then begin
+                    gibAus('Ich habe diese Runde schon Daten gelesen!',3);
+                    exit;
+                  end;
+                  etwasGelesen:=true;
+                end;
+              end;
+            end;
+            gExtended: begin
+              blockread(f,tmpe,sizeof(extended)); // x
+              if j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer then begin
+                params.transformationen.xstop:=tmpe;
+                params.transformationen.xstart:=params.xstop;
+              end;
+              for k:=0 to length(FeldgroeszenNamen)-1 do begin
+                blockread(f,ea[0],sizeof(extended)*length(ea));
+                if (j=(Dateien[i] as tTraceInputDateiInfo).Spurnummer) and
                   (k=(Dateien[i] as tTraceInputDateiInfo).Feldnummer) then begin
-                 for l:=0 to length(ea)-1 do
-                   werte[l+dateien[i].t0abs]:=ea[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
-                 if etwasGelesen then begin
-                   gibAus('Ich habe diese Runde schon Daten gelesen!',3);
-                   exit;
-                 end;
-                 etwasGelesen:=true;
-               end;
-             end;
-           end;
-         end{of Case};
-     end;
-     if not eof(f) then begin
-       gibAus('Zu viele Daten in '''+dateien[i].Name+'''!',3);
-       close(f);
-       exit;
-     end;
-     close(f);
-   end;
-   if dateien[i] is tPhaseSpaceInputDateiInfo then begin
-     if i<>0 then begin
-       gibAus('Ich kann Phasenraumdateien nicht kaskadieren!',3);
-       close(f);
-       exit;
-     end;
-     assign(f,dateien[i].Name);
-     reset(f,1);
-     seek(f,filepos(f)
-       + 4*wertGroesze(dateien[i].genauigkeit) // xstart,xstop,tstart,tstop
-       + 2*sizeof(longint));                   // xsteps,tsiz
-     blockread(f,werte[0],params.xsteps*params.tsiz*wertGroesze(dateien[i].genauigkeit));
-     close(f);
-     etwasGelesen:=true;
-   end;
-   if not etwasGelesen then begin
-     gibAus('Ich habe diese Runde keine Daten gelesen!',3);
-     exit;
-   end;
- end;
- params.refreshKnownValues;
- gibAus('... fertig '+timetostr(now-Zeit),1);
- result:=true;
+                  for l:=0 to length(ea)-1 do
+                    werte[l+dateien[i].t0abs]:=ea[l]*sqr(dateien[i].gamma)/sqr(dateien[i].groeszenFaktor);
+                  if etwasGelesen then begin
+                    gibAus('Ich habe diese Runde schon Daten gelesen!',3);
+                    exit;
+                  end;
+                  etwasGelesen:=true;
+                end;
+              end;
+            end;
+          end{of Case};
+      end;
+      if not eof(f) then begin
+        gibAus('Zu viele Daten in '''+dateien[i].Name+'''!',3);
+        close(f);
+        exit;
+      end;
+      close(f);
+    end;
+    if dateien[i] is tPhaseSpaceInputDateiInfo then begin
+      if i<>0 then begin
+        gibAus('Ich kann Phasenraumdateien nicht kaskadieren!',3);
+        close(f);
+        exit;
+      end;
+      assign(f,dateien[i].Name);
+      reset(f,1);
+      seek(f,filepos(f)
+        + 4*wertGroesze(dateien[i].genauigkeit) // xstart,xstop,tstart,tstop
+        + 2*sizeof(longint));                   // xsteps,tsiz
+      blockread(f,werte[0],params.xsteps*params.tsiz*wertGroesze(dateien[i].genauigkeit));
+      close(f);
+      etwasGelesen:=true;
+    end;
+    if not etwasGelesen then begin
+      gibAus('Ich habe diese Runde keine Daten gelesen!',3);
+      exit;
+    end;
+  end;
+  params.refreshKnownValues;
+  gibAus('... fertig '+timetostr(now-Zeit),1);
+  result:=true;
 end;
 
 procedure tLLWerte.gibMinMaxDichten(out wMi,wMa: extended; xmin,xmax,tmin,tmax: longint);
-var i,j:    longint;
+var
+  i,j:    longint;
 begin
   wMi:=werte[xmin+tmin*params.xsteps];
   wMa:=Werte[xmin+tmin*params.xsteps];
@@ -630,7 +641,8 @@ begin
 end;
 
 function tLLWerte.fft(senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; const fen: tFenster; out pvFehler: extended): boolean;
-var len: longint;
+var
+  len: longint;
 begin
   len:=1;
   if senkrecht then begin
@@ -646,12 +658,13 @@ begin
 end;
 
 function tLLWerte.fft(xmin,xmax,tmin,tmax: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; const fen: tFenster; out pvFehler: extended): boolean;
-var i,j,k,n,dist,absch,wnum,wstep,haL,
-      pmax,pmin,smax,smin:             longint;
-    in0,out0:                          boolean;
-    ims,wRe,wIm:                       tExtendedArray;
-    t1,t2,vorher,nachher,fenavg:       extended;
-    umsortierung:                      tLongintArray;
+var
+  i,j,k,n,dist,absch,wnum,wstep,haL,
+    pmax,pmin,smax,smin:             longint;
+  in0,out0:                          boolean;
+  ims,wRe,wIm:                       tExtendedArray;
+  t1,t2,vorher,nachher,fenavg:       extended;
+  umsortierung:                      tLongintArray;
 const faktoren: array[tFFTDatenordnung,0..2] of longint = // (doResIms,doResSmi,doRes,doBetr,doBetrQdr);
   ((2,1,1),(2,1,1),(1,1,1),(1,1,1),(1,1,1));
 begin
@@ -710,7 +723,7 @@ begin
         vorher:=vorher + werte[i+j*params.xsteps]*werte[i+j*params.xsteps]
           *faktoren[vor,
                   Byte(((not senkrecht) and (i=xmin)) or (senkrecht and (j=tmin)))
-               +2*Byte(((not senkrecht) and (2*i=xmin+xmax+1)) or (senkrecht and (2*j=tmin+tmax+1)))];
+                +2*Byte(((not senkrecht) and (2*i=xmin+xmax+1)) or (senkrecht and (2*j=tmin+tmax+1)))];
   end;
 
   setlength(umsortierung,pmax+1-pmin);
@@ -944,7 +957,7 @@ begin
         nachher:=nachher + werte[i+j*params.xsteps]*werte[i+j*params.xsteps]
           *faktoren[nach,
                   Byte(((not senkrecht) and (i=xmin)) or (senkrecht and (j=tmin)))
-               +2*Byte(((not senkrecht) and (2*i=xmin+xmax+1)) or (senkrecht and (2*j=tmin+tmax+1)))];
+                +2*Byte(((not senkrecht) and (2*i=xmin+xmax+1)) or (senkrecht and (2*j=tmin+tmax+1)))];
   end;
   if (nachher=0) and (vorher=0) then pvFehler:=0
   else pvFehler:=abs(nachher-vorher)/(nachher+vorher);
@@ -957,68 +970,71 @@ end;
 
 procedure tLLWerte.schreibeWert(var f: textfile; x,y: longint);
 begin
- schreibeWert(f,x,y,werte[x+y*params.xsteps]);
+  schreibeWert(f,x,y,werte[x+y*params.xsteps]);
 end;
 
 procedure tLLWerte.schreibeWert(var f: textfile; x,y,wert: extended);
-var xa,ta: extended;
+var
+  xa,ta: extended;
 begin
- if params.xstop=params.xstart then
-   xa:=params.xstop
- else
-   xa:=params.xstart+x/(params.xsteps-1)*(params.xstop-params.xstart);
- if params.tstop=params.tstart then
-   ta:=params.tstop
- else
-   ta:=params.tstart+y/(params.tsiz-1)*(params.tstop-params.tstart);
- writeln(f,floattostr(xa)+' '+floattostr(ta)+' '+floattostr(wert));
+  if params.xstop=params.xstart then
+    xa:=params.xstop
+  else
+    xa:=params.xstart+x/(params.xsteps-1)*(params.xstop-params.xstart);
+  if params.tstop=params.tstart then
+    ta:=params.tstop
+  else
+    ta:=params.tstart+y/(params.tsiz-1)*(params.tstop-params.tstart);
+  writeln(f,floattostr(xa)+' '+floattostr(ta)+' '+floattostr(wert));
 end;
 
 procedure tLLWerte.schreibeWertIntegriert(var f: textfile; i: longint; hor: boolean);
-var j:   longint;
-    tmp: extended;
+var
+  j:   longint;
+  tmp: extended;
 begin
- tmp:=0;
- if hor then begin
-   for j:=0 to params.xsteps-1 do
-     tmp:=tmp+werte[j+i*params.xsteps];
-   schreibeWert(f,(params.xsteps-1)/2,i,tmp);
- end
- else begin
-   for j:=0 to params.tsiz-1 do
-     tmp:=tmp+werte[i+j*params.xsteps];
-   schreibeWert(f,i,(params.tsiz-1)/2,tmp);
- end;
+  tmp:=0;
+  if hor then begin
+    for j:=0 to params.xsteps-1 do
+      tmp:=tmp+werte[j+i*params.xsteps];
+    schreibeWert(f,(params.xsteps-1)/2,i,tmp);
+  end
+  else begin
+    for j:=0 to params.tsiz-1 do
+      tmp:=tmp+werte[i+j*params.xsteps];
+    schreibeWert(f,i,(params.tsiz-1)/2,tmp);
+  end;
 end;
 
 procedure tLLWerte.erzeugeBinning(senkrecht,linien: boolean; x0,dx: extended; s: string);
-var f:     textfile;
-    i:     longint;
-    sum,x: extended;
+var
+  f:     textfile;
+  i:     longint;
+  sum,x: extended;
 begin
- assignfile(f,s);
- rewrite(f);
- sum:=0;
- while x0<0 do
-   x0:=x0+dx;
- for i:=0 to params.xsteps*params.tsiz-1 do
-   if i+1>x0 then begin
-     sum:=sum+werte[i]*(x0-i);
-     if senkrecht then
-       x:=x0/(params.tsiz-1)*(params.tstop-params.tstart)+params.tstart
-     else
-       x:=x0/(params.xsteps-1)*(params.xstop-params.xstart)+params.xstart;
-     writeln(f,floattostr(x)+' '+floattostr(sum/dx));
-     if linien then begin
-       writeln(f,floattostr(x)+' 0');
-       writeln(f)
-     end;
-     sum:=werte[i]*(i+1-x0);
-     x0:=x0+dx;
-   end
-   else
-     sum:=sum+werte[i];
- closefile(f);
+  assignfile(f,s);
+  rewrite(f);
+  sum:=0;
+  while x0<0 do
+    x0:=x0+dx;
+  for i:=0 to params.xsteps*params.tsiz-1 do
+    if i+1>x0 then begin
+      sum:=sum+werte[i]*(x0-i);
+      if senkrecht then
+        x:=x0/(params.tsiz-1)*(params.tstop-params.tstart)+params.tstart
+      else
+        x:=x0/(params.xsteps-1)*(params.xstop-params.xstart)+params.xstart;
+      writeln(f,floattostr(x)+' '+floattostr(sum/dx));
+      if linien then begin
+        writeln(f,floattostr(x)+' 0');
+        writeln(f)
+      end;
+      sum:=werte[i]*(i+1-x0);
+      x0:=x0+dx;
+    end
+    else
+      sum:=sum+werte[i];
+  closefile(f);
 end;
 
 procedure tLLWerte.spiegle;
@@ -1027,8 +1043,9 @@ begin
 end;
 
 procedure tLLWerte.spiegle(tmin,tmax: longint);
-var i,j:    longint;
-    tmp:    wgen;
+var
+  i,j:    longint;
+  tmp:    wgen;
 begin
   for i:=tmin to tmax do
     for j:=0 to params.xsteps div 2 -1 do begin
@@ -1039,7 +1056,8 @@ begin
 end;
 
 procedure tLLWerte.fft2dNachbearbeitungA(nb: tFFTDatenordnung);
-var i: longint;
+var
+  i: longint;
 begin
   case NB of
     doResIms,doResSmi: ;
@@ -1089,7 +1107,8 @@ begin
 end;
 
 procedure tLLWerte.fft2dNachbearbeitungB(xmin,xmax: longint; nb: tFFTDatenordnung);
-var i,j:    longint;
+var
+  i,j:    longint;
 begin // bearbeitet nur den Hauptteil (außer erster und mittlerer Zeile/Spalte) nach!
   case nb of
     doBetr: begin
@@ -1104,10 +1123,10 @@ begin // bearbeitet nur den Hauptteil (außer erster und mittlerer Zeile/Spalte)
         end;
     end;
     doBetrQdr: begin
-     for i:=xmin to xmax do
+      for i:=xmin to xmax do
         for j:=1 to params.tsiz div 2 -1 do begin
           werte[i+j*params.xsteps]:=
-             sqr(extended(werte[i+j*params.xsteps]-werte[params.xsteps-i+(params.tsiz-j)*params.xsteps]))  // Re^2
+              sqr(extended(werte[i+j*params.xsteps]-werte[params.xsteps-i+(params.tsiz-j)*params.xsteps]))  // Re^2
             +sqr(extended(werte[params.xsteps-i+j*params.xsteps]+werte[i+(params.tsiz-j)*params.xsteps])); // Im^2
           werte[params.xsteps-i+j*params.xsteps]:=werte[i+j*params.xsteps];
           werte[i+(params.tsiz-j)*params.xsteps]:=werte[i+j*params.xsteps];
@@ -1128,8 +1147,9 @@ begin
 end;
 
 procedure tLLWerte.holeRam(ausgaben: byte; gemaeszTXMinMax: boolean);
-var Zeit:  extended;
-    br,ho: longint;
+var
+  Zeit:  extended;
+  br,ho: longint;
 begin
   Zeit:=now;
   if gemaeszTXMinMax then begin
@@ -1149,9 +1169,10 @@ begin
 end;
 
 function tLLWerte.zuPixelWerten(whoehe,wbreite,xpmi,xmi,tmi: longint; xz,yz: extended; pPWerte: pTExtendedArray; pPAnzahlen: pTLongintArray): boolean;
-var i,j,k,l,
-      xv,xb,tv,tb: longint;
-    b:             boolean;
+var
+  i,j,k,l,
+    xv,xb,tv,tb: longint;
+  b:             boolean;
 begin
   result:=false;
   for i:=0 to length(pPWerte^)-1 do begin
@@ -1190,8 +1211,9 @@ begin
 end;
 
 function tLLWerte.findeSchwellwerte(xmi,xma,tmi,tma: longint; Schw: extended): tExtPointArray;
-var i,j,k,l,m,vz: longint;
-    dx,dy,x0,y0:  extended;
+var
+  i,j,k,l,m,vz: longint;
+  dx,dy,x0,y0:  extended;
 begin
   setlength(result,0);
   gibAus('Schwellwerte finden ('+inttostr(xmi)+'-'+inttostr(xma)+') '+floattostr(Schw)+' ...',1);
@@ -1206,7 +1228,7 @@ begin
       for l:=0 to 1 do
         for m:=0 to 1 do
           vz:=
-             vz or (byte(werte[j-l+(k-m)*params.xsteps]>=Schw) shl 1) or
+              vz or (byte(werte[j-l+(k-m)*params.xsteps]>=Schw) shl 1) or
                     byte(werte[j-l+(k-m)*params.xsteps]<=Schw);
       if vz=3 then begin
         if i>=length(result) then
@@ -1224,8 +1246,9 @@ begin
 end;
 
 procedure tLLWerte.integriereSingle(qu: pTLLWerteSingle; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
-var i,j:        longint;
-    int,faktor: extended;
+var
+  i,j:        longint;
+  int,faktor: extended;
 begin
   case richtung of
     irHorizontal: begin
@@ -1296,8 +1319,9 @@ begin
 end;
 
 procedure tLLWerte.integriereDouble(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
-var i,j:        longint;
-    int,faktor: extended;
+var
+  i,j:        longint;
+  int,faktor: extended;
 begin
   case richtung of
     irHorizontal: begin
@@ -1368,8 +1392,9 @@ begin
 end;
 
 procedure tLLWerte.integriereExtended(qu: pTLLWerteDouble; xmi,xma,tmi,tma,xof,tof: longint; richtung: tIntegrationsRichtung);
-var i,j:        longint;
-    int,faktor: extended;
+var
+  i,j:        longint;
+  int,faktor: extended;
 begin
   case richtung of
     irHorizontal: begin
@@ -1457,10 +1482,11 @@ begin
 end;
 
 function tWavelet.berechneWerte: boolean;
-var i:       longint;
-    tmp:     extended;
-    fenster: tFenster;
-    nur0:    boolean;
+var
+  i:       longint;
+  tmp:     extended;
+  fenster: tFenster;
+  nur0:    boolean;
 begin
   result:=false;
   werte.params.xsteps:=2;
@@ -1510,9 +1536,9 @@ begin
 (*        gibAus('dump:',3);
         for i:=0 to werte.tsiz-1 do
           if (i=0) or (i=werte.tsiz-1) or
-             (werte.werte[2*i+1]<>0) or
-             (werte.werte[2*i]<>werte.werte[2*(i-1)]) or
-             (werte.werte[2*i]<>werte.werte[2*(i+1)]) then
+              (werte.werte[2*i+1]<>0) or
+              (werte.werte[2*i]<>werte.werte[2*(i-1)]) or
+              (werte.werte[2*i]<>werte.werte[2*(i+1)]) then
           gibAus(inttostr(i)+' '+floattostr(werte.werte[2*i])+' '+floattostr(werte.werte[2*i+1]),3);
         gibAus('ende',3);
         exit; *)
@@ -1542,7 +1568,8 @@ begin
 end;
 
 constructor tWavelet.create;
-var ps: tExtrainfos;
+var
+  ps: tExtrainfos;
 begin
   inherited create;
   ps:=tExtrainfos.create;