wieder lauffähig

1 files changed, 694 insertions, 298 deletions

diff --git a/typenunit.pas b/typenunit.pas
index c8bb670..70d1bb8 100644
--- a/typenunit.pas
+++ b/typenunit.pas
@@ -211,6 +211,8 @@ type
     property inhalt: string
       read _inhalt
       write wInhalt;
+    constructor create;
+    destructor destroy; override;
     function strich: longint;
     function links: longint;
     function oben: longint;
@@ -225,8 +227,34 @@ type
     constructor create;
     destructor destroy; override;
   end;
-  tVerzerrung = class
+  tTransformation = class
+    // eine generische Transformation von Werten oder Koordinaten
+    // selbst nicht zum Instanziieren gedacht
+    function transformiereKoordinaten(x,y: longint): tExtPoint; overload;
+    function transformiereKoordinaten(p: tExtPoint): tExtPoint; virtual; overload;
+    function transformiereWert(x: extended): extended; virtual;
+    function xsteps_tsiz(xs_ts: tPoint): tPoint; virtual;
+    function dumpParams: string; virtual;
+  end;
+  tKoordinatenTransformation = class (tTransformation)
+    // eine generische Transformation der Koordinaten
+    // selbst nicht zum Instanziieren gedacht
+  end;
+  tFFTTransformation = class (tKoordinatenTransformation)
+    // repräsentiert die Transformation der Koordinaten bei einer FFT
+    horizontal,vertikal: boolean;
+    constructor create; overload;
+    constructor create(original: tFFTTransformation); overload;
+    function dumpParams: string; override;
+  end;
+  tSpiegelungsTransformation = class (tKoordinatenTransformation)
+    // repräsentiert die horizontale Spiegelung der Koordinaten
+    constructor create;
+    function dumpParams: string; override;
+  end;
+  tKonkreteKoordinatenTransformation = class (tKoordinatenTransformation)
   private
+    // eine konkrete Verzerrung der Koordinaten (linearer + logarithmischer + exponentieller Anteil)
     function findeLineareParameter(syntaxtest: boolean; auszenSkala: char; s: string; xscale,yscale: extended; var off,xl,yl: extended; ueberschreiben: boolean; etf: tExprToFloat): boolean;
   public
     lnInt,                                         // Faktoren in den ln-Argumenten
@@ -236,78 +264,135 @@ type
     lnFak,                                         // Vorfaktoren der Logarithmen
     lnOff,                                         // Offset der ln-Argumente
     expFak: array['x'..'y'] of extended;           // Vorfaktoren der Exponentialfunktionen
-    constructor create;
-    constructor create(original: tVerzerrung);
-    function ziel(x,y: longint): tExtPoint; overload;
-    function ziel(p: tExtPoint): tExtPoint; overload;
+    constructor create; overload;
+    constructor create(original: tKonkreteKoordinatenTransformation); overload;
+    function transformiereKoordinaten(p: tExtPoint): tExtPoint; override; overload;
     function initAbbildung(syntaxtest: boolean; s: string; xscale,yscale: extended; etf: tExprToFloat): boolean;
     procedure berechneZielausdehnung(xsteps,tsiz: longint; out grenzen: t2x2Longint);
-    function dumpParams: string;
+    function xsteps_tsiz(xs_ts: tPoint): tPoint; override;
+    function dumpParams: string; override;
   end;
-  tVerzerrungen = class
-  private
-    Schritte: array of tVerzerrung;
-    function gibInhalt(ii: longint): tVerzerrung;
-    procedure nimmInhalt(ii: longint; inh: tVerzerrung);
-  public
-    property inhalt[ii: longint]: tVerzerrung
-      read gibInhalt
-      write nimmInhalt; default;
+  tKoordinatenAusschnitt = class (tKoordinatenTransformation)
+    xmin,xmax,tmin,tmax: longint;
     constructor create; overload;
-    constructor create(original: tVerzerrungen); overload;
-    destructor destroy; override;
-    function count: longint;
-    function last: tVerzerrung;
-    procedure clear;
-    procedure addNew;
-    procedure add(inh: tVerzerrung);
-    procedure addAusschnitt(xsteps,tsiz,xmin,xmax,tmin,tmax: longint);
-    procedure append(inhs: tVerzerrungen);
+    constructor create(original: tKoordinatenAusschnitt); overload;
+    function xsteps_tsiz(xs_ts: tPoint): tPoint; override;
+    function dumpParams: string; override;
   end;
   tBearbeitungstyp = (btUnbekannt,btKnick,btLog,btAbsLog,btAbs);
-  tBearbeitung = class
-    typ: tBearbeitungstyp;
+  tWerteTransformation = class (tTransformation)
+    // eine generische Transformation der Werte
+    // selbst nicht zum Instanziieren gedacht
+  end;
+  tWerteKnickTransformation = class (tWerteTransformation)
+    // Werte knicken
     parameter: tExtendedArray;
-    constructor create;
-    constructor create(original: tBearbeitung);
+    constructor create; overload;
+    constructor create(original: tWerteKnickTransformation); overload;
     destructor destroy; override;
-    procedure anwenden(var x: extended);
-    function init(st: boolean; s: string; f: tInputFile; etf: tExprToFloat): boolean;
+    function transformiereWert(x: extended): extended; override;
+    function dumpParams: string; override;
+  end;
+  tWerteLogTransformation = class (tWerteTransformation)
+    // Werte logarithmieren
+    logMin: extended;
+    constructor create; overload;
+    constructor create(original: tWerteLogTransformation); overload;
+    function transformiereWert(x: extended): extended; override;
+    function dumpParams: string; override;
+  end;
+  tWerteLogAbsTransformation = class (tWerteTransformation)
+    // Wertebeträge logarithmieren
+    logSkala: extended;
+    constructor create; overload;
+    constructor create(original: tWerteLogAbsTransformation); overload;
+    function transformiereWert(x: extended): extended; override;
+    function dumpParams: string; override;
   end;
-  tBearbeitungen = class
+  tWerteAbsTransformation = class (tWerteTransformation)
+    // Werte betragen
+    constructor create;
+    function transformiereWert(x: extended): extended; override;
+    function dumpParams: string; override;
+  end;
+  tTransformationen = class
   private
-    Schritte: array of tBearbeitung;
-    function gibInhalt(ii: longint): tBearbeitung;
-    procedure nimmInhalt(ii: longint; inh: tBearbeitung);
+    // merkt sich, was mit den Werten und Koordinaten nach einem festen Punkt (dem Einlesen) passiert ist,
+    // sodass man immer nachvollziehen kann, welcher Punkt woher kam und wie verarbeitet wurde.
+    // -> sinnvolle Achsenbezeichnungen und Legenden
+    Schritte: array of tTransformation;
+    _xstart,_xstop,_tstart,_tstop,_wmin,_wmax: extended;
+    _xsteps,_tsiz:                             longint;
+    function gibInhalt(ii: longint): tTransformation;
+    procedure nimmInhalt(ii: longint; inh: tTransformation);
+    function rXstart: extended;
+    procedure wXstart(x: extended);
+    function rXstop: extended;
+    procedure wXstop(x: extended);
+    function rTstart: extended;
+    procedure wTstart(t: extended);
+    function rTstop: extended;
+    procedure wTstop(t: extended);
+    function rWmin: extended;
+    procedure wWmin(w: extended);
+    function rWmax: extended;
+    procedure wWmax(w: extended);
+    function rXsteps: longint;
+    procedure wXsteps(x: longint);
+    function rTsiz: longint;
+    procedure wTsiz(t: longint);
+    function xsteps_tsiz: tPoint;
   public
-    property inhalt[ii: longint]: tBearbeitung
+    property xstart: extended
+      read rXstart
+      write wXstart;
+    property xstop: extended
+      read rXstop
+      write wXstop;
+    property tstart: extended
+      read rTstart
+      write wTstart;
+    property tstop: extended
+      read rTstop
+      write wTstop;
+    property wmin: extended
+      read rWmin
+      write wWmin;
+    property wmax: extended
+      read rWmax
+      write wWmax;
+    property xsteps: longint
+      read rXsteps
+      write wXsteps;
+    property tsiz: longint
+      read rTsiz
+      write wTsiz;
+    property inhalt[ii: longint]: tTransformation
       read gibInhalt
       write nimmInhalt; default;
     constructor create; overload;
-    constructor create(original: tBearbeitungen); overload;
+    constructor create(original: tTransformationen); overload;
     destructor destroy; override;
-    procedure clear;
+    function kopiereVon(original: tTransformationen): boolean;
     function count: longint;
-    function last: tBearbeitung;
-    procedure addNew;
-    procedure add(inh: tBearbeitung);
-    procedure append(inhs: tBearbeitungen);
-  end;
-  tAchsenskala = class (tVerzerrungen)
-    xstart,xstop,tstart,tstop: extended;
-    xsteps,tsiz:               longint;
-    constructor create; overload;
-    constructor create(original: tAchsenskala); overload;
-    destructor destroy; override;
-    procedure kopiereVon(original: tAchsenskala);
-    function gibPosition(lage: tLage; x: extended): extended;
-  end;
-  tWerteskala = class (tBearbeitungen)
-    wmin,wmax: extended;
-    constructor create; overload;
-    constructor create(original: tWerteskala); overload;
-    destructor destroy; override;
-    procedure kopiereVon(original: tWerteskala);
+    function kCount: longint;
+    function wCount: longint;
+    function last: tTransformation;
+    procedure clear;
+    procedure clearWerte;
+    procedure addFFT(hor,ver: boolean);
+    procedure AddSpiegelung;
+    function add(inh: tTransformation): boolean; overload;
+    function add(st: boolean; s: string; f: tInputFile; etf: tExprToFloat): boolean; overload;
+    function add(syntaxtest: boolean; s: string; xscale,yscale: extended; etf: tExprToFloat): boolean; overload;
+    procedure addAusschnitt(xmin,xmax,tmin,tmax: longint);
+    function append(inhs: tTransformationen): boolean;
+    function transformiereKoordinaten(lage: tLage; x: extended): extended; overload;
+    function transformiereKoordinaten(x,y: extended): tExtPoint; overload;
+    function transformiereKoordinaten(p: tExtPoint): tExtPoint; overload;
+    function transformiereWert(x: extended): extended;
+    function dumpParams: string;
+    procedure berechneZielausdehnung(out grenzen: t2x2Longint);
   end;
 
 function ZeitDarstellen(t: extended): string;
@@ -326,13 +411,15 @@ procedure myDebugLnThreadLog(s: string);
 function belegterSpeicher: longint;
 procedure cleanupLogs;
 procedure cleanupLog(tid: PtrUInt);
-procedure DumpExceptionCallStack(E: Exception);
+procedure dumpExceptionCallStack(E: Exception);
 function startetMit(start: string; var s: string): boolean;
 function endetMit(ende: string; var s: string): boolean;
 function trimAll(s: string): string;
 function erstesArgument(var s: string): string; overload;
 function erstesArgument(var s: string; Trenner: string): string; overload;
 function mydatetimetostr(t: tDateTime): string;
+function tExtPointToStr(p: tExtPoint): string;
+function tPointToStr(p: tPoint): string;
 
 implementation
 
@@ -736,6 +823,18 @@ end;
 
 // tBeschriftung ***************************************************************
 
+constructor tBeschriftung.create;
+begin
+ inherited create;
+ _inhalt:='';
+end;
+
+destructor tBeschriftung.destroy;
+begin
+ _inhalt:='';
+ inherited destroy;
+end;
+
 function tBeschriftung.strich: longint;
 begin
  result:=round(position);
@@ -923,9 +1022,74 @@ begin
  setlength(buf,0);
 end;
 
-// tVerzerrung *****************************************************************
+// tTransformation *************************************************************
+
+function tTransformation.transformiereKoordinaten(x,y: longint): tExtPoint;
+var p: tExtPoint;
+begin
+ p.x:=x;
+ p.y:=y;
+ result:=transformiereKoordinaten(p);
+end;
+
+function tTransformation.transformiereKoordinaten(p: tExtPoint): tExtPoint;
+begin
+ result:=p;
+end;
+
+function tTransformation.transformiereWert(x: extended): extended;
+begin
+ result:=x;
+end;
+
+function tTransformation.xsteps_tsiz(xs_ts: tPoint): tPoint;
+begin
+ result:=xs_ts;
+end;
+
+function tTransformation.dumpParams: string;
+begin
+ result:='';
+end;
+
+// tFFTTransformation **********************************************************
+
+constructor tFFTTransformation.create;
+begin
+ inherited create;
+ horizontal:=false;
+ vertikal:=false;
+end;
+
+constructor tFFTTransformation.create(original: tFFTTransformation);
+begin
+ inherited create;
+ horizontal:=original.horizontal;
+ vertikal:=original.vertikal;
+end;
+
+function tFFTTransformation.dumpParams: string;
+begin
+ result:='FFT: ';
+ if horizontal then result:=result+'h';
+ if vertikal then result:=result+'v';
+end;
+
+// tSpiegelungsTransformation **************************************************
+
+constructor tSpiegelungsTransformation.create;
+begin
+ inherited create;
+end;
+
+function tSpiegelungsTransformation.dumpParams: string;
+begin
+ result:='horizontale Spiegelung';
+end;
+
+// tKonkreteKoordinatenTransformation ******************************************
 
-constructor tVerzerrung.create;
+constructor tKonkreteKoordinatenTransformation.create;
 var c,d: char;
 begin
  for c:='x' to 'y' do begin
@@ -941,7 +1105,7 @@ begin
  end;
 end;
 
-constructor tVerzerrung.create(original: tVerzerrung);
+constructor tKonkreteKoordinatenTransformation.create(original: tKonkreteKoordinatenTransformation);
 var c,d: char;
 begin
  for c:='x' to 'y' do begin
@@ -957,7 +1121,7 @@ begin
  end;
 end;
 
-function tVerzerrung.findeLineareParameter(syntaxtest: boolean; auszenSkala: char; s: string; xscale,yscale: extended; var off,xl,yl: extended; ueberschreiben: boolean; etf: tExprToFloat): boolean;
+function tKonkreteKoordinatenTransformation.findeLineareParameter(syntaxtest: boolean; auszenSkala: char; s: string; xscale,yscale: extended; var off,xl,yl: extended; ueberschreiben: boolean; etf: tExprToFloat): boolean;
 var t:   string;
     c:   char;
     tmp: extended;
@@ -1009,15 +1173,7 @@ begin
  result:=true;
 end;
 
-function tVerzerrung.ziel(x,y: longint): tExtPoint;
-var p: tExtPoint;
-begin
- p.x:=x;
- p.y:=y;
- result:=ziel(p);
-end;
-
-function tVerzerrung.ziel(p: tExtPoint): tExtPoint;
+function tKonkreteKoordinatenTransformation.transformiereKoordinaten(p: tExtPoint): tExtPoint;
 begin
  result.x:=off['x'];
  result.y:=off['y'];
@@ -1035,7 +1191,7 @@ begin
    result.y + expFak['y'] * exp( p.x*expExp['y','x'] + p.y*expExp['y','y']);
 end;
 
-function tVerzerrung.initAbbildung(syntaxtest: boolean; s: string; xscale,yscale: extended; etf: tExprToFloat): boolean;
+function tKonkreteKoordinatenTransformation.initAbbildung(syntaxtest: boolean; s: string; xscale,yscale: extended; etf: tExprToFloat): boolean;
 var c,d:   char;
     i:     longint;
     t,u,v: string;
@@ -1102,7 +1258,7 @@ begin
  result:=true;
 end;
 
-function tVerzerrung.dumpParams: string;
+function tKonkreteKoordinatenTransformation.dumpParams: string;
 var c,d: char;
 begin
  result:='';
@@ -1133,267 +1289,368 @@ begin
  delete(result,1,2);
 end;
 
-procedure tVerzerrung.berechneZielausdehnung(xsteps,tsiz: longint; out grenzen: t2x2Longint);
+procedure tKonkreteKoordinatenTransformation.berechneZielausdehnung(xsteps,tsiz: longint; out grenzen: t2x2Longint);
 var Rand:   array of tExtPoint;
     i:      longint;
 begin
  setlength(Rand,(xsteps+tsiz-2)*2);
  for i:=0 to xsteps-1 do
-   Rand[i]:=ziel(i,0);
+   Rand[i]:=transformiereKoordinaten(i,0);
  for i:=0 to xsteps-1 do
-   Rand[xsteps+i]:=ziel(i,tsiz-1);
+   Rand[xsteps+i]:=transformiereKoordinaten(i,tsiz-1);
  for i:=0 to tsiz-3 do
-   Rand[2*xsteps+i]:=ziel(0,i+1);
+   Rand[2*xsteps+i]:=transformiereKoordinaten(0,i+1);
  for i:=0 to tsiz-3 do
-   Rand[2*xsteps+tsiz-2+i]:=ziel(xsteps-1,i+1);
+   Rand[2*xsteps+tsiz-2+i]:=transformiereKoordinaten(xsteps-1,i+1);
  grenzen['x','x']:=floor(rand[0].x);
- grenzen['x','y']:=ceil(rand[0].x);
+ grenzen['x','y']:=floor(rand[0].x)+1;
  grenzen['y','x']:=floor(rand[0].y);
- grenzen['y','y']:=ceil(rand[0].y);
+ grenzen['y','y']:=floor(rand[0].y)+1;
  for i:=0 to length(rand)-1 do begin
    grenzen['x','x']:=min(grenzen['x','x'],floor(rand[i].x));
-   grenzen['x','y']:=max(grenzen['x','y'],ceil(rand[i].x));
+   grenzen['x','y']:=max(grenzen['x','y'],floor(rand[i].x)+1);
    grenzen['y','x']:=min(grenzen['y','x'],floor(rand[i].y));
-   grenzen['y','y']:=max(grenzen['y','y'],ceil(rand[i].y));
+   grenzen['y','y']:=max(grenzen['y','y'],floor(rand[i].y)+1);
  end;
 end;
 
-// tVerzerrungen ***************************************************************
+function tKonkreteKoordinatenTransformation.xsteps_tsiz(xs_ts: tPoint): tPoint;
+var gr: t2x2Longint;
+begin
+ berechneZielausdehnung(xs_ts.x,xs_ts.y,gr);
+ result.x:=gr['x','y']-gr['x','x']+1;
+ result.y:=gr['y','y']-gr['y','x']+1;
+end;
+
+// tKoordinatenAusschnitt ******************************************************
 
-constructor tVerzerrungen.create;
+constructor tKoordinatenAusschnitt.create;
 begin
  inherited create;
- setlength(Schritte,0);
+ xmin:=0;
+ xmax:=0;
+ tmin:=0;
+ tmax:=0;
 end;
 
-constructor tVerzerrungen.create(original: tVerzerrungen);
+constructor tKoordinatenAusschnitt.create(original: tKoordinatenAusschnitt);
 begin
  inherited create;
- setlength(Schritte,0);
- append(original);
+ xmin:=original.xmin;
+ xmax:=original.xmax;
+ tmin:=original.tmin;
+ tmax:=original.tmax;
 end;
 
-destructor tVerzerrungen.destroy;
-var i: longint;
+function tKoordinatenAusschnitt.xsteps_tsiz(xs_ts: tPoint): tPoint;
 begin
- for i:=0 to length(Schritte)-1 do
-   if assigned(Schritte[i]) then
-     Schritte[i].free;
- setlength(Schritte,0);
- inherited destroy;
+ result.x:=max(xmin,min(xs_ts.x,xmax+1))-xmin;
+ result.y:=max(tmin,min(xs_ts.y,tmax+1))-tmin;
 end;
 
-function tVerzerrungen.gibInhalt(ii: longint): tVerzerrung;
+function tKoordinatenAusschnitt.dumpParams: string;
 begin
- result:=Schritte[ii];
+ result:='Koordinatenausschnitt: '+inttostr(xmin)+'..'+inttostr(xmax)+' x '+inttostr(tmin)+'..'+inttostr(tmax);
 end;
 
-procedure tVerzerrungen.nimmInhalt(ii: longint; inh: tVerzerrung);
+// tWerteKnickTransformation ***************************************************
+
+constructor tWerteKnickTransformation.create;
 begin
- Schritte[ii]:=inh;
+ inherited create;
+ setlength(parameter,0);
 end;
 
-function tVerzerrungen.count: longint;
+constructor tWerteKnickTransformation.create(original: tWerteKnickTransformation);
+var i: longint;
 begin
- result:=length(Schritte);
+ inherited create;
+ setlength(parameter,length(original.parameter));
+ for i:=0 to length(parameter)-1 do
+   parameter[i]:=original.parameter[i];
 end;
 
-function tVerzerrungen.last: tVerzerrung;
+destructor tWerteKnickTransformation.destroy;
 begin
- result:=Schritte[length(Schritte)-1];
+ setlength(parameter,0);
+ inherited destroy;
 end;
 
-procedure tVerzerrungen.clear;
+function tWerteKnickTransformation.transformiereWert(x: extended): extended;
 var i: longint;
 begin
- for i:=0 to length(Schritte)-1 do
-   if assigned(Schritte[i]) then
-     Schritte[i].free;
- setlength(Schritte,0);
+ if x>=parameter[length(parameter)-2] then begin
+   result:=parameter[length(parameter)-1];
+   exit;
+ end;
+ i:=0;
+ while (i<length(parameter)-2) and (x>=parameter[i+2]) do
+   inc(i,2);
+ result:=x-parameter[i];
+ result:=result/(parameter[i+2]-parameter[i]);
+ result:=parameter[i+1]+result*(parameter[i+3]-parameter[i+1])
 end;
 
-procedure tVerzerrungen.addNew;
+function tWerteKnickTransformation.dumpParams: string;
+var i: longint;
 begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)]:=tVerzerrung.create;
+ result:='Knick:';
+ for i:=0 to length(parameter) div 2 - 1 do
+   result:=result + ' (' + floattostr(parameter[2*i])+';'+floattostr(parameter[2*i+1])+')';
 end;
 
-procedure tVerzerrungen.add(inh: tVerzerrung);
+// tWerteLogTransformation *****************************************************
+
+constructor tWerteLogTransformation.create;
 begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tVerzerrung.create(inh);
+ inherited create;
+ logMin:=0.1;
 end;
 
-procedure tVerzerrungen.addAusschnitt(xsteps,tsiz,xmin,xmax,tmin,tmax: longint);
+constructor tWerteLogTransformation.create(original: tWerteLogTransformation);
 begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tVerzerrung.create;
- last.off['x']:=-xmin*last.lin['x','x'];  // man muss sich nur die Verschiebung merken,
- last.off['y']:=-tmin*last.lin['y','y'];  // das Abschneiden kommt einfach durch die kleineren tsiz und xsteps zustande
+ inherited create;
+ logMin:=original.logMin;
 end;
 
-procedure tVerzerrungen.append(inhs: tVerzerrungen);
-var i: longint;
+function tWerteLogTransformation.transformiereWert(x: extended): extended;
 begin
- for i:=0 to inhs.count-1 do
-   add(inhs[i]);
+ result:=ln(max(x/logMin,1))/ln(max(1/logMin,1));
+end;
+
+function tWerteLogTransformation.dumpParams: string;
+begin
+ result:='Logarithmus: '+floattostr(logMin);
 end;
 
-// tBearbeitung ****************************************************************
+// tWerteLogAbsTransformation **************************************************
 
-constructor tBearbeitung.create;
+constructor tWerteLogAbsTransformation.create;
 begin
  inherited create;
- typ:=btUnbekannt;
- setlength(parameter,0);
+ logSkala:=0.1;
 end;
 
-constructor tBearbeitung.create(original: tBearbeitung);
-var i: longint;
+constructor tWerteLogAbsTransformation.create(original: tWerteLogAbsTransformation);
 begin
  inherited create;
- typ:=original.typ;
- setlength(parameter,length(original.parameter));
- for i:=0 to length(parameter)-1 do
-   parameter[i]:=original.parameter[i];
+ logSkala:=original.logSkala;
 end;
 
-destructor tBearbeitung.destroy;
+function tWerteLogAbsTransformation.transformiereWert(x: extended): extended;
 begin
- setlength(parameter,0);
- inherited destroy;
+ result:=(1+sign(x-0.5)*ln(logSkala*abs(x-0.5)+1)/ln(logSkala*0.5+1))/2;
 end;
 
-procedure tBearbeitung.anwenden(var x: extended);
-var i: longint;
+function tWerteLogAbsTransformation.dumpParams: string;
 begin
- case typ of
-   btKnick: begin
-     if x>=parameter[length(parameter)-2] then begin
-       x:=parameter[length(parameter)-1];
-       exit;
-     end;
-     i:=0;
-     while (i<length(parameter)-2) and (x>=parameter[i+2]) do
-       inc(i,2);
-     x:=x-parameter[i];
-     x:=x/(parameter[i+2]-parameter[i]);
-     x:=parameter[i+1]+x*(parameter[i+3]-parameter[i+1])
-   end;
-   btLog: begin
-     x:=ln(max(x/parameter[0],1))/ln(max(1/parameter[0],1));
-   end;
-   btAbsLog: begin
-     x:=(1+sign(x-0.5)*ln(parameter[0]*abs(x-0.5)+1)/ln(parameter[0]*0.5+1))/2;
-   end;
-   btAbs:
-     x:=2*abs(x-0.5);
- end{of case};
+ result:='Betragslogarithmus: '+floattostr(logSkala);
 end;
 
-function tBearbeitung.init(st: boolean; s: string; f: tInputFile; etf: tExprToFloat): boolean;
-var i: longint;
+// tWerteAbsTransformation *****************************************************
+
+constructor tWerteAbsTransformation.create;
 begin
- result:=false;
- if s='Knick' then begin
-   typ:=btKnick;
-   setlength(parameter,2);
-   parameter[0]:=0;
-   parameter[1]:=0;
-   repeat
-     if not f.gibZeile(s) then begin
-       gibAus('Unerwartetes Dateiende in '''+paramstr(1)+'''!',3);
-       exit;
-     end;
-     if s='Ende' then begin
-       for i:=0 to length(parameter)-1 do
-         if odd(i) then
-           parameter[i]:=
-             parameter[i]/
-               (length(parameter) div 2);
-       setlength(parameter,length(parameter)+2);
-       parameter[length(parameter)-2]:= 1;
-       parameter[length(parameter)-1]:= 1;
-       continue;
-     end;
-     setlength(parameter,length(parameter)+2);
-     s:=s+' ';
-     parameter[length(parameter)-2]:=
-       etf(st,copy(s,1,pos(' ',s)-1));
-     delete(s,1,pos(' ',s));
-     s:=trim(s);
-     if s='' then s:=inttostr(length(parameter) div 2 - 1);
-     parameter[length(parameter)-1]:=
-       etf(st,s);
-   until false;
-   result:=true;
-   exit;
- end;
- if startetMit('Log:',s) then begin
-   typ:=btLog;
-   setlength(parameter,1);
-   parameter[0]:=etf(st,s);
-   result:=true;
-   exit;
- end;
- if startetMit('AbsLog:',s) then begin
-   typ:=btAbsLog;
-   setlength(parameter,1);
-   parameter[0]:=etf(st,s);
-   result:=true;
-   exit;
- end;
- if s='Abs' then begin
-   typ:=btAbs;
-   setlength(parameter,0);
-   result:=true;
-   exit;
- end;
- gibAus('Kenne Nachbearbeitungsmethode '''+s+''' nicht!',3);
+ inherited create;
 end;
 
-// tBearbeitungen **************************************************************
+function tWerteAbsTransformation.transformiereWert(x: extended): extended;
+begin
+ result:=2*abs(x-0.5);
+end;
 
-constructor tBearbeitungen.create;
+function tWerteAbsTransformation.dumpParams: string;
+begin
+ result:='Betrag';
+end;
+
+// tTransformationen ***********************************************************
+
+constructor tTransformationen.create;
 begin
  inherited create;
  setlength(Schritte,0);
 end;
 
-constructor tBearbeitungen.create(original: tBearbeitungen);
+constructor tTransformationen.create(original: tTransformationen);
 begin
  inherited create;
  setlength(Schritte,0);
- append(original);
+ if not kopiereVon(original) then
+   halt(1);
 end;
 
-destructor tBearbeitungen.destroy;
+destructor tTransformationen.destroy;
+var i: longint;
 begin
+ for i:=0 to length(Schritte)-1 do
+   if assigned(Schritte[i]) then
+     Schritte[i].free;
  setlength(Schritte,0);
  inherited destroy;
 end;
 
-function tBearbeitungen.gibInhalt(ii: longint): tBearbeitung;
+function tTransformationen.gibInhalt(ii: longint): tTransformation;
 begin
  result:=Schritte[ii];
 end;
 
-procedure tBearbeitungen.nimmInhalt(ii: longint; inh: tBearbeitung);
+procedure tTransformationen.nimmInhalt(ii: longint; inh: tTransformation);
 begin
  Schritte[ii]:=inh;
 end;
 
-function tBearbeitungen.count: longint;
+function tTransformationen.rXstart: extended;
+begin
+ result:=_xstart;
+end;
+
+procedure tTransformationen.wXstart(x: extended);
+begin
+ if kCount>0 then begin
+   gibAus('Will xstart schreiben, aber der kCount ist '+inttostr(kCount),3);
+   raise exception.create('Will xstart schreiben, aber der kCount ist '+inttostr(kCount));
+ end;
+ _xstart:=x;
+end;
+
+function tTransformationen.rXstop: extended;
+begin
+ result:=_xstop;
+end;
+
+procedure tTransformationen.wXstop(x: extended);
+begin
+ if kCount>0 then begin
+   gibAus('Will xstop schreiben, aber der kCount ist '+inttostr(kCount),3);
+   raise exception.create('Will xstop schreiben, aber der kCount ist '+inttostr(kCount));
+ end;
+ _xstop:=x;
+end;
+
+function tTransformationen.rTstart: extended;
+begin
+ result:=_tstart;
+end;
+
+procedure tTransformationen.wTstart(t: extended);
+begin
+ if kCount>0 then begin
+   gibAus('Will tstart schreiben, aber der kCount ist '+inttostr(kCount),3);
+   raise exception.create('Will tstart schreiben, aber der kCount ist '+inttostr(kCount));
+ end;
+ _tstart:=t;
+end;
+
+function tTransformationen.rTstop: extended;
+begin
+ result:=_tstop;
+end;
+
+procedure tTransformationen.wTstop(t: extended);
+begin
+ if kCount>0 then begin
+   gibAus('Will tstop schreiben, aber der kCount ist '+inttostr(kCount),3);
+   raise exception.create('Will tstop schreiben, aber der kCount ist '+inttostr(kCount));
+ end;
+ _tstop:=t;
+end;
+
+function tTransformationen.rWmin: extended;
+begin
+ result:=_wmin;
+end;
+
+procedure tTransformationen.wWmin(w: extended);
+begin
+ (*if wCount>0 then begin
+   gibAus('Will wmin schreiben, aber der wCount ist '+inttostr(wCount),3);
+   raise exception.create('Will wmin schreiben, aber der wCount ist '+inttostr(wCount));
+ end;*)
+ _wmin:=w;
+end;
+
+function tTransformationen.rWmax: extended;
+begin
+ result:=_wmax;
+end;
+
+procedure tTransformationen.wWmax(w: extended);
+begin
+ (*if wCount>0 then begin
+   gibAus('Will wmax schreiben, aber der wCount ist '+inttostr(wCount),3);
+   raise exception.create('Will wmax schreiben, aber der wCount ist '+inttostr(wCount));
+ end;*)
+ _wmax:=w;
+end;
+
+function tTransformationen.rXsteps: longint;
+begin
+ result:=xsteps_tsiz.x;
+end;
+
+procedure tTransformationen.wXsteps(x: longint);
+begin
+ if kCount>0 then begin
+   gibAus('Will xsteps schreiben, aber der kCount ist '+inttostr(kCount),3);
+   raise exception.create('Will xsteps schreiben, aber der kCount ist '+inttostr(kCount));
+ end;
+ _xsteps:=x;
+end;
+
+function tTransformationen.rTsiz: longint;
+begin
+ result:=xsteps_tsiz.y;
+end;
+
+function tTransformationen.xsteps_tsiz: tPoint;
+var i:  longint;
+begin
+ result.x:=_xsteps;
+ result.y:=_tsiz;
+ for i:=0 to count-1 do
+   if inhalt[i] is tKoordinatenTransformation then
+     result:=(inhalt[i] as tKoordinatenTransformation).xsteps_tsiz(result);
+end;
+
+procedure tTransformationen.wTsiz(t: longint);
+begin
+ if kCount>0 then begin
+   gibAus('Will tsiz schreiben, aber der kCount ist '+inttostr(kCount),3);
+   raise exception.create('Will tsiz schreiben, aber der kCount ist '+inttostr(kCount));
+ end;
+ _tsiz:=t;
+end;
+
+function tTransformationen.count: longint;
 begin
  result:=length(Schritte);
 end;
 
-function tBearbeitungen.last: tBearbeitung;
+function tTransformationen.kCount: longint;
+var i: longint;
+begin
+ result:=0;
+ for i:=0 to count-1 do
+   if Inhalt[i] is tKoordinatenTransformation then
+     inc(result);
+end;
+
+function tTransformationen.wCount: longint;
+var i: longint;
+begin
+ result:=0;
+ for i:=0 to count-1 do
+   if Inhalt[i] is tWerteTransformation then
+     inc(result);
+end;
+
+function tTransformationen.last: tTransformation;
 begin
  result:=gibInhalt(count-1);
 end;
 
-procedure tBearbeitungen.clear;
+procedure tTransformationen.clear;
 var i: longint;
 begin
  for i:=0 to length(Schritte)-1 do
@@ -1402,117 +1659,244 @@ begin
  setlength(Schritte,0);
 end;
 
-procedure tBearbeitungen.addNew;
+procedure tTransformationen.clearWerte;
+var i,j: longint;
 begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tBearbeitung.create;
+ for i:=0 to length(Schritte)-1 do
+   if assigned(Schritte[i]) and (Schritte[i] is tWerteTransformation) then
+     Schritte[i].free;
+ j:=0;
+ for i:=0 to length(Schritte)-1 do
+   if assigned(Schritte[i]) then begin
+     Schritte[j]:=Schritte[i];
+     inc(j);
+   end;
+ setlength(Schritte,j);
 end;
 
-procedure tBearbeitungen.add(inh: tBearbeitung);
+procedure tTransformationen.addFFT(hor,ver: boolean);
 begin
  setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tBearbeitung.create(inh);
+ Schritte[length(Schritte)-1]:=tFFTTransformation.create;
+ with last as tFFTTransformation do begin
+   horizontal:=hor;
+   vertikal:=ver;
+ end;
 end;
 
-procedure tBearbeitungen.append(inhs: tBearbeitungen);
-var i: longint;
+procedure tTransformationen.AddSpiegelung;
 begin
- for i:=0 to inhs.count-1 do
-   add(inhs[i]);
+ setlength(Schritte,length(Schritte)+1);
+ Schritte[length(Schritte)-1]:=tSpiegelungsTransformation.create;
 end;
 
-// tAchsenskala ****************************************************************
+function tTransformationen.add(inh: tTransformation): boolean;
+begin
+ result:=false;
+ setlength(Schritte,length(Schritte)+1);
+ if inh is tFFTTransformation then
+   Schritte[length(Schritte)-1]:=tFFTTransformation.create(inh as tFFTTransformation)
+ else if inh is tKoordinatenAusschnitt then
+   Schritte[length(Schritte)-1]:=tKoordinatenAusschnitt.create(inh as tKoordinatenAusschnitt)
+ else if inh is tKonkreteKoordinatenTransformation then
+   Schritte[length(Schritte)-1]:=tKonkreteKoordinatenTransformation.create(inh as tKonkreteKoordinatenTransformation)
+ else if inh is tSpiegelungsTransformation then
+   Schritte[length(Schritte)-1]:=tSpiegelungsTransformation.create
+ else if inh is tWerteKnickTransformation then
+   Schritte[length(Schritte)-1]:=tWerteKnickTransformation.create(inh as tWerteKnickTransformation)
+ else if inh is tWerteLogTransformation then
+   Schritte[length(Schritte)-1]:=tWerteLogTransformation.create(inh as tWerteLogTransformation)
+ else if inh is tWerteLogAbsTransformation then
+   Schritte[length(Schritte)-1]:=tWerteLogAbsTransformation.create(inh as tWerteLogAbsTransformation)
+ else if inh is tWerteAbsTransformation then
+   Schritte[length(Schritte)-1]:=tWerteAbsTransformation.create
+ else begin
+   gibAus('Ich kann unbekannten Transformationstyp ('+inh.ClassName+') nicht einfügen, da ich ihn nicht kopieren kann!',3);
+   exit;
+ end;
+ result:=true;
+end;
 
-constructor tAchsenskala.create;
+function tTransformationen.add(st: boolean; s: string; f: tInputFile; etf: tExprToFloat): boolean;
+var i:   longint;
 begin
- inherited create;
- xsteps:=-1;
- tsiz:=-1;
- xstart:=0;
- xstop:=1;
- tstart:=0;
- tstop:=1;
+ result:=false;
+ if s='Knick' then begin
+   setlength(Schritte,length(Schritte)+1);
+   Schritte[length(Schritte)-1]:=tWerteKnickTransformation.create;
+   with (last as tWerteKnickTransformation) do begin
+     setlength(parameter,2);
+     parameter[0]:=0;
+     parameter[1]:=0;
+     repeat
+       if not f.gibZeile(s) then begin
+         gibAus('Unerwartetes Dateiende!',3);
+         exit;
+       end;
+       if s='Ende' then break;
+       setlength(parameter,length(parameter)+2);
+       parameter[length(parameter)-2]:=
+         etf(st,erstesArgument(s,' '));
+       if s='' then s:=inttostr(length(parameter) div 2 - 1);
+       parameter[length(parameter)-1]:=
+         etf(st,s);
+     until false;
+     for i:=0 to length(parameter)-1 do
+       if odd(i) then
+         parameter[i]:=
+           parameter[i]/
+             (length(parameter) div 2);
+     setlength(parameter,length(parameter)+2);
+     parameter[length(parameter)-2]:= 1;
+     parameter[length(parameter)-1]:= 1;
+   end;
+   result:=true;
+   exit;
+ end;
+ if startetMit('Log:',s) then begin
+   setlength(Schritte,length(Schritte)+1);
+   Schritte[length(Schritte)-1]:=tWerteLogTransformation.create;
+   (last as tWerteLogTransformation).logMin:=etf(st,s);
+   result:=true;
+   exit;
+ end;
+ if startetMit('AbsLog:',s) then begin
+   setlength(Schritte,length(Schritte)+1);
+   Schritte[length(Schritte)-1]:=tWerteLogAbsTransformation.create;
+   (last as tWerteLogAbsTransformation).logSkala:=etf(st,s);
+   result:=true;
+   exit;
+ end;
+ if s='Abs' then begin
+   setlength(Schritte,length(Schritte)+1);
+   Schritte[length(Schritte)-1]:=tWerteAbsTransformation.create;
+   result:=true;
+   exit;
+ end;
+ gibAus('Kenne Nachbearbeitungsmethode '''+s+''' nicht!',3);
 end;
 
-constructor tAchsenskala.create(original: tAchsenskala);
+function tTransformationen.add(syntaxtest: boolean; s: string; xscale,yscale: extended; etf: tExprToFloat): boolean;
 begin
- inherited create(original);
- xsteps:=original.xsteps;
- tsiz:=original.tsiz;
- xstart:=original.xstart;
- xstop:=original.xstop;
- tstart:=original.tstart;
- tstop:=original.tstop;
+ setlength(Schritte,length(Schritte)+1);
+ Schritte[length(Schritte)-1]:=tKonkreteKoordinatenTransformation.create;
+ result:=(last as tKonkreteKoordinatenTransformation).initAbbildung(syntaxtest,s,xscale,yscale,etf);
 end;
 
-destructor tAchsenskala.destroy;
+function tTransformationen.append(inhs: tTransformationen): boolean;
+var i: longint;
 begin
- inherited destroy;
+ result:=true;
+ for i:=0 to inhs.count-1 do
+   result:=result and add(inhs[i]);
 end;
 
-procedure tAchsenskala.kopiereVon(original: tAchsenskala);
+procedure tTransformationen.addAusschnitt(xmin,xmax,tmin,tmax: longint);
 begin
- clear;
- append(original);
- xsteps:=original.xsteps;
- tsiz:=original.tsiz;
- xstart:=original.xstart;
- xstop:=original.xstop;
- tstart:=original.tstart;
- tstop:=original.tstop;
+ setlength(Schritte,length(Schritte)+1);
+ Schritte[length(Schritte)-1]:=tKoordinatenAusschnitt.create;
+ (last as tKoordinatenAusschnitt).xmin:=xmin;
+ (last as tKoordinatenAusschnitt).xmax:=xmax;
+ (last as tKoordinatenAusschnitt).tmin:=tmin;
+ (last as tKoordinatenAusschnitt).tmax:=tmax;
+// last.off['x']:=-xmin*last.lin['x','x'];  // man muss sich nur die Verschiebung merken,
+// last.off['y']:=-tmin*last.lin['y','y'];  // das Abschneiden kommt einfach durch die kleineren tsiz und xsteps zustande
 end;
 
-function tAchsenskala.gibPosition(lage: tLage; x: extended): extended;
-var i: longint;
-    p: tExtPoint;
+function tTransformationen.kopiereVon(original: tTransformationen): boolean;
 begin
- if lage in [lOben,lRechts] then begin
-   p.x:=1;
-   p.y:=1;
- end
- else begin
-   p.x:=0;
-   p.y:=0;
- end;
+ clear;
+ result:=append(original);
+ _xsteps:=original._xsteps;
+ _tsiz:=original._tsiz;
+ _xstart:=original._xstart;
+ _xstop:=original._xstop;
+ _tstart:=original._tstart;
+ _tstop:=original._tstop;
+ _wmax:=original._wmax;
+ _wmin:=original._wmin;
+end;
+
+function tTransformationen.transformiereKoordinaten(lage: tLage; x: extended): extended;
+var p: tExtPoint;
+begin
+ case lage of
+   lLinks:
+     p.x:=xstart;
+   lOben:
+     p.y:=tstop;
+   lRechts:
+     p.x:=xstop;
+   lUnten:
+     p.y:=tstart;
+ end{of case};
  if lage in [lOben,lUnten] then
    p.x:=(x-xstart)/(xstop-xstart)
  else
    p.y:=(x-tstart)/(tstop-tstart);
- for i:=0 to count-1 do
-   p:=inhalt[i].ziel(p);
+ p.x:=p.x*(_xsteps-1);
+ p.y:=p.y*(_tsiz-1);
+ p:=transformiereKoordinaten(p);
  if lage in [lOben,lUnten] then
-   result:=p.x
+   result:=p.x/xsteps_tsiz.x
  else
-   result:=p.y;
+   result:=p.y/xsteps_tsiz.y;
 end;
 
-// tWerteskala *****************************************************************
+function tTransformationen.transformiereKoordinaten(x,y: extended): tExtPoint;
+begin
+ result.x:=x;
+ result.y:=y;
+ result:=transformiereKoordinaten(result);
+end;
 
-constructor tWerteskala.create;
+function tTransformationen.transformiereKoordinaten(p: tExtPoint): tExtPoint;
+var i: longint;
 begin
- inherited create;
- wmin:=0;
- wmax:=1;
+ result:=p;
+ for i:=0 to count-1 do
+   result:=inhalt[i].transformiereKoordinaten(result);
 end;
 
-constructor tWerteskala.create(original: tWerteskala);
+function tTransformationen.transformiereWert(x: extended): extended;
+var i: longint;
 begin
- inherited create;
- wmin:=original.wmin;
- wmax:=original.wmax;
+ result:=x;
+ for i:=0 to count-1 do
+   x:=inhalt[i].transformiereWert(result);
 end;
 
-destructor tWerteskala.destroy;
+function tTransformationen.dumpParams: string;
+var i: longint;
 begin
- inherited destroy;
+ result:=inttostr(xsteps)+' x '+inttostr(tsiz)+' ('+floattostr(xstart)+'..'+floattostr(xstop)+' x '+floattostr(tstart)+'..'+floattostr(tstop)+')';
+ for i:=0 to count-1 do
+   result:=result+#10' '+inhalt[i].dumpParams;
 end;
 
-procedure tWerteskala.kopiereVon(original: tWerteskala);
+procedure tTransformationen.berechneZielausdehnung(out grenzen: t2x2Longint);
+var Rand:   array of tExtPoint;
+    i:      longint;
 begin
- clear;
- append(original);
- wmin:=original.wmin;
- wmax:=original.wmax;
+ setlength(Rand,(_xsteps+_tsiz-2)*2);
+ for i:=0 to _xsteps-1 do
+   Rand[i]:=transformiereKoordinaten(i,0);
+ for i:=0 to _xsteps-1 do
+   Rand[_xsteps+i]:=transformiereKoordinaten(i,_tsiz-1);
+ for i:=0 to _tsiz-3 do
+   Rand[2*_xsteps+i]:=transformiereKoordinaten(0,i+1);
+ for i:=0 to _tsiz-3 do
+   Rand[2*_xsteps+_tsiz-2+i]:=transformiereKoordinaten(_xsteps-1,i+1);
+ grenzen['x','x']:=floor(rand[0].x);
+ grenzen['x','y']:=floor(rand[0].x)+1;
+ grenzen['y','x']:=floor(rand[0].y);
+ grenzen['y','y']:=floor(rand[0].y)+1;
+ for i:=0 to length(rand)-1 do begin
+   grenzen['x','x']:=min(grenzen['x','x'],floor(rand[i].x));
+   grenzen['x','y']:=max(grenzen['x','y'],floor(rand[i].x)+1);
+   grenzen['y','x']:=min(grenzen['y','x'],floor(rand[i].y));
+   grenzen['y','y']:=max(grenzen['y','y'],floor(rand[i].y)+1);
+ end;
 end;
 
 // allgemeine Funktionen *******************************************************
@@ -1710,10 +2094,12 @@ var s: string;
 begin
  s:=extractfilepath(paramstr(0))+'Log'+inttostr(tid);
  if fileexists(s) then
-   deletefile(s);
+   deletefile(s)
+ else
+   gibAus('Datei ''Log'+inttostr(tid)+''' kann nicht gelöscht werden, da sie nicht existiert!',3);
 end;
 
-procedure DumpExceptionCallStack(E: Exception);
+procedure dumpExceptionCallStack(E: Exception);
 var
   I: Integer;
   Frames: PPointer;
@@ -1771,5 +2157,15 @@ begin
  result:=formatDateTime('YYYY.MM.DD_hh.mm.ss',t);
 end;
 
+function tExtPointToStr(p: tExtPoint): string;
+begin
+ result:=floattostr(p.x)+';'+floattostr(p.y);
+end;
+
+function tPointToStr(p: tPoint): string;
+begin
+ result:=inttostr(p.x)+';'+inttostr(p.y);
+end;
+
 end.