wieder lauffähig

1 files changed, 397 insertions, 327 deletions

diff --git a/epostunit.pas b/epostunit.pas
index 13640b3..cd66982 100644
--- a/epostunit.pas
+++ b/epostunit.pas
@@ -75,7 +75,7 @@ type
     function findeAlleDateien(nam: string; var dat: tGenerischeInputDateiInfoArray; Vorlage: tGenerischeInputDateiInfo): boolean;
     function ermittleExterneInputParameter(var f: tInputfile; out dateien: tGenerischeInputDateiInfoArray): boolean;
     function ermittleInterneInputParameter(var dateien: tGenerischeInputDateiInfoArray): boolean;
-    procedure initVerzerrung(quelle: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,mt: longint; oberst: boolean; epsilon: extended; verzerrung: tVerzerrung; ZPs: tPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; Warn: tWarnstufe);
+    procedure initVerzerrung(quelle: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,mt: longint; oberst: boolean; epsilon: extended; verzerrung: tTransformationen; ZPs: tPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; Warn: tWarnstufe);
     function rXsteps: longint;
     procedure wXsteps(xs: longint);
     function rTsiz: longint;
@@ -100,6 +100,10 @@ type
     function xscale: extended;
     function tscale: extended;
     function dichtenParameterErkannt(st: boolean; s: string; threads,xmin,xmax,tmin,tmax: longint): boolean;
+    function kont2disk(dir: char; x: extended): longint;
+    function kont2diskFak(dir: char; x: extended): extended;
+    function disk2kont(dir: char; x: longint): extended;
+    function disk2kontFak(dir: char; x: longint): extended;
   public
     eWerte:                                      tLLWerteDouble;
     sWerte:                                      tLLWerteSingle;
@@ -107,8 +111,7 @@ type
     bezeichner:                                  string;
     Konturen:                                    pTKonturenArray;
     wertes:                                      pTWerteArray;
-    Achsenskala:                                 tAchsenskala;
-    Werteskala:                                  tWerteskala;
+    Transformationen:                            tTransformationen;
     constructor create(Kont: pTKonturenArray; wert: pTWerteArray); overload;
     constructor create(original: tWerte; xmin,xmax: longint); overload;
     destructor destroy; override;
@@ -141,10 +144,10 @@ type
     procedure beendeLeseThreadWennFertig;
     property _xsteps: longint read rXsteps write wXsteps;
     property _tsiz: longint read rTsiz write wTsiz;
-    property _xstart: extended read rXstart write wXstart;
-    property _xstop: extended read rXstop write wXstop;
-    property _tstart: extended read rTstart write wTstart;
-    property _tstop: extended read rTstop write wTstop;
+//    property _xstart: extended read rXstart write wXstart;
+//    property _xstop: extended read rXstop write wXstop;
+//    property _tstart: extended read rTstart write wTstart;
+//    property _tstop: extended read rTstop write wTstop;
     property _np: extended read rNp write wNp;
     property _beta: extended read rBeta write wBeta;
     property _minw: extended read rMinw write wMinw;
@@ -161,7 +164,14 @@ type
     linear: boolean;
   end;
   tLogThread = class(tThread)
-    fertig: boolean;
+  private
+    _fertig:         boolean;
+    raisedException: exception;
+    function rFertig: boolean;
+  public
+    property fertig: boolean
+      read rFertig
+      write _fertig;
     constructor create;
     destructor destroy; override;
     procedure execute; override;
@@ -172,6 +182,7 @@ type
     xMi,xMa,tMi,tMa,tOf,xOf: longint;
     pW:                      tWerte;
     constructor create(lk: pTLiKo; pWerte: tWerte; xMin,xMax,tMin,tMax,xOff,tOff: longint);
+    destructor destroy; override;
     procedure stExecute; override;
   end;
   tQuotientThread = class(tLogThread)
@@ -179,6 +190,7 @@ type
     xMi,xMa,tMi,tMa,tOf,xOf: longint;
     dend,sor,quot:           tWerte;
     constructor create(dividend, divisor, quotient: tWerte; epsilon: extended; xMin,xMax,tMin,tMax,xOff,tOff: longint);
+    destructor destroy; override;
     procedure stExecute; override;
   end;
   tBilderthread = class(tLogThread)
@@ -187,14 +199,14 @@ type
     w:                                  tWerte;
     xmi,xma,tmi,tma,xpmi,xpma:          Longint;
     xz,yz:                              extended;
-    nb:                                 tBearbeitungen;
+    nb:                                 tTransformationen;
     farben:                             trgbArray;
     werte:                              tExtendedArray;
     anzahlen:                           tLongintArray;
     pal:                                tRGBArray;
     rahmen:                             boolean;
     beschr:                             pTBeschriftungen;
-    constructor create(i,maxthreads,ibreite,ihoehe,lo,oo,ro,uo: longint; const we: tWerte; xmin,xmax,tmin,tmax: Longint; xzoom,yzoom: extended; Nachbearbeitung: tBearbeitungen; palette: pTPalette; beschri: pTBeschriftungen; rm: boolean);
+    constructor create(i,maxthreads,ibreite,ihoehe,lo,oo,ro,uo: longint; const we: tWerte; xmin,xmax,tmin,tmax: Longint; xzoom,yzoom: extended; Nachbearbeitung: tTransformationen; palette: pTPalette; beschri: pTBeschriftungen; rm: boolean);
     destructor destroy; override;
     procedure stExecute; override;
   end;
@@ -203,12 +215,14 @@ type
     xmin,xmax,tmin,tmax: longint;
     w:                   tWerte;
     constructor create(xmi,xma,tmi,tma: longint; const werte: tWerte);
+    destructor destroy; override;
     procedure stExecute; override;
   end;
   tSpiegelThread = class(tLogThread)
     tmin,tmax: longint;
     pW:        tWerte;
     constructor create(tmi,tma: longint; pWerte: tWerte);
+    destructor destroy; override;
     procedure stExecute; override;
   end;
   tFFT2dNBThread = class(tLogThread)
@@ -216,6 +230,7 @@ type
     pW:        tWerte;
     nb:        tFFTDatenordnung;
     constructor create(xmi,xma: longint; pWerte: tWerte; endordnung: tFFTDatenordnung);
+    destructor destroy; override;
     procedure stExecute; override;
   end;
   tFFTThread = class(tLogThread)
@@ -226,6 +241,7 @@ type
     pW:                    tWerte;
     pvFehler:              extended;
     constructor create(werte: tWerte; xMin,xMax,tMin,tMax: longint; senkrecht,invers: boolean; const vor,nach: tFFTDatenordnung; const fenster: tFenster);
+    destructor destroy; override;
     procedure stExecute; override;
   end;
   tKorrelThread = class(tLogThread)
@@ -234,6 +250,7 @@ type
     qu,zi:                   tWerte;
     pvFehler:                extended;
     constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,xOff,tOff: longint; wavelet: tWavelet);
+    destructor destroy; override;
     procedure stExecute; override;
   end;
   tKonturAusWertenThread = class(tLogThread)
@@ -250,6 +267,7 @@ type
     xmi,xma,tmi,tma,xof,tof: longint;
     rtg:                     tIntegrationsRichtung;
     constructor create(quelle, ziel: tWerte; xmin, xmax, tmin, tmax, xoff, toff: longint; richtung: tIntegrationsRichtung);
+    destructor destroy; override;
     procedure stExecute; override;
   end;
   tSortiereNachYThread = class(tLogThread)
@@ -257,6 +275,7 @@ type
     vo,bi,mt:      longint;
     erfolg:        boolean;
     constructor create(K: tKontur; threads,von,bis: longint);
+    destructor destroy; override;
     procedure stExecute; override;
   end;
   tBefehlThread = class(tLogThread)
@@ -280,11 +299,11 @@ type
     ZAs:                      tExtendedArray;
     xMi,xMa,tMi,tMa,x0,t0,mt: longint;        // bzgl. Ziel
     eps:                      extended;
-    verz:                     tVerzerrung;
+    verz:                     tTransformationen;
     Warnstufe:                tWarnstufe;
-    constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tVerzerrung; zielpositionen: tPointArray; zielgewichte: tExtPointArray; Warn: tWarnstufe);
-    procedure stExecute; override;
+    constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tTransformationen; zielpositionen: tPointArray; zielgewichte: tExtPointArray; Warn: tWarnstufe);
     destructor destroy; override;
+    procedure stExecute; override;
   end;
   tVerzerrThread = class(tLogThread)
     qu,zi:           tWerte;
@@ -292,8 +311,9 @@ type
     ZGs:             tExtPointArray;
     ZAs:             tExtendedArray;
     xMi,xMa,tMi,tMa: longint;        // bzgl. Ziel
-    vb,nb:           tBearbeitungen;
-    constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tBearbeitungen);
+    vb,nb:           tTransformationen;
+    constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tTransformationen);
+    destructor destroy; override;
     procedure stExecute; override;
   end;
 
@@ -301,7 +321,7 @@ function neuePalette(var f: tInputfile): boolean;
 function initBmpHeader(w,h: longint): tBmpHeader;
 procedure schreibeBmpHeader(var f: file; w,h: longint);
 function findePalette(out Palette: pTPalette; name: string): boolean;
-function erzeugeLegende(st: boolean; var f: tInputfile; datei: string; Qu: tWerte; minDichte,maxDichte: extended; nb: tBearbeitungen; pal: pTPalette): boolean;
+function erzeugeLegende(st: boolean; var f: tInputfile; datei: string; Qu: tWerte; minDichte,maxDichte: extended; nb: tTransformationen; pal: pTPalette): boolean;
 function strToFftDo(out fftDo: tFFTDatenordnung; s: string): boolean;
 function findeWerte(s: String; pws: pTWerteArray; Kont: pTKonturenArray; darfErstellen: boolean): integer;
 function findeKontur(s: String; pks: pTKonturenArray; darfErstellen: boolean): integer;
@@ -330,8 +350,7 @@ begin
  eWerte:=tLLWerteDouble.create(ps);
  Konturen:=Kont;
  wertes:=wert;
- Achsenskala:=tAchsenskala.create;
- Werteskala:=tWerteskala.create;
+ Transformationen:=tTransformationen.create;
  bezeichner:='';
 end;
 
@@ -361,8 +380,7 @@ begin
  end{of case};
  if original.bezeichner='' then bezeichner:=''
  else bezeichner:=original.bezeichner+'''';
- Achsenskala:=tAchsenskala.create(original.Achsenskala);
- Werteskala:=tWerteskala.create(original.Werteskala);
+ Transformationen:=tTransformationen.create(original.Transformationen);
  wertes:=original.wertes;
 end;
 
@@ -377,8 +395,7 @@ begin
  freemem(sWerte.params,sizeof(tExtrainfos));
  eWerte.free;
  sWerte.free;
- Achsenskala.free;
- Werteskala.free;
+ Transformationen.free;
  inherited destroy;
 end;
 
@@ -404,8 +421,7 @@ var pSi: pTLLWerteSingle;
     pEx: pTLLWerteDouble;
 begin
  original.warteAufBeendigungDesLeseThreads;
- Achsenskala.kopiereVon(original.Achsenskala);
- Werteskala.kopiereVon(original.Werteskala);
+ Transformationen.kopiereVon(original.Transformationen);
  Genauigkeit:=original.Genauigkeit;
  case Genauigkeit of
    gSingle:   begin
@@ -555,7 +571,7 @@ end;
 
 procedure tWerte.wMinw(miw: extended);
 begin
- werteskala.wmin:=miw;
+ Transformationen.wmin:=miw;
  case genauigkeit of
    gSingle:   sWerte.params^.minw:=miw;
    gExtended: eWerte.params^.minw:=miw;
@@ -572,7 +588,7 @@ end;
 
 procedure tWerte.wMaxw(maw: extended);
 begin
- werteskala.wmax:=maw;
+ Transformationen.wmax:=maw;
  case genauigkeit of
    gSingle:   sWerte.params^.maxw:=maw;
    gExtended: eWerte.params^.maxw:=maw;
@@ -1011,9 +1027,9 @@ begin
          gExtended: blockread(f,tmpe,sizeof(extended));
        end{of case};
        tmpe:=tmpe*dateien[i].groeszenFaktor;
-       if i=0 then _xstart:=tmpe;
-       if tmpe<>_xstart then begin
-         gibAus('Falscher linker Rand in '''+dateien[i].Name+''', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(_xstart)+'.',3);
+       if i=0 then Transformationen.xstart:=tmpe;
+       if tmpe<>Transformationen.xstart then begin
+         gibAus('Falscher linker Rand in '''+dateien[i].Name+''', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(Transformationen.xstart)+'.',3);
          close(f);
          exit;
        end;
@@ -1025,9 +1041,9 @@ begin
          gExtended: blockread(f,tmpe,sizeof(extended));
        end{of case};
        tmpe:=tmpe*dateien[i].groeszenFaktor;
-       if i=0 then _xstop:=tmpe;
-       if tmpe<>_xstop then begin
-         gibAus('Falscher rechter Rand in '''+dateien[i].Name+''', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(_xstop)+'.',3);
+       if i=0 then Transformationen.xstop:=tmpe;
+       if tmpe<>Transformationen.xstop then begin
+         gibAus('Falscher rechter Rand in '''+dateien[i].Name+''', nämlich '+myfloattostr(tmpe)+' statt '+myfloattostr(Transformationen.xstop)+'.',3);
          close(f);
          exit;
        end;
@@ -1058,19 +1074,19 @@ begin
    end;
  end;
 
- _tstart:=Positionen[0]*dateien[0].groeszenFaktor;
- _tstop:=(Positionen[0]+1)*dateien[0].groeszenFaktor;
+ Transformationen.tstart:=Positionen[0]*dateien[0].groeszenFaktor;
+ Transformationen.tstop:=(Positionen[0]+1)*dateien[0].groeszenFaktor;
  for i:=1 to length(Positionen)-1 do begin
-   _tstart:=min(_tstart,Positionen[i]*dateien[i].groeszenFaktor);
-   _tstop:=max(_tstop,(Positionen[i]+1)*dateien[i].groeszenFaktor);
+   Transformationen.tstart:=min(Transformationen.tstart,Positionen[i]*dateien[i].groeszenFaktor);
+   Transformationen.tstop:=max(Transformationen.tstop,(Positionen[i]+1)*dateien[i].groeszenFaktor);
  end;
- if 0<>round(_tstart+length(dateien)*dateien[0].groeszenFaktor-_tstop) then begin
-   gibAus('Die Dateien decken nicht den kompletten Zeitbereich von '+inttostr(round(_tstart))+'T bis '+inttostr(round(_tstop))+'T ab!',3);
+ if 0<>round(Transformationen.tstart+length(dateien)*dateien[0].groeszenFaktor-Transformationen.tstop) then begin
+   gibAus('Die Dateien decken nicht den kompletten Zeitbereich von '+inttostr(round(Transformationen.tstart))+'T bis '+inttostr(round(Transformationen.tstop))+'T ab!',3);
    exit;
  end;
  setlength(sortiert,length(dateien));
  for i:=0 to length(Positionen)-1 do
-   sortiert[Positionen[i]-round(_tstart/dateien[i].groeszenFaktor)]:=dateien[i];
+   sortiert[Positionen[i]-round(Transformationen.tstart/dateien[i].groeszenFaktor)]:=dateien[i];
  for i:=0 to length(Positionen)-1 do begin
    dateien[i]:=sortiert[i];
    if i=0 then begin
@@ -1093,7 +1109,7 @@ begin
  result:=true;
 end;
 
-procedure tWerte.initVerzerrung(quelle: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,mt: longint; oberst: boolean; epsilon: extended; verzerrung: tVerzerrung; ZPs: tPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; Warn: tWarnstufe);
+procedure tWerte.initVerzerrung(quelle: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,mt: longint; oberst: boolean; epsilon: extended; verzerrung: tTransformationen; ZPs: tPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; Warn: tWarnstufe);
 var i,j:  longint;
     vits: array[boolean] of tVerzerrInitThread;
     b:    boolean;
@@ -1102,9 +1118,9 @@ begin
    for i:=0 to _tsiz-1 do
      for j:=0 to _xsteps-1 do
        ZAs[j + i*_xsteps]:=0;
-   for i:=tMin to tMax do begin
+   for i:=tMin to tMax do
      for j:=xMin to xMax do begin
-       ZGs[j+i*quelle._xsteps]:=verzerrung.ziel(j,i);
+       ZGs[j+i*quelle._xsteps]:=verzerrung.transformiereKoordinaten(j,i);
        ZPs[j+i*quelle._xsteps].x:=floor(ZGs[j+i*quelle._xsteps].x);
        ZPs[j+i*quelle._xsteps].y:=floor(ZGs[j+i*quelle._xsteps].y);
        ZGs[j+i*quelle._xsteps].x:=
@@ -1122,7 +1138,6 @@ begin
        ZAs[ZPs[j+i*quelle._xsteps].x + 1 + (ZPs[j+i*quelle._xsteps].y + 1)*_xsteps]:=
          ZAs[ZPs[j+i*quelle._xsteps].x + 1 + (ZPs[j+i*quelle._xsteps].y + 1)*_xsteps] + ZGs[j+i*quelle._xsteps].x*ZGs[j+i*quelle._xsteps].y;
      end;
-   end;
  end
  else begin
    for b:=false to true do
@@ -1162,12 +1177,13 @@ end;
 
 function tWerte.xscale: extended;
 begin
- result:=(_xstop-_xstart)/(_xsteps-1);
+ gibAus(floattostr(Transformationen.xstop)+' '+floattostr(Transformationen.xstart)+' '+inttostr(Transformationen.xsteps),3);
+ result:=(Transformationen.xstop-Transformationen.xstart)/(Transformationen.xsteps-1);
 end;
 
 function tWerte.tscale: extended;
 begin
- result:=(_tstop-_tstart)/(_tsiz-1);
+ result:=(Transformationen.tstop-Transformationen.tstart)/(Transformationen.tsiz-1);
 end;
 
 function tWerte.dichtenParameterErkannt(st: boolean; s: string; threads,xmin,xmax,tmin,tmax: longint): boolean;
@@ -1188,6 +1204,54 @@ begin
  result:=false;
 end;
 
+function tWerte.kont2disk(dir: char; x: extended): longint;
+begin
+ case dir of
+   'x':
+     result:=min(_xsteps-1,max(0,round(kont2diskFak(dir,x-Transformationen.xstart))));
+   'y','t':
+     result:=min(_tsiz-1,max(0,round(kont2diskFak(dir,x-Transformationen.tstart))));
+   else
+     result:=-1;
+ end;
+end;
+
+function tWerte.kont2diskFak(dir: char; x: extended): extended;
+begin
+ case dir of
+   'x':
+     result:=x*(_xsteps-1)/(Transformationen.xstop-Transformationen.xstart);
+   'y','t':
+     result:=x*(_tsiz-1)/(Transformationen.tstop-Transformationen.tstart);
+   else
+     result:=-1;
+ end;
+end;
+
+function tWerte.disk2kont(dir: char; x: longint): extended;
+begin
+ case dir of
+   'x':
+     result:=disk2kontFak(dir,x)+Transformationen.xstart;
+   'y','t':
+     result:=disk2kontFak(dir,x)+Transformationen.tstart;
+   else
+     result:=nan;
+ end;
+end;
+
+function tWerte.disk2kontFak(dir: char; x: longint): extended;
+begin
+ case dir of
+   'x':
+     result:=x/(_xsteps-1)*(Transformationen.xstop-Transformationen.xstart);
+   'y','t':
+     result:=x/(_tsiz-1)*(Transformationen.tstop-Transformationen.tstart);
+   else
+     result:=nan;
+ end;
+end;
+
 function tWerte.ladeDateien(st: boolean; var f: tInputfile; pl: boolean): boolean;
 var inputs: tGenerischeInputDateiInfoArray;
 
@@ -1203,6 +1267,7 @@ end;
 begin
   result:=false;
   warteaufBeendigungDesLeseThreads;
+  Transformationen.clear;
   Genauigkeit:=gSingle;
   if not ermittleExterneInputParameter(f,inputs) then begin
     aufraeumen;
@@ -1229,15 +1294,8 @@ begin
           eWerte.liesDateien(inputs);
       end{of case};
   end;
-  aufraeumen;
-  Achsenskala.clear;
-  Achsenskala.xstart:=_xstart;
-  Achsenskala.xstop:=_xstop;
-  Achsenskala.xsteps:=_xsteps;
-  Achsenskala.tstart:=_tstart;
-  Achsenskala.tstop:=_tstop;
-  Achsenskala.tsiz:=_tsiz;
-  Werteskala.clear;
+  Transformationen.xsteps:=_xsteps;
+  Transformationen.tsiz:=_tsiz;
   result:=true;
 end;
 
@@ -1251,11 +1309,11 @@ begin
   warteaufBeendigungDesLeseThreads;
   Genauigkeit:=gExtended;
   _tsiz:=-100;
-  _tstart:=-100;
-  _tstop:=-100;
+  Transformationen.tstart:=-100;
+  Transformationen.tstop:=-100;
   _xsteps:=-100;
-  _xstart:=-100;
-  _xstop:=-100;
+  Transformationen.xstart:=-100;
+  Transformationen.xstop:=-100;
   _np:=-100;
   _beta:=-100;
   assignFile(g,datei);
@@ -1270,11 +1328,11 @@ begin
       continue;
     end;
     if startetMit('tstart',s) then begin
-      _tstart:=exprtofloat(st,s);
+      Transformationen.tstart:=exprtofloat(st,s);
       continue;
     end;
     if startetMit('tstop',s) then begin
-      _tstop:=exprtofloat(st,s);
+      Transformationen.tstop:=exprtofloat(st,s);
       continue;
     end;
     if startetMit('xsteps',s) then begin
@@ -1282,11 +1340,11 @@ begin
       continue;
     end;
     if startetMit('xstart',s) then begin
-      _xstart:=exprtofloat(st,s);
+      Transformationen.xstart:=exprtofloat(st,s);
       continue;
     end;
     if startetMit('xstop',s) then begin
-      _xstop:=exprtofloat(st,s);
+      Transformationen.xstop:=exprtofloat(st,s);
       continue;
     end;
     if startetMit('np',s) then begin
@@ -1305,7 +1363,14 @@ begin
     closefile(g);
     exit;
   end;
-  if (_tsiz=-100) or (_tstart=-100) or (_tstop=-100) or (_xsteps=-100) or (_xstart=-100) or (_xstop=-100) or (_np=-100) or (_beta=-100) then begin
+  if (_tsiz=-100) or
+     (Transformationen.tstart=-100) or
+     (Transformationen.tstop=-100) or
+     (_xsteps=-100) or
+     (Transformationen.xstart=-100) or
+     (Transformationen.xstop=-100) or
+     (_np=-100) or
+     (_beta=-100) then begin
     gibAus('Ungenügende Informationen über Raumzeitfenster in Asci-Input-Datei '''+datei+'''!',3);
     closefile(g);
     exit;
@@ -1359,14 +1424,9 @@ begin
       inc(k);
     end;
   end;
-  Achsenskala.clear;
-  Achsenskala.xstart:=_xstart;
-  Achsenskala.xstop:=_xstop;
-  Achsenskala.xsteps:=_xsteps;
-  Achsenskala.tstart:=_tstart;
-  Achsenskala.tstop:=_tstop;
-  Achsenskala.tsiz:=_tsiz;
-  Werteskala.clear;
+  Transformationen.clear;
+  Transformationen.xsteps:=_xsteps;
+  Transformationen.tsiz:=_tsiz;
   gibAus('... fertig '+ZeitDarstellen(now-Zeit),3);
   result:=true;
 end;
@@ -1397,19 +1457,19 @@ begin
       continue;
     end;
     if startetMit('xmin:',s) then begin
-      xmin:=min(_xsteps-1,max(0,round((exprtofloat(st,s)-_xstart)*(_xsteps-1)/(_xstop-_xstart))));
+      xmin:=kont2disk('x',exprtofloat(st,s));
       continue;
     end;
     if startetMit('xmax:',s) then begin
-      xmax:=min(_xsteps-1,max(0,round((exprtofloat(st,s)-_xstart)*(_xsteps-1)/(_xstop-_xstart))));
+      xmax:=kont2disk('x',exprtofloat(st,s));
       continue;
     end;
     if startetMit('tmin:',s) then begin
-      tmin:=min(_tsiz-1,max(0,round((exprtofloat(st,s)-_tstart)*_tsiz/(_tstop-_tstart))));
+      tmin:=kont2disk('t',exprtofloat(st,s));
       continue;
     end;
     if startetMit('tmax:',s) then begin
-      tmax:=min(_tsiz-1,max(0,round((exprtofloat(st,s)-_tstart)*_tsiz/(_tstop-_tstart))));
+      tmax:=kont2disk('t',exprtofloat(st,s));
       continue;
     end;
     setlength(liKo,length(liKo)+1);
@@ -1421,15 +1481,13 @@ begin
     liKo[length(liKo)-1].werte:=wertes^[i mod (length(wertes^)-1)];
     if _xsteps=0 then begin
       _xsteps:=liKo[length(liKo)-1].werte._xsteps;
-      _xstart:=liKo[length(liKo)-1].werte._xstart;
-      _xstop:=liKo[length(liKo)-1].werte._xstop;
+      Transformationen.kopiereVon(liKo[length(liKo)-1].werte.Transformationen);
       xmin:=0;
       xmax:=_xsteps-1;
     end;
     if _tsiz=0 then begin
       _tsiz:=liKo[length(liKo)-1].werte._tsiz;
-      _tstart:=liKo[length(liKo)-1].werte._tstart;
-      _tstop:=liKo[length(liKo)-1].werte._tstop;
+      Transformationen.kopiereVon(liKo[length(liKo)-1].werte.Transformationen);
       tmin:=0;
       tmax:=_tsiz-1;
     end;
@@ -1445,20 +1503,20 @@ begin
       gibAus('Ich bin dumm, ich kann nur Werte mit gleicher Genauigkeit zusammenrechnen!',3);
       exit;
     end;
-    if liKo[length(liKo)-1].werte._xstart<>liKo[0].werte._xstart then begin
-      gibAus('Anfangspostionen passen nicht zusammen ('+floattostr(liKo[0].werte._xstart)+' bisher vs. '+floattostr(liKo[length(liKo)-1].werte._xstart)+' bei '+inttostr(i)+')!',3);
+    if liKo[length(liKo)-1].werte.Transformationen.xstart<>liKo[0].werte.Transformationen.xstart then begin
+      gibAus('Anfangspostionen passen nicht zusammen ('+floattostr(liKo[0].werte.Transformationen.xstart)+' bisher vs. '+floattostr(liKo[length(liKo)-1].werte.Transformationen.xstart)+' bei '+inttostr(i)+')!',3);
       exit;
     end;
-    if liKo[length(liKo)-1].werte._xstop<>liKo[0].werte._xstop then begin
-      gibAus('Endpostionen passen nicht zusammen ('+floattostr(liKo[0].werte._xstop)+' bisher vs. '+floattostr(liKo[length(liKo)-1].werte._xstop)+' bei '+inttostr(i)+')!',3);
+    if liKo[length(liKo)-1].werte.Transformationen.xstop<>liKo[0].werte.Transformationen.xstop then begin
+      gibAus('Endpostionen passen nicht zusammen ('+floattostr(liKo[0].werte.Transformationen.xstop)+' bisher vs. '+floattostr(liKo[length(liKo)-1].werte.Transformationen.xstop)+' bei '+inttostr(i)+')!',3);
       exit;
     end;
-    if liKo[length(liKo)-1].werte._tstart<>liKo[0].werte._tstart then begin
-      gibAus('Anfangszeiten passen nicht zusammen ('+floattostr(liKo[0].werte._tstart)+' bisher vs. '+floattostr(liKo[length(liKo)-1].werte._tstart)+' bei '+inttostr(i)+')!',3);
+    if liKo[length(liKo)-1].werte.Transformationen.tstart<>liKo[0].werte.Transformationen.tstart then begin
+      gibAus('Anfangszeiten passen nicht zusammen ('+floattostr(liKo[0].werte.Transformationen.tstart)+' bisher vs. '+floattostr(liKo[length(liKo)-1].werte.Transformationen.tstart)+' bei '+inttostr(i)+')!',3);
       exit;
     end;
-    if liKo[length(liKo)-1].werte._tstop<>liKo[0].werte._tstop then begin
-      gibAus('Endzeiten passen nicht zusammen ('+floattostr(liKo[0].werte._tstop)+' bisher vs. '+floattostr(liKo[length(liKo)-1].werte._tstop)+' bei '+inttostr(i)+')!',3);
+    if liKo[length(liKo)-1].werte.Transformationen.tstop<>liKo[0].werte.Transformationen.tstop then begin
+      gibAus('Endzeiten passen nicht zusammen ('+floattostr(liKo[0].werte.Transformationen.tstop)+' bisher vs. '+floattostr(liKo[length(liKo)-1].werte.Transformationen.tstop)+' bei '+inttostr(i)+')!',3);
       exit;
     end;
   until false;
@@ -1469,13 +1527,7 @@ begin
   end;
   _xsteps:=xmax-xmin+1;
   _tsiz:=tmax-tmin+1;
-  _xstart:=liKo[0].werte._xstart + xmin/(liKo[0].werte._xsteps-1)*(liKo[0].werte._xstop-liKo[0].werte._xstart);
-  _xstop:=liKo[0].werte._xstart + xmax/(liKo[0].werte._xsteps-1)*(liKo[0].werte._xstop-liKo[0].werte._xstart);
-  _tstart:=liKo[0].werte._tstart + tmin/(liKo[0].werte._tsiz-1)*(liKo[0].werte._tstop-liKo[0].werte._tstart);
-  _tstop:=liKo[0].werte._tstart + tmax/(liKo[0].werte._tsiz-1)*(liKo[0].werte._tstop-liKo[0].werte._tstart);
-  Achsenskala.kopiereVon(liKo[0].werte.Achsenskala);
-  Achsenskala.addAusschnitt(liKo[0].werte._xsteps,liKo[0].werte._tsiz,xmin,xmax,tmin,tmax);
-  Werteskala.append(liKo[0].werte.Werteskala);
+  Transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
   _np:=liKo[0].werte._np;
   _beta:=liKo[0].werte._beta;
   if st then begin
@@ -1510,16 +1562,13 @@ begin
   result:=false;
   warteaufBeendigungDesLeseThreads;
   Zeit:=now;
+  Transformationen.kopiereVon(wertes^[dividend].Transformationen);
   _xsteps:=wertes^[dividend]._xsteps;
   xmin:=0;
   xmax:=_xsteps-1;
-  _xstart:=wertes^[dividend]._xstart;
-  _xstop:=wertes^[dividend]._xstop;
   _tsiz:=wertes^[dividend]._tsiz;
   tmin:=0;
   tmax:=_tsiz-1;
-  _tstart:=wertes^[dividend]._tstart;
-  _tstop:=wertes^[dividend]._tstop;
   _np:=wertes^[dividend]._np;
   _beta:=wertes^[dividend]._beta;
   epsilon:=1e-9;
@@ -1535,23 +1584,23 @@ begin
       continue;
     end;
     if startetMit('xmin:',s) then begin
-      xmin:=min(_xsteps-1,max(0,round((exprtofloat(st,s)-_xstart)*(_xsteps-1)/(_xstop-_xstart))));
+      xmin:=kont2disk('x',exprtofloat(st,s));
       continue;
     end;
     if startetMit('xmax:',s) then begin
-      xmax:=min(_xsteps-1,max(0,round((exprtofloat(st,s)-_xstart)*(_xsteps-1)/(_xstop-_xstart))));
+      xmax:=kont2disk('x',exprtofloat(st,s));
       continue;
     end;
     if startetMit('tmin:',s) then begin
-      tmin:=min(_tsiz-1,max(0,round((exprtofloat(st,s)-_tstart)*_tsiz/(_tstop-_tstart))));
+      tmin:=kont2disk('t',exprtofloat(st,s));
       continue;
     end;
     if startetMit('tmax:',s) then begin
-      tmax:=min(_tsiz-1,max(0,round((exprtofloat(st,s)-_tstart)*_tsiz/(_tstop-_tstart))));
+      tmax:=kont2disk('t',exprtofloat(st,s));
       continue;
     end;
     if startetMit('epsilon:',s) then begin
-      epsilon:=strtoint(s);
+      epsilon:=exprtofloat(st,s);
       continue;
     end;
     gibAus('Verstehe Option '''+s+''' nicht bei Teile!',3);
@@ -1560,24 +1609,17 @@ begin
 
   _xsteps:=xmax-xmin+1;
   _tsiz:=tmax-tmin+1;
-  if // (wertes[dividend]^.genauigkeit<>wertes[divisor]^.genauigkeit) or
-     (wertes^[dividend]._xstart<>wertes^[divisor]._xstart) or
-     (wertes^[dividend]._xstop<>wertes^[divisor]._xstop) or
-     (wertes^[dividend]._tstart<>wertes^[divisor]._tstart) or
-     (wertes^[dividend]._tstop<>wertes^[divisor]._tstop) or
+  if (wertes^[dividend].Transformationen.xstart<>wertes^[divisor].Transformationen.xstart) or
+     (wertes^[dividend].Transformationen.xstop<>wertes^[divisor].Transformationen.xstop) or
+     (wertes^[dividend].Transformationen.tstart<>wertes^[divisor].Transformationen.tstart) or
+     (wertes^[dividend].Transformationen.tstop<>wertes^[divisor].Transformationen.tstop) or
      (wertes^[dividend]._xsteps<>wertes^[divisor]._xsteps) or
      (wertes^[dividend]._tsiz<>wertes^[divisor]._tsiz) then begin
 //    gibAus('Dividend und Divisor haben verschiedene Abmessungen oder verschiedene Genauigkeiten, sowas verstehe ich nicht!',3);
     gibAus('Dividend und Divisor haben verschiedene Abmessungen, sowas verstehe ich nicht!',3);
     exit;
   end;
-  Achsenskala.kopiereVon(wertes^[dividend].Achsenskala);
-  Achsenskala.addAusschnitt(wertes^[dividend]._xsteps,wertes^[dividend]._tsiz,xmin,xmax,tmin,tmax);
-  Werteskala.kopiereVon(wertes^[dividend].Werteskala);
-  _xstart:=wertes^[dividend]._xstart + xmin/(wertes^[dividend]._xsteps-1)*(wertes^[dividend]._xstop-wertes^[dividend]._xstart);
-  _xstop:=wertes^[dividend]._xstart + xmax/(wertes^[dividend]._xsteps-1)*(wertes^[dividend]._xstop-wertes^[dividend]._xstart);
-  _tstart:=wertes^[dividend]._tstart + tmin/(wertes^[dividend]._tsiz-1)*(wertes^[dividend]._tstop-wertes^[dividend]._tstart);
-  _tstop:=wertes^[dividend]._tstart + tmax/(wertes^[dividend]._tsiz-1)*(wertes^[dividend]._tstop-wertes^[dividend]._tstart);
+  Transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
   _np:=wertes^[dividend]._np;
   _beta:=wertes^[dividend]._beta;
   Genauigkeit:=gExtended;
@@ -1620,19 +1662,16 @@ begin
   wavelet:=tWavelet.create;
   wavelet.mitFFT:=false;
   Zeit:=now;
+  Transformationen.kopiereVon(quelle.Transformationen);
   wavelet.freq:=0;
   wavelet.tfwhm:=1;
   wavelet.typ:=wtSin2;
   _xsteps:=quelle._xsteps;
   xmin:=0;
   xmax:=_xsteps-1;
-  _xstart:=quelle._xstart;
-  _xstop:=quelle._xstop;
   _tsiz:=quelle._tsiz;
   tmin:=0;
   tmax:=_tsiz-1;
-  _tstart:=quelle._tstart;
-  _tstop:=quelle._tstop;
   _np:=quelle._np;
   _beta:=quelle._beta;
   ausrichtung:=0;
@@ -1647,27 +1686,27 @@ begin
       continue;
     end;
     if startetMit('xmin:',s) then begin
-      xmin:=min(_xsteps-1,max(0,round((exprtofloat(st,s)-_xstart)*(_xsteps-1)/(_xstop-_xstart))));
+      xmin:=kont2disk('x',exprtofloat(st,s));
       continue;
     end;
     if startetMit('xmax:',s) then begin
-      xmax:=min(_xsteps-1,max(0,round((exprtofloat(st,s)-_xstart)*(_xsteps-1)/(_xstop-_xstart))));
+      xmax:=kont2disk('x',exprtofloat(st,s));
       continue;
     end;
     if startetMit('tmin:',s) then begin
-      tmin:=min(_tsiz-1,max(0,round((exprtofloat(st,s)-_tstart)*_tsiz/(_tstop-_tstart))));
+      tmin:=kont2disk('t',exprtofloat(st,s));
       continue;
     end;
     if startetMit('tmax:',s) then begin
-      tmax:=min(_tsiz-1,max(0,round((exprtofloat(st,s)-_tstart)*_tsiz/(_tstop-_tstart))));
+      tmax:=kont2disk('t',exprtofloat(st,s));
       continue;
     end;
     if startetMit('freq:',s) then begin
-      wavelet.freq:=exprtofloat(st,s)/(_tsiz-1)*(_tstop-_tstart);
+      wavelet.freq:=1/kont2diskFak('t',1/exprtofloat(st,s));
       continue;
     end;
     if startetMit('tfwhm:',s) then begin
-      wavelet.tfwhm:=round(exprtofloat(st,s)*(_tsiz-1)/(_tstop-_tstart));
+      wavelet.tfwhm:=round(kont2diskFak('t',exprtofloat(st,s)));
       continue;
     end;
     if startetMit('Wavelettyp:',s) then begin
@@ -1700,9 +1739,7 @@ begin
     exit;
   until false;
 
-  Achsenskala.kopiereVon(quelle.Achsenskala);
-  Achsenskala.addAusschnitt(quelle._xsteps,quelle._tsiz,xmin,xmax,tmin,tmax);
-  Werteskala.kopiereVon(quelle.Werteskala);
+  Transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
   _xsteps:=xmax-xmin+1;
   if wavelet.mitFFT then begin
     i:=1;
@@ -1796,12 +1833,11 @@ begin
  setlength(DTs,threads);
  gibAus('Ermittle maximale und minimale Dichten ...',3);
  j:=xmin;
- for i:=0 to length(DTs)-1 do
-  begin
+ for i:=0 to length(DTs)-1 do begin
    DTs[i]:=tDichteThread.create(j,Byte(i=length(DTs)-1)*xmax + Byte(i<length(DTs)-1)*(j+ ((xmax+1-xmin) div length(DTs))),tmin,tmax,self);
    j:=Byte(i=length(DTs)-1)*xmax + Byte(i<length(DTs)-1)*(j+((xmax+1-xmin) div length(DTs)))+1;
    gibAus('Dichtethread '+inttostr(i)+' gestartet!',1);
-  end;
+ end;
  repeat
    sleep(100);
    fertig:=true;
@@ -1811,12 +1847,11 @@ begin
  gibAus('Alle Dichtethreads beendet!',1);
  _maxW:=DTs[0].maxDichte;
  _minW:=DTs[0].minDichte;
- for i:=1 to length(DTs)-1 do
-  begin
+ for i:=1 to length(DTs)-1 do begin
    _maxW:=max(_maxW,DTs[i].maxDichte);
    _minW:=min(_minW,DTs[i].minDichte);
    DTs[i].free;
-  end;
+ end;
  gibAus('... sie sind '+myfloattostr(_minW)+' und '+myfloattostr(_maxW)+'. '+ZeitDarstellen(now-Zeit),3);
  if symmetrisch then begin
    _minW:=min(_minW,-_maxW);
@@ -1918,13 +1953,15 @@ begin
   end;
   warteaufBeendigungDesLeseThreads;
   Zeit:=now;
+  Transformationen.kopiereVon(quelle.Transformationen);
+  Transformationen.clearWerte;
   Fenster.Breite:=0;
   Fenster.aktiv:=false;
   Fenster.Rand:=0;
   Schritt:=round(sqrt(quelle._tsiz));
   tmin:=0;
   tmax:=quelle._tsiz-1;
-  freqMax:=quelle._tsiz/(quelle._tstop-quelle._tstart);
+  freqMax:=quelle._tsiz/(quelle.Transformationen.tstop-quelle.Transformationen.tstart);
   Genauigkeit:=gExtended;
   repeat
     if not f.gibZeile(s) then begin
@@ -1941,22 +1978,22 @@ begin
       continue;
     end;
     if startetMit('Fenster:',s) then begin
-      Fenster.Breite:=round(quelle.exprtofloat(st,erstesArgument(s,';'))*(quelle._tsiz-1)/(quelle._tstop-quelle._tstart));
-      Fenster.Rand:=round(quelle.exprtofloat(st,s)*(quelle._tsiz-1)/(quelle._tstop-quelle._tstart));
+      Fenster.Breite:=round(quelle.kont2diskFak('t',quelle.exprtofloat(st,erstesArgument(s,';'))));
+      Fenster.Rand:=round(quelle.kont2diskFak('t',quelle.exprtofloat(st,s)));
       Fenster.aktiv:=true;
       continue;
     end;
     if startetMit('Schritt:',s) then begin
-      Schritt:=round(quelle.exprtofloat(st,s)*(quelle._tsiz-1)/(quelle._tstop-quelle._tstart));
+      Schritt:=round(quelle.kont2diskFak('t',quelle.exprtofloat(st,s)));
       continue;
     end;
     if (quelle._xsteps=1) then begin
       if startetMit('xmin:',s) then begin
-        tmin:=round((quelle.exprtofloat(st,s)-quelle._xstart)*(quelle._xsteps-1)/(quelle._xstop-quelle._xstart));
+        tmin:=quelle.kont2disk('x',quelle.exprtofloat(st,s));
         continue;
       end;
       if startetMit('xmax:',s) then begin
-        tmax:=round((quelle.exprtofloat(st,s)-quelle._xstart)*(quelle._xsteps-1)/(quelle._xstop-quelle._xstart));
+        tmax:=quelle.kont2disk('x',quelle.exprtofloat(st,s));
         continue;
       end;
       if startetMit('wmax:',s) or startetMit('omegamax:',s) or startetMit('ωmax:',s) then begin
@@ -1966,11 +2003,11 @@ begin
     end;
     if (quelle._tsiz=1) then begin
       if startetMit('tmin:',s) then begin
-        tmin:=round((quelle.exprtofloat(st,s)-quelle._tstart)*(quelle._tsiz-1)/(quelle._tstop-quelle._tstart));
+        tmin:=quelle.kont2disk('t',quelle.exprtofloat(st,s));
         continue;
       end;
       if startetMit('tmax:',s) then begin
-        tmax:=round((quelle.exprtofloat(st,s)-quelle._tstart)*(quelle._tsiz-1)/(quelle._tstop-quelle._tstart));
+        tmax:=quelle.kont2disk('t',quelle.exprtofloat(st,s));
         continue;
       end;
       if startetMit('kmax:',s) then begin
@@ -1984,27 +2021,28 @@ begin
   tmin:=max(0,tmin);
   tmax:=min(quelle._tsiz-1,tmax);
   Schritt:=max(1,Schritt);
+
+  _tsiz:=round(power(2,ceil(ln(Fenster.Breite)/ln(2))));
+  _xsteps:=1 + ((tmax-tmin+1-(Fenster.Breite-1)) div Schritt);
+  if _xsteps<=0 then begin
+    gibAus('Das angegebene Fenster passt nicht zwischen Anfangs- und Endzeit! ('+
+      floattostrtrunc(disk2kontFak('t',Fenster.Breite),2,true)+'>='+
+      floattostrtrunc(disk2kontFak('t',tmax-tmin+1),2,true)+')',3);
+    exit;
+  end;
+  if quelle._tsiz<>1 then begin
+    Transformationen.xstart:=quelle.disk2kont('t',tmin);      // quelle._tstart + tmin/(quelle._tsiz-1)*(quelle._tstop-quelle._tstart);
+    Transformationen.xstop:= quelle.disk2kont('t',tmax);      // quelle._tstart + tmax/(quelle._tsiz-1)*(quelle._tstop-quelle._tstart);
+    Transformationen.tstart:=0;
+    Transformationen.tstop:=quelle.disk2kontFak('t',_tsiz-1); // _tsiz/(quelle._tsiz-1)*(quelle._tstop-quelle._tstart);
+  end
+  else begin
+    Transformationen.xstart:=quelle.disk2kont('x',tmin);      // _xstart:=quelle._xstart + tmin/(quelle._xsteps-1)*(quelle._xstop-quelle._xstart);
+    Transformationen.xstop:= quelle.disk2kont('x',tmax);      // _xstop:= quelle._xstart + tmax/(quelle._xsteps-1)*(quelle._xstop-quelle._xstart);
+    Transformationen.tstart:=0;
+    Transformationen.tstop:=quelle.disk2kontFak('x',_tsiz-1); // _tstop:=_tsiz/(quelle._xsteps-1)*(quelle._xstop-quelle._xstart);
+  end;
   if not st then begin
-    _tsiz:=round(power(2,ceil(ln(Fenster.Breite)/ln(2))));
-    _xsteps:=1 + ((tmax-tmin+1-(Fenster.Breite-1)) div Schritt);
-    if _xsteps<=0 then begin
-      gibAus('Das angegebene Fenster passt nicht zwischen Anfangs- und Endzeit! ('+
-        floattostrtrunc(Fenster.Breite/(quelle._tsiz-1)*(quelle._tstop-quelle._tstart),2,true)+'>='+
-        floattostrtrunc((tmax-tmin+1)/(quelle._tsiz-1)*(quelle._tstop-quelle._tstart),2,true)+')',3);
-      exit;
-    end;
-    if quelle._tsiz<>1 then begin
-      _xstart:=quelle._tstart + tmin/(quelle._tsiz-1)*(quelle._tstop-quelle._tstart);
-      _xstop:= quelle._tstart + tmax/(quelle._tsiz-1)*(quelle._tstop-quelle._tstart);
-      _tstart:=0;
-      _tstop:=_tsiz/(quelle._tsiz-1)*(quelle._tstop-quelle._tstart);
-    end
-    else begin
-      _xstart:=quelle._xstart + tmin/(quelle._xsteps-1)*(quelle._xstop-quelle._xstart);
-      _xstop:= quelle._xstart + tmax/(quelle._xsteps-1)*(quelle._xstop-quelle._xstart);
-      _tstart:=0;
-      _tstop:=_tsiz/(quelle._xsteps-1)*(quelle._xstop-quelle._xstart);
-    end;
     tOf:=(_tsiz-Fenster.Breite) div 2;
     eWerte.holeRam(3);
     gibAus('kopiere Inhalt ...',3);
@@ -2032,25 +2070,21 @@ begin
       gibAus('Es traten Fehler auf!',3);
       exit;
     end;
-    _tstop:=(_tsiz div 2-1)/(_tstop-_tstart)/2;
-    _tstart:=0;
     gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',3);
-    if (_tstop<=freqmax) or (freqmax<=0) then
-      _tsiz:=_tsiz div 2
-    else begin
-      freqmax:=_tstop * round((_tsiz div 2)/_tstop*freqmax) / (_tsiz div 2);
-      _tsiz:=round((_tsiz div 2)/_tstop*freqmax);
-      _tstop:=freqmax;
-    end;
-    eWerte.holeRAM(0);
   end;
-  Achsenskala.clear;
-  Achsenskala.xsteps:=_xsteps;
-  Achsenskala.tsiz:=_tsiz;
-  Achsenskala.xstart:=_xstart;
-  Achsenskala.xstop:=_xstop;
-  Achsenskala.tstart:=_tstart;
-  Achsenskala.tstop:=_tstop;
+  Transformationen.tstop:=(_tsiz div 2-1)/(Transformationen.tstop-Transformationen.tstart)/2;
+  Transformationen.tstart:=0;
+  if (Transformationen.tstop<=freqmax) or (freqmax<=0) then
+    _tsiz:=_tsiz div 2
+  else begin
+    freqmax:=Transformationen.tstop * round((_tsiz div 2)/Transformationen.tstop*freqmax) / (_tsiz div 2);
+    _tsiz:=round((_tsiz div 2)/Transformationen.tstop*freqmax);
+    Transformationen.tstop:=freqmax;
+  end;                              gibAus(inttostr(_xsteps)+' '+inttostr(_tsiz),3);
+  Transformationen.xsteps:=_xsteps;
+  Transformationen.tsiz:=_tsiz;
+  if not st then
+    eWerte.holeRAM(0);
   gibAus('... fertig '+ZeitDarstellen(now-Zeit),3);
   result:=true;
 end;
@@ -2063,8 +2097,8 @@ var i,j:                     longint;
     ZAs:                     tExtendedArray;  // Anzahl Quellen, die auf entsprechende Zielposition abgebildet werden
     Zeit,epsilon:            extended;
     Vorbearbeitung,
-    Nachbearbeitung:         tBearbeitungen;
-    verzerrung:              tVerzerrung;
+    Nachbearbeitung,
+    verzerrung:              tTransformationen;
     s:                       string;
     verzerrThreads:          array of tVerzerrThread;
     fertig:                  boolean;
@@ -2075,16 +2109,9 @@ begin
    if assigned(verzerrThreads[ii]) then
      verzerrThreads[ii].free;
  setlength(verzerrThreads,0);
- for ii:=0 to Vorbearbeitung.count-1 do
-   if assigned(Vorbearbeitung[ii]) then
-     Vorbearbeitung[ii].free;
  Vorbearbeitung.free;
- for ii:=0 to Nachbearbeitung.count-1 do
-   if assigned(Nachbearbeitung[ii]) then
-     Nachbearbeitung[ii].free;
  Nachbearbeitung.free;
- if assigned(verzerrung) then
-   verzerrung.free;
+ verzerrung.free;
  setlength(ZPs,0);
  setlength(ZGs,0);
  setlength(ZAs,0);
@@ -2094,11 +2121,13 @@ begin
  warteaufBeendigungDesLeseThreads;
  gibAus('Verzerrung berechnen ... ',3);
  Zeit:=now;
- verzerrung:=tVerzerrung.create;
+ verzerrung:=tTransformationen.create;
+ verzerrung.xsteps:=quelle._xsteps;
+ verzerrung.tsiz:=quelle._tsiz;
  epsilon:=1e-9;
  Genauigkeit:=gExtended;
- Vorbearbeitung:=tBearbeitungen.create;
- Nachbearbeitung:=tBearbeitungen.create;
+ Vorbearbeitung:=tTransformationen.create;
+ Nachbearbeitung:=tTransformationen.create;
  repeat
    if not f.gibZeile(s) then begin
      gibAus('Unerwartetes Dateiende!',3);
@@ -2120,7 +2149,7 @@ begin
      continue;
    end;
    if startetMit('Abbildung:',s) then begin
-     if not verzerrung.initAbbildung(st,s,quelle.xscale,quelle.tscale,@(exprtofloat)) then begin
+     if not verzerrung.add(st,s,quelle.xscale,quelle.tscale,@(exprtofloat)) then begin
        gibAus('Syntaxfehler in der Funktion '''+s+'''!',3);
        aufraeumen;
        exit;
@@ -2129,21 +2158,21 @@ begin
        gibAus(verzerrung.dumpParams,3);
        for i:=0 to 1 do
          for j:=0 to 1 do
-           gibAus(inttostr(i*(quelle._xsteps-1))+';'+inttostr(j*(quelle._tsiz-1))+' -> '+floattostr(verzerrung.ziel(i*(quelle._xsteps-1),j*(quelle._tsiz-1)).x)+';'+floattostr(verzerrung.ziel(i*(quelle._xsteps-1),j*(quelle._tsiz-1)).y),3);
+           gibAus(
+             inttostr(i*(quelle._xsteps-1))+';'+inttostr(j*(quelle._tsiz-1))+' -> '+
+             tExtPointToStr(verzerrung.transformiereKoordinaten(i*(quelle._xsteps-1),j*(quelle._tsiz-1))),3);
      end;
      continue;
    end;
    if startetMit('Nachbearbeitung:',s) then begin
-     Nachbearbeitung.addNew;
-     if not Nachbearbeitung.last.init(st,s,f,@exprtofloat) then begin
+     if not Nachbearbeitung.add(st,s,f,@exprtofloat) then begin
        aufraeumen;
        exit;
      end;
      continue;
    end;
    if startetMit('Vorbearbeitung:',s) then begin
-     Vorbearbeitung.addNew;
-     if not Vorbearbeitung.last.init(st,s,f,@exprtofloat) then begin
+     if not Vorbearbeitung.add(st,s,f,@exprtofloat) then begin
        aufraeumen;
        exit;
      end;
@@ -2153,23 +2182,20 @@ begin
    aufraeumen;
    exit;
  until false;
- Achsenskala.add(Verzerrung);
- Werteskala.append(Vorbearbeitung);
- Werteskala.append(Nachbearbeitung);
+ Transformationen.kopiereVon(quelle.Transformationen);
+ Transformationen.append(Vorbearbeitung);
+ Transformationen.append(Verzerrung);
+ Transformationen.append(Nachbearbeitung);
  if not st then begin
    gibAus('... Zielausdehnung berechnen ... ',3);
-   verzerrung.berechneZielausdehnung(quelle._xsteps,quelle._tsiz,grenzen);
+   verzerrung.berechneZielausdehnung(grenzen);
    _xsteps:=grenzen['x','y']-grenzen['x','x']+2;
    _tsiz:=grenzen['y','y']-grenzen['y','x']+2;
-   if (_xsteps<=0) or (_tsiz<=0) then begin
+   if (_xsteps<=1) or (_tsiz<=1) then begin
      gibAus('Es passt kein Rechteck des Ziels vollständig in die Quelldaten!',3);
      aufraeumen;
      exit;
    end;
-   _xstart:=quelle._xstart;  // eher unzuverlässig, was sollte man auch jetzt von diesen Werten erwarten?
-   _xstop:= quelle._xstop;
-   _tstart:=quelle._tstart;
-   _tstop:= quelle._tstop;
    eWerte.holeRam(3);
    gibAus('Positionen und Gewichte initialisieren ...',3);
    setlength(ZPs,quelle._xsteps*quelle._tsiz);
@@ -2224,19 +2250,19 @@ begin
       continue;
     end;
     if startetMit('xmin:',s) then begin
-      xmin:=round((quelle.exprtofloat(st,s)-quelle._xstart)*(quelle._xsteps-1)/(quelle._xstop-quelle._xstart));
+      xmin:=quelle.kont2disk('x',quelle.exprtofloat(st,s));
       continue;
     end;
     if startetMit('xmax:',s) then begin
-      xmax:=round((quelle.exprtofloat(st,s)-quelle._xstart)*(quelle._xsteps-1)/(quelle._xstop-quelle._xstart));
+      xmax:=quelle.kont2disk('x',quelle.exprtofloat(st,s));
       continue;
     end;
     if startetMit('tmin:',s) then begin
-      tmin:=round((quelle.exprtofloat(st,s)-quelle._tstart)*(quelle._tsiz-1)/(quelle._tstop-quelle._tstart));
+      tmin:=quelle.kont2disk('t',quelle.exprtofloat(st,s));
       continue;
     end;
     if startetMit('tmax:',s) then begin
-      tmax:=round((quelle.exprtofloat(st,s)-quelle._tstart)*(quelle._tsiz-1)/(quelle._tstop-quelle._tstart));
+      tmax:=quelle.kont2disk('t',quelle.exprtofloat(st,s));
       continue;
     end;
     if startetMit('Richtung:',s) then begin
@@ -2262,16 +2288,11 @@ begin
   tmax:=min(quelle._tsiz-1,tmax);
   xmin:=max(0,xmin);
   xmax:=min(quelle._xsteps-1,xmax);
-  Achsenskala.kopiereVon(quelle.Achsenskala);
-  Achsenskala.addAusschnitt(quelle._xsteps,quelle._tsiz,xmin,xmax,tmin,tmax);
-  Werteskala.kopiereVon(quelle.Werteskala);
+  Transformationen.kopiereVon(quelle.Transformationen);
+  Transformationen.addAusschnitt(xmin,xmax,tmin,tmax);
   if not st then begin
     _tsiz:=tmax-tmin+1;
     _xsteps:=xmax-xmin+1;
-    _xstart:=quelle._xstart + xmin/(quelle._xsteps-1)*(quelle._xstop-quelle._xstart);
-    _xstop:= quelle._xstart + xmax/(quelle._xsteps-1)*(quelle._xstop-quelle._xstart);
-    _tstart:=quelle._tstart + tmin/(quelle._tsiz-1)*(quelle._tstop-quelle._tstart);
-    _tstop:= quelle._tstart + tmax/(quelle._tsiz-1)*(quelle._tstop-quelle._tstart);
 
     eWerte.holeRam(3);
     gibAus('Berechne Integrale ...',3);
@@ -2334,9 +2355,9 @@ begin
     end;
     if startetMit('Fenster:',s) then begin
       if senkrecht then
-        Fenster.Rand:=round(exprtofloat(st,s)*(_tsiz-1)/(_tstop-_tstart))
+        Fenster.Rand:=round(kont2diskFak('t',exprtofloat(st,s)))
       else
-        Fenster.Rand:=round(exprtofloat(st,s)*(_xsteps-1)/(_xstop-_xstart));
+        Fenster.Rand:=round(kont2diskFak('x',exprtofloat(st,s)));
       Fenster.aktiv:=true;
       continue;
     end;
@@ -2363,25 +2384,32 @@ begin
     end;
     gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',3);
   end;
-  i:=1;
-  while 2*i<=_tsiz do
-    i:=i*2;
-  _tstop:=_tstart+(_tstop-_tstart)*(i-1)/(_tsiz-1);
-  _tsiz:=i;
+  if senkrecht then begin
+    i:=1;
+    while 2*i<=_tsiz do
+      i:=i*2;
+    Transformationen.addAusschnitt(0,_xsteps-1,(_tsiz-i) div 2,((_tsiz+i) div 2) - 1);
+    if not st then begin
+      gibAus('Die Länge wird von '+inttostr(_tsiz)+' auf '+inttostr(i)+' Zeitschritte gekürzt!',3);
+      _tsiz:=i;
+    end;
+  end
+  else begin
+    i:=1;
+    while 2*i<=_xsteps do
+      i:=i*2;
+    Transformationen.addAusschnitt((_xsteps-i) div 2,((_xsteps+i) div 2) - 1,0,_tsiz-1);
+    if not st then begin
+      gibAus('Die Länge wird von '+inttostr(_xsteps)+' auf '+inttostr(i)+' Ortsschritte gekürzt!',3);
+      _xsteps:=i;
+    end;
+  end;
+  Transformationen.addFFT(not senkrecht,senkrecht);
   if not st then begin
-    gibAus('Die Länge wird von '+inttostr(_tsiz)+' auf '+inttostr(i)+' Zeitschritte gekürzt!',3);
     eWerte.holeRam(0);
     gibAus('... fertig! '+ZeitDarstellen(now-Zeit),3);
   end;
-  _tstop:=(_tsiz-1)/(_tstop-_tstart);
-  _tstart:=0;
-  Achsenskala.clear;
-  Achsenskala.xsteps:=_xsteps;
-  Achsenskala.tsiz:=_tsiz;
-  Achsenskala.xstart:=_xstart;
-  Achsenskala.xstop:=_xstop;
-  Achsenskala.tstart:=_tstart;
-  Achsenskala.tstop:=_tstop;
+  _tsiz:=i;
   result:=true;
 end;
 
@@ -2420,8 +2448,8 @@ begin
       b:=s[1]='t';
       delete(s,1,pos(':',s));
       s:=trim(s);
-      if b then Fensters[b].Rand:=round(exprtofloat(st,s)*(_tsiz-1)/(_tstop-_tstart))
-      else Fensters[b].Rand:=round(exprtofloat(st,s)*(_xsteps-1)/(_xstop-_xstart));
+      if b then Fensters[b].Rand:=round(kont2diskFak('t',exprtofloat(st,s)))
+      else Fensters[b].Rand:=round(kont2diskFak('x',exprtofloat(st,s)));
       Fensters[b].aktiv:=true;
       continue;
     end;
@@ -2447,7 +2475,7 @@ begin
     i:=i*2;
   if _tsiz>i then begin
     gibAus('Die Länge wird von '+inttostr(_tsiz)+' auf '+inttostr(i)+' Zeitschritte gekürzt!',3);
-    _tstop:=_tstart+(_tstop-_tstart)*(i-1)/(_tsiz-1);
+    Transformationen.addAusschnitt(0,_xsteps-1,(_tsiz-i) div 2,((_tsiz+i) div 2) - 1);
     _tsiz:=i;
     eWerte.holeRam(0);
   end;
@@ -2456,12 +2484,13 @@ begin
     i:=i*2;
   if _xsteps>i then begin
     gibAus('Die Breite wird von '+inttostr(_xsteps)+' auf '+inttostr(i)+' Ortsschritte gekürzt!',3);
-    _xstop:=_xstart+(_xstop-_xstart)*(i-1)/(_xsteps-1);
+    Transformationen.addAusschnitt((_xsteps-i) div 2,((_xsteps+i) div 2) - 1,0,_tsiz-1);
     for k:=1 to _tsiz-1 do
       Move(eWerte.werte[k*_xsteps],eWerte.werte[k*i],i*sizeof(extended));
     _xsteps:=i;
     eWerte.holeRam(0);
   end;
+  Transformationen.addFFT(true,true);
   gibAus('... fertig! '+ZeitDarstellen(now-Zeit),3);
   if spiegeln then begin
     gibAus('Werte spiegeln ...',3);
@@ -2474,8 +2503,6 @@ begin
     exit;
   end;
   gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',3);
-  _tstop:=(_tsiz-1)/(_tstop-_tstart);
-  _tstart:=0;
   gibAus('... fertig! '+ZeitDarstellen(now-Zeit),3);
   gibAus('berechne x-FFT ...',3);
   if not fft(threads,0,_xsteps-1,0,_tsiz-1,false,false,doRes,preOrd,Fensters[false],pvFehler,Warn) then begin
@@ -2483,8 +2510,6 @@ begin
     exit;
   end;
   gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',3);
-  _xstop:=(_xsteps-1)/(_xstop-_xstart);
-  _xstart:=0;
   gibAus('... fertig! '+ZeitDarstellen(now-Zeit),3);
   gibAus('Wertenachbearbeiten ...',3);
   case genauigkeit of
@@ -2495,13 +2520,6 @@ begin
     doBetr,doBetrQdr:
       fft2dNachbearbeitung(threads,nb);                // die Hauptarbeit
   end{of case};
-  Achsenskala.clear;
-  Achsenskala.xsteps:=_xsteps;
-  Achsenskala.tsiz:=_tsiz;
-  Achsenskala.xstart:=_xstart;
-  Achsenskala.xstop:=_xstop;
-  Achsenskala.tstart:=_tstart;
-  Achsenskala.tstop:=_tstop;
   gibAus('... fertig! '+ZeitDarstellen(now-Zeit),3);
   result:=true;
 end;
@@ -2513,7 +2531,7 @@ var s,datei:                               string;
     xmin,xmax,tmin,tmax,xp,tp:             longint;
     breite,hoehe,lof,rof,oof,uof:          longint;
     Palette:                               pTPalette;
-    Nachbearbeitung:                       tBearbeitungen;
+    Nachbearbeitung:                       tTransformationen;
     BilderThreads:                         array of TBilderthread;
     fertig,Rahmen:                         boolean;
     img:                                   file;
@@ -2556,7 +2574,7 @@ begin
  tmin:=0;
  tmax:=_tsiz-1;
  schriftgroesze:=24;
- Nachbearbeitung:=tBearbeitungen.create;
+ Nachbearbeitung:=tTransformationen.create;
  findePalette(Palette,'Graustufen');
  setlength(Achsen,0);
  setlength(verwKonturen,0);
@@ -2589,19 +2607,19 @@ begin
   end;
   if self.dichtenParameterErkannt(st,s,maxThreads,xmin,xmax,tmin,tmax) then continue;
   if startetMit('xmin:',s) then begin
-    xmin:=min(_xsteps-1,max(0,round((exprtofloat(st,s)-_xstart)*(_xsteps-1)/(_xstop-_xstart))));
+    xmin:=kont2disk('x',exprtofloat(st,s));
     continue;
   end;
   if startetMit('xmax:',s) then begin
-    xmax:=min(_xsteps-1,max(0,round((exprtofloat(st,s)-_xstart)*(_xsteps-1)/(_xstop-_xstart))));
+    xmax:=kont2disk('x',exprtofloat(st,s));
     continue;
   end;
   if startetMit('tmin:',s) then begin
-    tmin:=min(_tsiz-1,max(0,round((exprtofloat(st,s)-_tstart)*(_tsiz-1)/(_tstop-_tstart))));
+    tmin:=kont2disk('t',exprtofloat(st,s));
     continue;
   end;
   if startetMit('tmax:',s) then begin
-    tmax:=min(_tsiz-1,max(0,round((exprtofloat(st,s)-_tstart)*(_tsiz-1)/(_tstop-_tstart))));
+    tmax:=kont2disk('t',exprtofloat(st,s));
     continue;
   end;
   if startetMit('Palette:',s) then begin
@@ -2621,8 +2639,7 @@ begin
     continue;
   end;
   if startetMit('Nachbearbeitung:',s) then begin
-    Nachbearbeitung.addNew;
-    if not Nachbearbeitung.last.init(st,s,f,@exprtofloat) then begin
+    if not Nachbearbeitung.add(st,s,f,@exprtofloat) then begin
       aufraeumen;
       exit;
     end;
@@ -2692,7 +2709,7 @@ begin
  tmin:=max(tmin,0);
  tmax:=min(tmax,_tsiz-1);
  gibAus('('+inttostr(xmin)+'-'+inttostr(xmax)+'x'+inttostr(tmin)+'-'+inttostr(tmax)+')',3);
- gibAus(' ('+floattostr(_xstart)+'-'+floattostr(_xstop)+' x '+floattostr(_tstart)+'-'+floattostr(_tstop)+')',3);
+ gibAus(' ('+floattostr(Transformationen.xstart)+'-'+floattostr(Transformationen.xstop)+' x '+floattostr(Transformationen.tstart)+'-'+floattostr(Transformationen.tstop)+')',3);
  breite:=round((xmax-xmin)*xzoom)+1;
  hoehe:=round((tmax-tmin)*yzoom)+1;
 
@@ -2723,12 +2740,12 @@ begin
    wert:=ceil(miw/schritt)*schritt;
    while wert<=maw do  *)
    if Achsen[i].Lage in [lOben,lUnten] then begin
-     maw:=xMax/(Achsenskala.xsteps-1)*(Achsenskala.xstop-Achsenskala.xstart)+Achsenskala.xstart;
-     miw:=xMin/(Achsenskala.xsteps-1)*(Achsenskala.xstop-Achsenskala.xstart)+Achsenskala.xstart;
+     maw:=disk2kont('x',xMax);
+     miw:=disk2Kont('x',xMin);
    end
    else begin
-     maw:=tMax/(Achsenskala.tsiz-1)*(Achsenskala.tstop-Achsenskala.tstart)+Achsenskala.tstart;
-     miw:=tMin/(Achsenskala.tsiz-1)*(Achsenskala.tstop-Achsenskala.tstart)+Achsenskala.tstart;
+     maw:=disk2kont('t',tMax);
+     miw:=disk2kont('t',tMin);
    end;
    schritt:=(maw-miw)/Achsen[i].Striche;
    j:=round(ln(schritt)/ln(10));
@@ -2744,7 +2761,10 @@ begin
        fontRend:=fontRenderer;
        lage:=Achsen[i].lage;
 //       position:=(wert-miw)/(maw-miw);
-       position:=Achsenskala.gibPosition(Achsen[i].Lage,wert);
+  gibAus(' -> -> '+inttostr(Transformationen.count),3);
+  for j:=0 to Transformationen.count-1 do
+    gibAus(' '+inttostr(j)+' '+Transformationen.Inhalt[j].dumpParams,3);
+       position:=Transformationen.transformiereKoordinaten(Achsen[i].Lage,wert);
        if (position<0) or (position>1) then begin
          beschriftungen[length(beschriftungen)-1].free;
          setlength(beschriftungen,length(beschriftungen)-1);
@@ -2790,8 +2810,8 @@ begin
  gibAus('Alle Threads beendet, Konturen einfügen ...',1);
  for i:=0 to length(verwKonturen)-1 do
    for j:=0 to length(konturen^[verwKonturen[i]].orte)-1 do begin
-     xp:=round((_xsteps-1)*(konturen^[verwKonturen[i]].orte[j].x-_xstart)/(_xstop-_xstart));
-     tp:=round((_tsiz-1) * (konturen^[verwKonturen[i]].orte[j].y-_tstart)/(_tstop-_tstart));
+     xp:=kont2disk('x',konturen^[verwKonturen[i]].orte[j].x);
+     tp:=kont2disk('t',konturen^[verwKonturen[i]].orte[j].y);
 
      if (xmin<=xp) and (xp<=xmax) and (tmin<=tp) and (tp<=tmax) then begin
        k:=0;
@@ -2850,19 +2870,19 @@ begin
      continue;
    end;
    if startetMit('xmin:',s) then begin
-     xmin:=round((exprtofloat(st,s)-_xstart)*(_xsteps-1)/(_xstop-_xstart));
+     xmin:=kont2disk('x',exprtofloat(st,s));
      continue;
    end;
    if startetMit('xmax:',s) then begin
-     xmax:=round((exprtofloat(st,s)-_xstart)*(_xsteps-1)/(_xstop-_xstart));
+     xmax:=kont2disk('x',exprtofloat(st,s));
      continue;
    end;
    if startetMit('tmin:',s) then begin
-     tmin:=round((exprtofloat(st,s)-_tstart)*(_tsiz-1)/(_tstop-_tstart));
+     tmin:=kont2disk('t',exprtofloat(st,s));
      continue;
    end;
    if startetMit('tmax:',s) then begin
-     tmax:=round((exprtofloat(st,s)-_tstart)*(_tsiz-1)/(_tstop-_tstart));
+     tmax:=kont2disk('t',exprtofloat(st,s));
      continue;
    end;
    if (s='Koordinaten einfügen') and ((_xsteps=1) or (_tsiz=1)) then begin
@@ -2917,26 +2937,26 @@ begin
      case Genauigkeit of
        gSingle:
          for i:=max(0,xmin) to min(_xsteps-1,xmax) do
-           writeln(outf,floattostr(i*(_xstop-_xstart)/_xsteps+_xstart)+separator+floattostr(sWerte.werte[i]));
+           writeln(outf,floattostr(disk2kont('x',i))+separator+floattostr(sWerte.werte[i]));
        gExtended:
          for i:=max(0,xmin) to min(_xsteps-1,xmax) do
-           writeln(outf,floattostr(i*(_xstop-_xstart)/_xsteps+_xstart)+separator+floattostr(eWerte.werte[i]));
+           writeln(outf,floattostr(disk2kont('x',i))+separator+floattostr(eWerte.werte[i]));
      end{of Case};
    2:
      case Genauigkeit of
        gSingle:
          for i:=max(0,tmin) to min(_tsiz-1,tmax) do
-           writeln(outf,floattostr(i*(_tstop-_tstart)/_tsiz+_tstart)+separator+floattostr(sWerte.werte[i]));
+           writeln(outf,floattostr(disk2kont('t',i))+separator+floattostr(sWerte.werte[i]));
        gExtended:
          for i:=max(0,tmin) to min(_tsiz-1,tmax) do
-           writeln(outf,floattostr(i*(_tstop-_tstart)/_tsiz+_tstart)+separator+floattostr(eWerte.werte[i]));
+           writeln(outf,floattostr(disk2kont('t',i))+separator+floattostr(eWerte.werte[i]));
      end{of Case};
    3:
      case Genauigkeit of
        gSingle:
-         writeln(outf,floattostr(_xstart)+separator+floattostr(_tstart)+separator+floattostr(sWerte.werte[0]));
+         writeln(outf,floattostr(disk2kont('x',0))+separator+floattostr(disk2kont('t',0))+separator+floattostr(sWerte.werte[0]));
        gExtended:
-         writeln(outf,floattostr(_xstart)+separator+floattostr(_tstart)+separator+floattostr(sWerte.werte[0]));
+         writeln(outf,floattostr(disk2kont('x',0))+separator+floattostr(disk2kont('t',0))+separator+floattostr(eWerte.werte[0]));
      end{of Case};
  end{of Case};
  close(outf);
@@ -2957,7 +2977,7 @@ begin
  Zeit:=now;
  if not st then begin
    gibAus('erzeuge Lineout ...',3);
-   gibAus('insgesamt: '+floattostr(_xstart)+'-'+floattostr(_xstop)+'x'+floattostr(_tstart)+'-'+floattostr(_tstop),3);
+   gibAus('insgesamt: '+floattostr(Transformationen.xstart)+'-'+floattostr(Transformationen.xstop)+'x'+floattostr(Transformationen.tstart)+'-'+floattostr(Transformationen.tstop),3);
  end;
 
  for b1:=false to true do
@@ -2968,9 +2988,9 @@ begin
  for b1:=false to true do
    if startetMit('(',params) then begin
      s:=erstesArgument(params,',');
-     ab[b1,false]:=max(0,min(_xsteps-1,round((exprtofloat(st,s)-_xstart)/(_xstop-_xstart)*(_xsteps-1))));
+     ab[b1,false]:=kont2disk('x',exprtofloat(st,s));
      s:=erstesArgument(params,')');
-     ab[b1,true]:=max(0,min(_tsiz-1,round((exprtofloat(st,s)-_tstart)/(_tstop-_tstart)*(_tsiz-1))));
+     ab[b1,true]:=kont2disk('t',exprtofloat(st,s));
    end
    else begin
      ab[true,false]:=ab[b1,false];
@@ -3034,7 +3054,6 @@ procedure tWerte.spiegle(threads,tmin,tmax: longint);
 var i:      longint;
     sts:    array of tSpiegelthread;
     fertig: boolean;
-    tmp:    extended;
 begin
   warteaufBeendigungDesLeseThreads;
   setlength(sts,threads);
@@ -3051,9 +3070,7 @@ begin
   until fertig;
   for i:=0 to length(sts)-1 do
     sts[i].free;
-  tmp:=Achsenskala.xstart;
-  Achsenskala.xstart:=Achsenskala.xstop;
-  Achsenskala.xstop:=tmp;
+  Transformationen.AddSpiegelung;
   gibAus('Alle Spiegelthreads fertig!',1);
 end;
 
@@ -3113,14 +3130,14 @@ begin
       gibAus('Finde Werte nicht!',3);
       exit;
     end;
-    if s='xmin' then result:=wertes^[i]._xstart
-    else if s='xmax' then result:=wertes^[i]._xstop
-    else if s='tmin' then result:=wertes^[i]._tstart
-    else if s='tmax' then result:=wertes^[i]._xstop
+    if s='xmin' then result:=wertes^[i].Transformationen.xstart
+    else if s='xmax' then result:=wertes^[i].Transformationen.xstop
+    else if s='tmin' then result:=wertes^[i].Transformationen.tstart
+    else if s='tmax' then result:=wertes^[i].Transformationen.xstop
     else if (s='wmin') or (s='minw') then result:=wertes^[i]._minw
     else if (s='wmax') or (s='maxw') then result:=wertes^[i]._maxw
-    else if s='Breite' then result:=wertes^[i]._xstart-wertes^[i]._xstop
-    else if s='Hoehe' then result:=wertes^[i]._tstart-wertes^[i]._tstop
+    else if s='Breite' then result:=wertes^[i].Transformationen.xstart-wertes^[i].Transformationen.xstop
+    else if s='Hoehe' then result:=wertes^[i].Transformationen.tstart-wertes^[i].Transformationen.tstop
     else gibAus('Kenne Bezeichner '''+s+''' nicht als Eigenschaft von Werten!',3);
     exit;
   end;
@@ -3156,24 +3173,33 @@ end;
 constructor tLogThread.create;
 begin
  inherited create(true);
+ raisedException:=nil;
  freeonterminate:=false;
  fertig:=false;
 end;
 
 destructor tLogThread.destroy;
 begin
+ raisedException.free;
  if not behalteLogs then cleanupLog(ThreadID);
  inherited destroy;
 end;
 
+function tLogThread.rFertig: boolean;
+begin
+ if assigned(raisedException) then
+   raise exception.Create('Fehler innerhalb eines Threads!');
+ result:=_fertig;
+end;
+
 procedure tLogThread.execute;
 begin
  try
    stExecute;
  except
-   on E: Exception do begin
-     DumpExceptionCallStack(E);
-     halt(1);
+   on E: exception do begin
+     dumpExceptionCallStack(E);
+     raisedException:=E;
    end;
  end;
  fertig:=true;
@@ -3196,6 +3222,11 @@ begin
   suspended:=false;
 end;
 
+destructor tLiKoThread.destroy;
+begin
+ inherited destroy;
+end;
+
 procedure tLiKoThread.stExecute;
 var i,j,k:    longint;
     out0,in0: boolean;
@@ -3262,6 +3293,11 @@ begin
   suspended:=false;
 end;
 
+destructor tQuotientThread.destroy;
+begin
+ inherited destroy;
+end;
+
 procedure tQuotientThread.stExecute;
 var i,j:   longint;
     i0,o0: boolean;
@@ -3345,7 +3381,7 @@ end;
 
 // tBilderthread ***************************************************************
 
-constructor tBilderthread.create(i,maxthreads,ibreite,ihoehe,lo,oo,ro,uo: longint; const we: tWerte; xmin,xmax,tmin,tmax: Longint; xzoom,yzoom: extended; Nachbearbeitung: tBearbeitungen; palette: pTPalette; beschri: pTBeschriftungen; rm: boolean);
+constructor tBilderthread.create(i,maxthreads,ibreite,ihoehe,lo,oo,ro,uo: longint; const we: tWerte; xmin,xmax,tmin,tmax: Longint; xzoom,yzoom: extended; Nachbearbeitung: tTransformationen; palette: pTPalette; beschri: pTBeschriftungen; rm: boolean);
 begin
  inherited create;
  beschr:=beschri;
@@ -3385,6 +3421,14 @@ begin
  gibAus('Thread '+inttostr(nummer)+' hat jetzt seinen Speicher.',1);
 end;
 
+destructor tBilderthread.destroy;
+begin
+ setlength(farben,0);
+ setlength(werte,0);
+ setlength(anzahlen,0);
+ inherited destroy;
+end;
+
 procedure tBilderthread.stExecute;
 var i,j,k:   longint;
     wert:    extended;
@@ -3407,8 +3451,7 @@ begin
      if (j>=0) and (j<whoehe) and (i>=0) and (i<gesBreite) then begin       // innerer Pixel
        wert:=(werte[i-max(0,xpmi)+j*wbreite]/anzahlen[i-max(0,xpmi)+j*wbreite]-w._minW)/(w._maxW-w._minW);
        wert:=max(0,min(wert,1));
-       for k:=0 to nb.count-1 do
-         nb[k].anwenden(wert);
+       wert:=nb.transformiereWert(wert);
        farben[i-xpmi+(j+oof)*breite]:=wertZuFarbe(wert,pal);                // farben startet bei Index 0 + 0*breite
      end
      else begin
@@ -3479,14 +3522,6 @@ begin
  fertig:=true;
 end;
 
-destructor tBilderthread.destroy;
-begin
- setlength(farben,0);
- setlength(werte,0);
- setlength(anzahlen,0);
- inherited destroy;
-end;
-
 // tDichteThread ***************************************************************
 
 constructor tDichteThread.create(xmi,xma,tmi,tma: longint; const werte: tWerte);
@@ -3502,6 +3537,11 @@ begin
  suspended:=false;
 end;
 
+destructor tDichteThread.destroy;
+begin
+ inherited destroy;
+end;
+
 procedure tDichteThread.stExecute;
 begin
  gibAus('Dichtethread gestartet!',1);
@@ -3533,6 +3573,11 @@ begin
   suspended:=false;
 end;
 
+destructor tFFTThread.destroy;
+begin
+ inherited destroy;
+end;
+
 procedure tFFTThread.stExecute;
 begin
   gibAus('FFTthread gestartet: '+inttostr(xMi)+'-'+inttostr(xMa)+' '+inttostr(tMi)+'-'+inttostr(tMa)+' ...',1);
@@ -3556,6 +3601,11 @@ begin
   suspended:=false;
 end;
 
+destructor tSpiegelThread.destroy;
+begin
+ inherited destroy;
+end;
+
 procedure tSpiegelThread.stExecute;
 begin
   gibAus('Spiegelthread gestartet: '+inttostr(tMin)+'-'+inttostr(tMax)+' ...',1);
@@ -3580,6 +3630,11 @@ begin
   suspended:=false;
 end;
 
+destructor tFFT2dNBThread.destroy;
+begin
+ inherited destroy;
+end;
+
 procedure tFFT2dNBThread.stExecute;
 begin
   gibAus('FFT2d-Nachbearbeitungsthread gestartet: '+inttostr(xMin)+'-'+inttostr(xMax)+' ...',1);
@@ -3609,6 +3664,11 @@ begin
   suspended:=false;
 end;
 
+destructor tKorrelThread.destroy;
+begin
+ inherited destroy;
+end;
+
 procedure tKorrelThread.stExecute;
 var i,j,k,hl:        longint;
     sus,suc,tmp,pvF: extended;
@@ -3949,13 +4009,13 @@ begin
   if i<0 then exit;
   Schwelle:=w^[i].exprtofloat(false,s);
   if _xmin='' then xmi:=1
-  else xmi:=max(1,min(w^[i]._xsteps-1,round((w^[i].exprtofloat(st,_xmin)-w^[i]._xstart)*(w^[i]._xsteps-1)/(w^[i]._xstop-w^[i]._xstart))));
+  else xmi:=max(1,w^[i].kont2disk('x',w^[i].exprtofloat(st,_xmin)));
   if _xmax='' then xma:=w^[i]._xsteps-1
-  else xma:=max(1,min(w^[i]._xsteps-1,round((w^[i].exprtofloat(st,_xmax)-w^[i]._xstart)*(w^[i]._xsteps-1)/(w^[i]._xstop-w^[i]._xstart))));
+  else xma:=max(1,w^[i].kont2disk('x',w^[i].exprtofloat(st,_xmax)));
   if _tmin='' then tmi:=1
-  else tmi:=max(1,min(w^[i]._tsiz-1,round((w^[i].exprtofloat(st,_tmin)-w^[i]._tstart)*(w^[i]._tsiz-1)/(w^[i]._tstop-w^[i]._tstart))));
+  else tmi:=max(1,w^[i].kont2disk('t',w^[i].exprtofloat(st,_tmin)));
   if _tmax='' then tma:=w^[i]._tsiz-1
-  else tma:=max(1,min(w^[i]._tsiz-1,round((w^[i].exprtofloat(st,_tmax)-w^[i]._tstart)*(w^[i]._tsiz-1)/(w^[i]._tstop-w^[i]._tstart))));
+  else tma:=max(1,w^[i].kont2disk('x',w^[i].exprtofloat(st,_tmax)));
   if st then begin
     result:=true;
     exit;
@@ -4101,6 +4161,11 @@ begin
   suspended:=false;
 end;
 
+destructor tIntegralThread.destroy;
+begin
+ inherited destroy;
+end;
+
 procedure tIntegralThread.stExecute;
 begin
   gibAus('Integralthread gestartet ('+inttostr(xmi)+'-'+inttostr(xma)+'x'+inttostr(tmi)+'-'+inttostr(tma)+') '+
@@ -4142,6 +4207,11 @@ begin
  suspended:=false;
 end;
 
+destructor tSortiereNachYThread.destroy;
+begin
+ inherited destroy;
+end;
+
 procedure tSortiereNachYThread.stExecute;
 begin
  gibAus('Sortierthread gestartet ('+inttostr(vo)+'-'+inttostr(bi)+') -> x'+inttostr(mt)+' ...',1);
@@ -4280,7 +4350,7 @@ end;
 
 // tVerzerrInitThread **********************************************************
 
-constructor tVerzerrInitThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tVerzerrung; zielpositionen: tPointArray; zielgewichte: tExtPointArray; Warn: tWarnstufe);
+constructor tVerzerrInitThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tTransformationen; zielpositionen: tPointArray; zielgewichte: tExtPointArray; Warn: tWarnstufe);
 begin
  inherited create;
  qu:=quelle;
@@ -4302,6 +4372,12 @@ begin
  suspended:=false;
 end;
 
+destructor tVerzerrInitThread.destroy;
+begin
+ setlength(ZAs,0);
+ inherited destroy;
+end;
+
 procedure tVerzerrInitThread.stExecute;
 begin
  gibAus('VerzerrInitThread gestartet ('+inttostr(xMi)+'-'+inttostr(xMa)+'/'+inttostr(tMi)+'-'+inttostr(tMa)+')',1);
@@ -4310,15 +4386,9 @@ begin
  fertig:=true;
 end;
 
-destructor tVerzerrInitThread.destroy;
-begin
- setlength(ZAs,0);
- inherited destroy;
-end;
-
 // tVerzerrThread **************************************************************
 
-constructor tVerzerrThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tBearbeitungen);
+constructor tVerzerrThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tTransformationen);
 begin
  inherited create;
  qu:=quelle;
@@ -4336,6 +4406,11 @@ begin
  suspended:=false;
 end;
 
+destructor tVerzerrThread.destroy;
+begin
+ inherited destroy;
+end;
+
 procedure tVerzerrThread.stExecute;
 var sw: pTLLWerteSingle;
     ew: pTLLWerteDouble;
@@ -4388,7 +4463,7 @@ begin
  result:=false;
 end;
 
-function erzeugeLegende(st: boolean; var f: tInputfile; datei: string; Qu: tWerte; minDichte,maxDichte: extended; nb: tBearbeitungen; pal: pTPalette): boolean;
+function erzeugeLegende(st: boolean; var f: tInputfile; datei: string; Qu: tWerte; minDichte,maxDichte: extended; nb: tTransformationen; pal: pTPalette): boolean;
 var s:                                  string;
     breite,hoehe,i,j,k,lo,ro,oo,uo,
     schriftgroesze:                     longint;
@@ -4485,9 +4560,9 @@ begin
          beschriftungsschritte[0].bis:=maxDichte*minDichte;
          delete(s,1,pos(' ',s));
          for i:=0 to nb.count-1 do
-           if nb[i].typ=btLog then begin
-             if nb[i].parameter[0]<>minDichte then begin
-               gibAus('Die minimale Dichte der logarithmischen Farbskala ('+myfloattostr(minDichte)+') und der logarithmischen Nachbearbeitung ('+myfloattostr(nb[i].parameter[0])+') stimmen nicht überein!',3);
+           if nb[i] is tWerteLogTransformation then begin
+             if (nb[i] as tWerteLogTransformation).logMin<>minDichte then begin
+               gibAus('Die minimale Dichte der logarithmischen Farbskala ('+myfloattostr(minDichte)+') und der logarithmischen Nachbearbeitung ('+myfloattostr((nb[i] as tWerteLogTransformation).logMin)+') stimmen nicht überein!',3);
                exit;
              end;
            minDichte:=minDichte*maxDichte;
@@ -4556,12 +4631,8 @@ begin
  end;
 
  if lineareFarbe then
-   for i:=0 to length(beschriftungen)-1 do begin
-     wert:=beschriftungen[i].position;
-     for j:=0 to nb.count-1 do
-       nb[j].anwenden(wert);
-     beschriftungen[i].position:=wert;
-   end;
+   for i:=0 to length(beschriftungen)-1 do
+     beschriftungen[i].position:=nb.transformiereWert(beschriftungen[i].position);
  for i:=0 to length(beschriftungen)-1 do
    beschriftungen[i].position:=beschriftungen[i].position*(hoehe+byte(waagerecht)*(breite-hoehe));
 
@@ -4582,8 +4653,7 @@ begin
  for i:=0 to length(farben)-1 do begin
    wert:=i/length(farben);
    if not lineareFarbe then
-     for j:=0 to nb.count-1 do
-       nb[j].anwenden(wert);
+     wert:=nb.transformiereWert(wert);
    farben[i]:=wertZuFarbe(wert,pal^.farben);
  end;
  assign(img,datei);