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

1 files changed, 1449 insertions, 1046 deletions

diff --git a/typenunit.pas b/typenunit.pas
index 974090e..54c98cf 100644
--- a/typenunit.pas
+++ b/typenunit.pas
@@ -199,11 +199,11 @@ type
   end;
   tBeschriftungen = array of tBeschriftung;
   tWaveletTyp = (wtSin2,wtFrequenzfenster);
-  tTransformationen = class;
+  tTransformation = class;
   tExtraInfos = class
     maxW,minW,np,beta:                           extended;
     tsiz,xsteps,tsiz_,xsteps_:                   longint;
-    transformationen:                            tTransformationen;
+    transformationen:                            tTransformation;
     knownValues:                                 tKnownValues;
     constructor create;
     destructor destroy; override;
@@ -213,24 +213,98 @@ type
     function tstop: extended;
     procedure refreshKnownValues;
   end;
+  tTransformationArray = array of tTransformation;
   tTransformation = class
     // eine generische Transformation von Werten oder Koordinaten
     // selbst nicht zum Instanziieren gedacht
   private
+    vorgaenger,nachfolger: array of tTransformation;
+    in_xs_ts,out_xs_ts:   tIntPoint;
+    in_achsen,out_achsen: t2x2Extended;
+    out_wmia:             tExtPoint;
+    wmiaExplizit:         boolean;
+
     procedure testeAuszerhalb(const p: tExtPoint);
+    procedure aktualisiereAchsen; virtual; // nicht zum direkten Aufrufen
+    procedure aktualisiereXsTs; virtual;   // nicht zum direkten Aufrufen
+    procedure aktualisiereWmia; virtual;   // nicht zum direkten Aufrufen
+
+    function transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint; virtual;
+    // wie ändert sich die Position eines Punktes (Paradebeispiel: bei Spiegelung: x -> xsteps-1-x)
+    // ist für p veranwortlich?
+    function transformiereWertEinzeln(const x: extended): extended; virtual;
+    // wie ändert sich ein Wert
+
+    function rXstart: extended;
+    procedure wXstart(x: extended);
+    function rXstop: extended;
+    procedure wXstop(x: extended);
+    function rTstart: extended;
+    procedure wTstart(t: extended);
+    function rTstop: extended;
+    procedure wTstop(t: extended);
+    function rWmin: extended;
+    procedure wWmin(w: extended);
+    function rWmax: extended;
+    procedure wWmax(w: extended);
+    function rXsteps: longint;
+    procedure wXsteps(x: longint);
+    function rTsiz: longint;
+    procedure wTsiz(t: longint);
   public
-    in_xs_ts:  tIntPoint;
-    in_achsen: t2x2Extended;
-    function achsen: t2x2Extended; virtual;
-      // wie ändern sich xstart,xstop,tstart,tstop?
-    function transformiereKoordinaten(const x,y: longint): tExtPoint; overload;
-    function transformiereKoordinaten(const p: tExtPoint): tExtPoint; virtual; overload;
-      // wie ändert sich die Position eines Punktes (Paradebeispiel: bei Spiegelung: x -> xsteps-1-x)
-    function transformiereWert(const x: extended): extended; virtual;
-      // wie ändert sich ein Wert
-    function xsteps_tsiz: tIntPoint; virtual;
-      // wie ändert sich die Ausdehnung?
-    function dumpParams: string; virtual;
+    constructor create;
+    destructor destroy; override;
+    destructor freeAll;
+
+    procedure fuegeNachfolgerHinzu(tr: tTransformation);
+    procedure loescheNachfolger(tr: tTransformation);
+    procedure fuegeVorgaengerHinzu(tr: tTransformation);
+    procedure loescheVorgaenger(tr: tTransformation);
+    function hatNachfolger: boolean;
+    procedure aktualisiereAlles; // (inkl. Informieren der Nachfolger)
+    function ersetzeAnfangDurch(tr: tTransformation): boolean;
+    function beliebigerVorgaenger: tTransformation;
+
+    property achsen: t2x2Extended read out_achsen;
+      // wie lauten xstart,xstop,tstart,tstop?
+    function transformiereKoordinaten(const p: tExtPoint; const tiefe: longint = -1): tExtPoint; overload;
+    function transformiereKoordinaten(const x,y: longint; const tiefe: longint = -1): tExtPoint; overload;
+    function wertZuPositionAufAchse(const l: tLage; x: extended): extended; virtual;
+    function transformiereWert(const x: extended; const tiefe: longint = -1): extended;
+    property xsteps_tsiz: tIntPoint read out_xs_ts;
+    function dumpParams: string; virtual; overload;
+    function dumpParams(tiefe: longint): string; overload;
+    property xstart: extended
+      read rXstart
+      write wXstart;
+    property xstop: extended
+      read rXstop
+      write wXstop;
+    property tstart: extended
+      read rTstart
+      write wTstart;
+    property tstop: extended
+      read rTstop
+      write wTstop;
+    property wmin: extended
+      read rWmin
+      write wWmin;
+    property wmax: extended
+      read rWmax
+      write wWmax;
+    property xsteps: longint
+      read rXsteps
+      write wXsteps;
+    property tsiz: longint
+      read rTsiz
+      write wTsiz;
+  end;
+  tKeineTransformation = class (tTransformation)
+    // der Beginn einer Transformationskette, z.B. das Laden von Daten
+  end;
+  tUeberlagerung = class (tTransformation)
+    // die Überlagerung mehrer gleichformatiger Daten, z.B. Linearkombination
+    procedure addKomponente(tr: tTransformation);
   end;
   tKoordinatenTransformation = class (tTransformation)
     // eine generische Transformation der Koordinaten
@@ -240,15 +314,16 @@ type
     // repräsentiert die Transformation der Koordinaten bei einer FFT
     horizontal,vertikal: boolean;
     constructor create; overload;
-    constructor create(original: tFFTTransformation); overload;
-    function achsen: t2x2Extended; override;
+    constructor create(vorg: tTransformation; hor,ver: boolean);
+    procedure aktualisiereAchsen; override;
     // keine Änderung der Positionen, der Werte(skalierung), der Ausdehnung
     function dumpParams: string; override;
   end;
   tSpiegelungsTransformation = class (tKoordinatenTransformation)
     // repräsentiert die horizontale Spiegelung der Koordinaten
     constructor create;
-    function transformiereKoordinaten(const p: tExtPoint): tExtPoint; override; overload;
+    constructor create(vorg: tTransformation);
+    function transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint; override; overload;
     // keine Änderung der Achsenbegrenzungen, der Werte(skalierung), der Ausdehnung
     function dumpParams: string; override;
   end;
@@ -265,34 +340,32 @@ type
     lnOff,                       // Offset der ln-Argumente
     expFak: tExtPoint;           // Vorfaktoren der Exponentialfunktionen
     constructor create; overload;
-    constructor create(original: tKonkreteKoordinatenTransformation); overload;
-    function transformiereKoordinaten(const p: tExtPoint): tExtPoint; override; overload;
+    function transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint; override; overload;
     function initAbbildung(syntaxtest: boolean; s: string; xscale,yscale: extended; etf: tExprToFloat): boolean;
     function zielausdehnung: t2x2Longint;
-    function xsteps_tsiz: tIntPoint; override;
+    procedure aktualisiereXsTs; override;
     // keine Änderung der Achsenbegrenzungen, der Werte(skalierung)
     function dumpParams: string; override;
   end;
   tKoordinatenAusschnitt = class (tKoordinatenTransformation)
     gr: t2x2Longint;
     constructor create; overload;
-    constructor create(original: tKoordinatenAusschnitt); overload;
-    function xsteps_tsiz: tIntPoint; override;
-    function achsen: t2x2Extended; override;
-    function transformiereKoordinaten(const p: tExtPoint): tExtPoint; override; overload;
+    constructor create(vorg: tTransformation; xmin,xmax,tmin,tmax: longint); overload;
+    procedure aktualisiereXsTs; override;
+    procedure aktualisiereAchsen; override;
+    function transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint; override; overload;
     // keine Änderung der Werte(skalierung)
     function dumpParams: string; override;
   end;
   tAgglomeration = class (tKoordinatenTransformation)
     schritt: extended;
-    anzahl: longint;
     horizontal: boolean;
     constructor create; overload;
-    constructor create(original: tAgglomeration); overload;
-    function xsteps_tsiz: tIntPoint; override;
-    function achsen: t2x2Extended; override;
-    function transformiereKoordinaten(const p: tExtPoint): tExtPoint; override; overload;
+    procedure addKomponente(tr: tTransformation);
+    procedure aktualisiereXsTs; override;
+    procedure aktualisiereAchsen; override;
     // keine Änderung der Werte(skalierung)
+    function wertZuPositionAufAchse(const l: tLage; x: extended): extended; override;
     function dumpParams: string; override;
   end;
   tBearbeitungstyp = (btUnbekannt,btKnick,btLog,btAbsLog,btAbs);
@@ -304,9 +377,8 @@ type
     // Werte knicken
     parameter: tExtendedArray;
     constructor create; overload;
-    constructor create(original: tWerteKnickTransformation); overload;
     destructor destroy; override;
-    function transformiereWert(const x: extended): extended; override;
+    function transformiereWertEinzeln(const x: extended): extended; override;
     // keine Änderung der Achsenbegrenzungen, der Positionen, der Ausdehnung
     function dumpParams: string; override;
   end;
@@ -314,8 +386,7 @@ type
     // Werte logarithmieren
     logMin: extended;
     constructor create; overload;
-    constructor create(original: tWerteLogTransformation); overload;
-    function transformiereWert(const x: extended): extended; override;
+    function transformiereWertEinzeln(const x: extended): extended; override;
     // keine Änderung der Achsenbegrenzungen, der Positionen, der Ausdehnung
     function dumpParams: string; override;
   end;
@@ -323,19 +394,18 @@ type
     // Wertebeträge logarithmieren
     logSkala: extended;
     constructor create; overload;
-    constructor create(original: tWerteLogAbsTransformation); overload;
-    function transformiereWert(const x: extended): extended; override;
+    function transformiereWertEinzeln(const x: extended): extended; override;
     // keine Änderung der Achsenbegrenzungen, der Positionen, der Ausdehnung
     function dumpParams: string; override;
   end;
   tWerteAbsTransformation = class (tWerteTransformation)
     // Werte betragen
     constructor create;
-    function transformiereWert(const x: extended): extended; override;
+    function transformiereWertEinzeln(const x: extended): extended; override;
     // keine Änderung der Achsenbegrenzungen, der Positionen, der Ausdehnung
     function dumpParams: string; override;
   end;
-  tTransformationen = class
+(*  tTransformationen = class
   private
     // merkt sich, was mit den Werten und Koordinaten nach einem festen Punkt (dem Einlesen) passiert ist,
     // sodass man immer nachvollziehen kann, welcher Punkt woher kam und wie verarbeitet wurde.
@@ -346,50 +416,9 @@ type
     _xs_ts:   tIntPoint;
     function gibInhalt(ii: longint): tTransformation;
     procedure nimmInhalt(ii: longint; inh: tTransformation);
-    function rXstart: extended;
-    procedure wXstart(x: extended);
-    function rXstop: extended;
-    procedure wXstop(x: extended);
-    function rTstart: extended;
-    procedure wTstart(t: extended);
-    function rTstop: extended;
-    procedure wTstop(t: extended);
-    function rWmin: extended;
-    procedure wWmin(w: extended);
-    function rWmax: extended;
-    procedure wWmax(w: extended);
-    function rXsteps: longint;
-    procedure wXsteps(x: longint);
-    function rTsiz: longint;
-    procedure wTsiz(t: longint);
-    function xsteps_tsiz: tIntPoint;
     function gibAchsen: t2x2Extended;
     procedure achsenUndGroeszeAktualisieren;
   public
-    property xstart: extended
-      read rXstart
-      write wXstart;
-    property xstop: extended
-      read rXstop
-      write wXstop;
-    property tstart: extended
-      read rTstart
-      write wTstart;
-    property tstop: extended
-      read rTstop
-      write wTstop;
-    property wmin: extended
-      read rWmin
-      write wWmin;
-    property wmax: extended
-      read rWmax
-      write wWmax;
-    property xsteps: longint
-      read rXsteps
-      write wXsteps;
-    property tsiz: longint
-      read rTsiz
-      write wTsiz;
     property inhalt[ii: longint]: tTransformation
       read gibInhalt
       write nimmInhalt; default;
@@ -418,7 +447,9 @@ type
     function dumpParams: string;
     procedure berechneZielausdehnung(out grenzen: t2x2Longint);
   end;
-  tTransformationenArray = array of tTransformationen;
+  tTransformationenArray = array of tTransformationen; *)
+
+function liesTWerteTransformationen(st: boolean; s: string; f: tMyStringlist; etf: tExprToFloat; var tr: tTransformation): boolean;
 
 implementation
 
@@ -426,409 +457,410 @@ implementation
 
 constructor tGenerischeInputDateiInfo.create(Vorlage: tGenerischeInputDateiInfo);
 begin
- inherited create;
- fillchar(Name,sizeof(Name),#0);
- Name:=Vorlage.Name;
- fillchar(Fehlerbehebungskommando,sizeof(Fehlerbehebungskommando),#0);
- Fehlerbehebungskommando:=Vorlage.Fehlerbehebungskommando;
- gamma:=Vorlage.gamma;
- groeszenFaktor:=Vorlage.groeszenFaktor;
- Genauigkeit:=Vorlage.Genauigkeit;
- tsiz:=Vorlage.tsiz;
- xsteps:=Vorlage.xsteps;
- tstart:=Vorlage.tstart;
- tstop:=Vorlage.tstop;
- xstart:=Vorlage.xstart;
- xstop:=Vorlage.xstop;
- params:=Vorlage.params;
- t0abs:=Vorlage.t0abs;
+  inherited create;
+  fillchar(Name,sizeof(Name),#0);
+  Name:=Vorlage.Name;
+  fillchar(Fehlerbehebungskommando,sizeof(Fehlerbehebungskommando),#0);
+  Fehlerbehebungskommando:=Vorlage.Fehlerbehebungskommando;
+  gamma:=Vorlage.gamma;
+  groeszenFaktor:=Vorlage.groeszenFaktor;
+  Genauigkeit:=Vorlage.Genauigkeit;
+  tsiz:=Vorlage.tsiz;
+  xsteps:=Vorlage.xsteps;
+  tstart:=Vorlage.tstart;
+  tstop:=Vorlage.tstop;
+  xstart:=Vorlage.xstart;
+  xstop:=Vorlage.xstop;
+  params:=Vorlage.params;
+  t0abs:=Vorlage.t0abs;
 end;
 
 constructor tGenerischeInputDateiInfo.create;
 begin
- inherited create;
- fillchar(Name,sizeof(Name),#0);
- Name:='';
- fillchar(Fehlerbehebungskommando,sizeof(Fehlerbehebungskommando),#0);
- Fehlerbehebungskommando:='';
- gamma:=1;
- groeszenFaktor:=1;
- Genauigkeit:=gSingle;
- tsiz:=-1;
- t0abs:=-1;
- xsteps:=-1;
- tstart:=-myInf;
- tstop:=myInf;
- xstart:=-myInf;
- xstop:=myInf;
- params:=nil;
+  inherited create;
+  fillchar(Name,sizeof(Name),#0);
+  Name:='';
+  fillchar(Fehlerbehebungskommando,sizeof(Fehlerbehebungskommando),#0);
+  Fehlerbehebungskommando:='';
+  gamma:=1;
+  groeszenFaktor:=1;
+  Genauigkeit:=gSingle;
+  tsiz:=-1;
+  t0abs:=-1;
+  xsteps:=-1;
+  tstart:=-myInf;
+  tstop:=myInf;
+  xstart:=-myInf;
+  xstop:=myInf;
+  params:=nil;
 end;
 
 destructor tGenerischeInputDateiInfo.destroy;
 begin
- Name:='';
- Fehlerbehebungskommando:='';
- inherited destroy;
+  Name:='';
+  Fehlerbehebungskommando:='';
+  inherited destroy;
 end;
 
 function tGenerischeInputDateiInfo.xmin: longint;
 begin
- result:=0;
- if assigned(params) and (params.xsteps>1) and (xstart > params.xstart + result/(params.xsteps-1)*(params.xstop-params.xstart)) then
-   result:=min(xsteps-1,round((xstart-params.xstart)/(params.xstop-params.xstart)/(params.xsteps-1)));
+  result:=0;
+  if assigned(params) and (params.xsteps>1) and (xstart > params.xstart + result/(params.xsteps-1)*(params.xstop-params.xstart)) then
+    result:=min(xsteps-1,round((xstart-params.xstart)/(params.xstop-params.xstart)/(params.xsteps-1)));
 end;
 
 function tGenerischeInputDateiInfo.xmax: longint;
 begin
- result:=xsteps-1;
- if assigned(params) and (params.xsteps>1) and (xstop < params.xstart + result/(params.xsteps-1)*(params.xstop-params.xstart)) then
-   result:=max(0,round((xstop-params.xstart)/(params.xstop-params.xstart)/(params.xsteps-1)));
+  result:=xsteps-1;
+  if assigned(params) and (params.xsteps>1) and (xstop < params.xstart + result/(params.xsteps-1)*(params.xstop-params.xstart)) then
+    result:=max(0,round((xstop-params.xstart)/(params.xstop-params.xstart)/(params.xsteps-1)));
 end;
 
 function tGenerischeInputDateiInfo.tmin: longint;
 begin
- result:=t0abs;
- if assigned(params) and (params.tsiz>1) and (tstart > params.tstart + result/(params.tsiz-1)*(params.tstop-params.tstart)) then
-   result:=round((tstart-params.tstart)/(params.tstop-params.tstart)/(params.tsiz-1));
- result:=min(tsiz-1,max(0,result-t0abs));
+  result:=t0abs;
+  if assigned(params) and (params.tsiz>1) and (tstart > params.tstart + result/(params.tsiz-1)*(params.tstop-params.tstart)) then
+    result:=round((tstart-params.tstart)/(params.tstop-params.tstart)/(params.tsiz-1));
+  result:=min(tsiz-1,max(0,result-t0abs));
 end;
 
 function tGenerischeInputDateiInfo.tmax: longint;
 begin
- result:=t0abs+tsiz-1;
- if assigned(params) and (params.tsiz>1) and (tstop < params.tstart + result/(params.tsiz-1)*(params.tstop-params.tstart)) then
-   result:=round((tstop-params.tstart)/(params.tstop-params.tstart)/(params.tsiz-1));
- result:=min(tsiz-1,max(0,result-t0abs));
+  result:=t0abs+tsiz-1;
+  if assigned(params) and (params.tsiz>1) and (tstop < params.tstart + result/(params.tsiz-1)*(params.tstop-params.tstart)) then
+    result:=round((tstop-params.tstart)/(params.tstop-params.tstart)/(params.tsiz-1));
+  result:=min(tsiz-1,max(0,result-t0abs));
 end;
 
 // tPhaseSpaceInputDateiInfo ****************************************************
 
 constructor tPhaseSpaceInputDateiInfo.create(Vorlage: tGenerischeInputDateiInfo);
 begin
- inherited create(Vorlage);
+  inherited create(Vorlage);
 end;
 
 constructor tPhaseSpaceInputDateiInfo.create;
 begin
- inherited create;
+  inherited create;
 end;
 
 destructor tPhaseSpaceInputDateiInfo.destroy;
 begin
- inherited destroy;
+  inherited destroy;
 end;
 
 // tSpaceTimeInputDateiInfo ****************************************************
 
 constructor tSpaceTimeInputDateiInfo.create(Vorlage: tGenerischeInputDateiInfo);
 begin
- inherited create(Vorlage);
+  inherited create(Vorlage);
 end;
 
 constructor tSpaceTimeInputDateiInfo.create;
 begin
- inherited create;
+  inherited create;
 end;
 
 destructor tSpaceTimeInputDateiInfo.destroy;
 begin
- inherited destroy;
+  inherited destroy;
 end;
 
 // tTraceInputDateiInfo ********************************************************
 
 constructor tTraceInputDateiInfo.create(Vorlage: tGenerischeInputDateiInfo);
 begin
- inherited create(Vorlage);
- if Vorlage is tTraceInputDateiInfo then begin
-   Spurnummer:=(Vorlage as tTraceInputDateiInfo).Spurnummer;
-   FeldNummer:=(Vorlage as tTraceInputDateiInfo).FeldNummer;
- end
- else begin
-   Spurnummer:=0;
-   FeldNummer:=0;
- end;
+  inherited create(Vorlage);
+  if Vorlage is tTraceInputDateiInfo then begin
+    Spurnummer:=(Vorlage as tTraceInputDateiInfo).Spurnummer;
+    FeldNummer:=(Vorlage as tTraceInputDateiInfo).FeldNummer;
+  end
+  else begin
+    Spurnummer:=0;
+    FeldNummer:=0;
+  end;
 end;
 
 constructor tTraceInputDateiInfo.create;
 begin
- inherited create;
- Spurnummer:=0;
- FeldNummer:=0;
+  inherited create;
+  Spurnummer:=0;
+  FeldNummer:=0;
 end;
 
 destructor tTraceInputDateiInfo.destroy;
 begin
- inherited destroy;
+  inherited destroy;
 end;
 
 // tPipeInputDateiInfo *********************************************************
 
 constructor tPipeInputDateiInfo.create(Vorlage: tGenerischeInputDateiInfo);
 begin
- inherited create(Vorlage);
- fillchar(Analysator,sizeof(Analysator),#0);
- if Vorlage is tPipeInputDateiInfo then begin
-   Analysator:=(Vorlage as tPipeInputDateiInfo).Analysator;
-   bytesPerSample:=(Vorlage as tPipeInputDateiInfo).bytesPerSample;
-   Kodierung:=(Vorlage as tPipeInputDateiInfo).Kodierung;
- end
- else begin
-   Analysator:='/usr/bin/soxi -';
-   bytesPerSample:=-1;
-   Kodierung:=kUnbekannt;
- end;
+  inherited create(Vorlage);
+  fillchar(Analysator,sizeof(Analysator),#0);
+  if Vorlage is tPipeInputDateiInfo then begin
+    Analysator:=(Vorlage as tPipeInputDateiInfo).Analysator;
+    bytesPerSample:=(Vorlage as tPipeInputDateiInfo).bytesPerSample;
+    Kodierung:=(Vorlage as tPipeInputDateiInfo).Kodierung;
+  end
+  else begin
+    Analysator:='/usr/bin/soxi -';
+    bytesPerSample:=-1;
+    Kodierung:=kUnbekannt;
+  end;
 end;
 
 constructor tPipeInputDateiInfo.create;
 begin
- inherited create;
- fillchar(Analysator,sizeof(Analysator),#0);
- Analysator:='/usr/bin/soxi -';
- bytesPerSample:=-1;
- Kodierung:=kUnbekannt;
+  inherited create;
+  fillchar(Analysator,sizeof(Analysator),#0);
+  Analysator:='/usr/bin/soxi -';
+  bytesPerSample:=-1;
+  Kodierung:=kUnbekannt;
 end;
 
 destructor tPipeInputDateiInfo.destroy;
 begin
- Analysator:='';
- inherited destroy;
+  Analysator:='';
+  inherited destroy;
 end;
 
 function tPipeInputDateiInfo.Executable: string;
 begin
- result:=leftStr(Name,pos(' ',Name+' ')-1);
+  result:=leftStr(Name,pos(' ',Name+' ')-1);
 end;
 
 function tPipeInputDateiInfo.ParametersText: string;
 begin
- result:=copy(Name,pos(' ',Name+' ')+1,length(Name));
- while pos(' ',result)>0 do
-   result[pos(' ',result)]:=#13;
+  result:=copy(Name,pos(' ',Name+' ')+1,length(Name));
+  while pos(' ',result)>0 do
+    result[pos(' ',result)]:=#13;
 end;
 
 function tPipeInputDateiInfo.AnalysatorExecutable: string;
 begin
- result:=leftStr(Analysator,pos(' ',Analysator+' ')-1);
+  result:=leftStr(Analysator,pos(' ',Analysator+' ')-1);
 end;
 
 function tPipeInputDateiInfo.AnalysatorParametersText: string;
 begin
- result:=copy(Analysator,pos(' ',Analysator+' ')+1,length(Analysator));
- while pos(' ',result)>0 do
-   result[pos(' ',result)]:=#13;
+  result:=copy(Analysator,pos(' ',Analysator+' ')+1,length(Analysator));
+  while pos(' ',result)>0 do
+    result[pos(' ',result)]:=#13;
 end;
 
 // tInputDateiInfoVorlagen *****************************************************
 
 constructor tInputDateiInfoVorlagen.create;
 begin
- inherited create;
- PhaseSpaceVorlage:=tPhaseSpaceInputDateiInfo.create;
- SpaceTimeVorlage:=tSpaceTimeInputDateiInfo.create;
- TraceVorlage:=tTraceInputDateiInfo.create;
- PipeVorlage:=tPipeInputDateiInfo.create;
- fillchar(_Name,sizeof(_Name),#0);
- Name:=SpaceTimeVorlage.Name;
- fillchar(_Fehlerbehebungskommando,sizeof(_Fehlerbehebungskommando),#0);
- Fehlerbehebungskommando:=SpaceTimeVorlage.Fehlerbehebungskommando;
- Gamma:=SpaceTimeVorlage.Gamma;
- groeszenFaktor:=SpaceTimeVorlage.groeszenFaktor;
- Genauigkeit:=SpaceTimeVorlage.Genauigkeit;
- _tsiz:=SpaceTimeVorlage.tsiz;
- _xsteps:=SpaceTimeVorlage.xsteps;
- SpurNummer:=TraceVorlage.SpurNummer;
- FeldNummer:=TraceVorlage.FeldNummer;
- fillchar(_Analysator,sizeof(_Analysator),#0);
- Analysator:=PipeVorlage.Analysator;
- _bytesPerSample:=PipeVorlage.bytesPerSample;
- _Kodierung:=PipeVorlage.Kodierung;
- _tstart:=SpaceTimeVorlage.tstart;
- _tstop:=SpaceTimeVorlage.tstop;
- _xstart:=SpaceTimeVorlage.xstart;
- _xstop:=SpaceTimeVorlage.xstop;
- _t0abs:=SpaceTimeVorlage.t0abs;
+  inherited create;
+  PhaseSpaceVorlage:=tPhaseSpaceInputDateiInfo.create;
+  SpaceTimeVorlage:=tSpaceTimeInputDateiInfo.create;
+  TraceVorlage:=tTraceInputDateiInfo.create;
+  PipeVorlage:=tPipeInputDateiInfo.create;
+  fillchar(_Name,sizeof(_Name),#0);
+  Name:=SpaceTimeVorlage.Name;
+  fillchar(_Fehlerbehebungskommando,sizeof(_Fehlerbehebungskommando),#0);
+  Fehlerbehebungskommando:=SpaceTimeVorlage.Fehlerbehebungskommando;
+  Gamma:=SpaceTimeVorlage.Gamma;
+  groeszenFaktor:=SpaceTimeVorlage.groeszenFaktor;
+  Genauigkeit:=SpaceTimeVorlage.Genauigkeit;
+  _tsiz:=SpaceTimeVorlage.tsiz;
+  _xsteps:=SpaceTimeVorlage.xsteps;
+  SpurNummer:=TraceVorlage.SpurNummer;
+  FeldNummer:=TraceVorlage.FeldNummer;
+  fillchar(_Analysator,sizeof(_Analysator),#0);
+  Analysator:=PipeVorlage.Analysator;
+  _bytesPerSample:=PipeVorlage.bytesPerSample;
+  _Kodierung:=PipeVorlage.Kodierung;
+  _tstart:=SpaceTimeVorlage.tstart;
+  _tstop:=SpaceTimeVorlage.tstop;
+  _xstart:=SpaceTimeVorlage.xstart;
+  _xstop:=SpaceTimeVorlage.xstop;
+  _t0abs:=SpaceTimeVorlage.t0abs;
 end;
 
 destructor tInputDateiInfoVorlagen.destroy;
 begin
- PhaseSpaceVorlage.free;
- SpaceTimeVorlage.free;
- TraceVorlage.free;
- PipeVorlage.free;
- _Name:='';
- _Fehlerbehebungskommando:='';
- _Analysator:='';
- inherited destroy;
+  PhaseSpaceVorlage.free;
+  SpaceTimeVorlage.free;
+  TraceVorlage.free;
+  PipeVorlage.free;
+  _Name:='';
+  _Fehlerbehebungskommando:='';
+  _Analysator:='';
+  inherited destroy;
 end;
 
 procedure tInputDateiInfoVorlagen.wFehlerbehebungskommando(f: string);
 begin
- _Fehlerbehebungskommando:=f;
- PhaseSpaceVorlage.Fehlerbehebungskommando:=f;
- SpaceTimeVorlage.Fehlerbehebungskommando:=f;
- TraceVorlage.Fehlerbehebungskommando:=f;
- PipeVorlage.Fehlerbehebungskommando:=f;
+  _Fehlerbehebungskommando:=f;
+  PhaseSpaceVorlage.Fehlerbehebungskommando:=f;
+  SpaceTimeVorlage.Fehlerbehebungskommando:=f;
+  TraceVorlage.Fehlerbehebungskommando:=f;
+  PipeVorlage.Fehlerbehebungskommando:=f;
 end;
 
 procedure tInputDateiInfoVorlagen.wName(n: string);
 begin
- _Name:=n;
- PhaseSpaceVorlage.Name:=n;
- SpaceTimeVorlage.Name:=n;
- TraceVorlage.Name:=n;
- PipeVorlage.Name:=n;
+  _Name:=n;
+  PhaseSpaceVorlage.Name:=n;
+  SpaceTimeVorlage.Name:=n;
+  TraceVorlage.Name:=n;
+  PipeVorlage.Name:=n;
 end;
 
 procedure tInputDateiInfoVorlagen.wGamma(g: extended);
 begin
- _Gamma:=g;
- PhaseSpaceVorlage.Gamma:=g;
- SpaceTimeVorlage.Gamma:=g;
- TraceVorlage.Gamma:=g;
- PipeVorlage.Gamma:=g;
+  _Gamma:=g;
+  PhaseSpaceVorlage.Gamma:=g;
+  SpaceTimeVorlage.Gamma:=g;
+  TraceVorlage.Gamma:=g;
+  PipeVorlage.Gamma:=g;
 end;
 
 procedure tInputDateiInfoVorlagen.wTStart(t: extended);
 begin
- _tstart:=t;
- PhaseSpaceVorlage.tstart:=t;
- SpaceTimeVorlage.tstart:=t;
- TraceVorlage.tstart:=t;
- PipeVorlage.tstart:=t;
+  _tstart:=t;
+  PhaseSpaceVorlage.tstart:=t;
+  SpaceTimeVorlage.tstart:=t;
+  TraceVorlage.tstart:=t;
+  PipeVorlage.tstart:=t;
 end;
 
 procedure tInputDateiInfoVorlagen.wTStop(t: extended);
 begin
- _tstop:=t;
- PhaseSpaceVorlage.tstop:=t;
- SpaceTimeVorlage.tstop:=t;
- TraceVorlage.tstop:=t;
- PipeVorlage.tstop:=t;
+  _tstop:=t;
+  PhaseSpaceVorlage.tstop:=t;
+  SpaceTimeVorlage.tstop:=t;
+  TraceVorlage.tstop:=t;
+  PipeVorlage.tstop:=t;
 end;
 
 procedure tInputDateiInfoVorlagen.wXStart(x: extended);
 begin
- _xstart:=x;
- PhaseSpaceVorlage.xstart:=x;
- SpaceTimeVorlage.xstart:=x;
- TraceVorlage.xstart:=x;
- PipeVorlage.xstart:=x;
+  _xstart:=x;
+  PhaseSpaceVorlage.xstart:=x;
+  SpaceTimeVorlage.xstart:=x;
+  TraceVorlage.xstart:=x;
+  PipeVorlage.xstart:=x;
 end;
 
 procedure tInputDateiInfoVorlagen.wXStop(x: extended);
 begin
- _xstop:=x;
- PhaseSpaceVorlage.xstop:=x;
- SpaceTimeVorlage.xstop:=x;
- TraceVorlage.xstop:=x;
- PipeVorlage.xstop:=x;
+  _xstop:=x;
+  PhaseSpaceVorlage.xstop:=x;
+  SpaceTimeVorlage.xstop:=x;
+  TraceVorlage.xstop:=x;
+  PipeVorlage.xstop:=x;
 end;
 
 procedure tInputDateiInfoVorlagen.wT0Abs(t: longint);
 begin
- _t0abs:=t;
- PhaseSpaceVorlage.t0abs:=t;
- SpaceTimeVorlage.t0abs:=t;
- TraceVorlage.t0abs:=t;
- PipeVorlage.t0abs:=t;
+  _t0abs:=t;
+  PhaseSpaceVorlage.t0abs:=t;
+  SpaceTimeVorlage.t0abs:=t;
+  TraceVorlage.t0abs:=t;
+  PipeVorlage.t0abs:=t;
 end;
 
 procedure tInputDateiInfoVorlagen.wGroeszenFaktor(g: extended);
 begin
- _groeszenFaktor:=g;
- PhaseSpaceVorlage.groeszenFaktor:=g;
- SpaceTimeVorlage.groeszenFaktor:=g;
- TraceVorlage.groeszenFaktor:=g;
- PipeVorlage.groeszenFaktor:=g;
+  _groeszenFaktor:=g;
+  PhaseSpaceVorlage.groeszenFaktor:=g;
+  SpaceTimeVorlage.groeszenFaktor:=g;
+  TraceVorlage.groeszenFaktor:=g;
+  PipeVorlage.groeszenFaktor:=g;
 end;
 
 procedure tInputDateiInfoVorlagen.wGenauigkeit(g: tGenauigkeit);
 begin
- _Genauigkeit:=g;
- PhaseSpaceVorlage.Genauigkeit:=g;
- SpaceTimeVorlage.Genauigkeit:=g;
- TraceVorlage.Genauigkeit:=g;
- PipeVorlage.Genauigkeit:=g;
+  _Genauigkeit:=g;
+  PhaseSpaceVorlage.Genauigkeit:=g;
+  SpaceTimeVorlage.Genauigkeit:=g;
+  TraceVorlage.Genauigkeit:=g;
+  PipeVorlage.Genauigkeit:=g;
 end;
 
 procedure tInputDateiInfoVorlagen.wTSiz(t: longint);
 begin
- _tsiz:=t;
- PhaseSpaceVorlage.tsiz:=t;
- SpaceTimeVorlage.tsiz:=t;
- TraceVorlage.tsiz:=t;
- PipeVorlage.tsiz:=t;
+  _tsiz:=t;
+  PhaseSpaceVorlage.tsiz:=t;
+  SpaceTimeVorlage.tsiz:=t;
+  TraceVorlage.tsiz:=t;
+  PipeVorlage.tsiz:=t;
 end;
 
 procedure tInputDateiInfoVorlagen.wXSteps(x: longint);
 begin
- _xsteps:=x;
- PhaseSpaceVorlage.xsteps:=x;
- SpaceTimeVorlage.xsteps:=x;
- TraceVorlage.xsteps:=x;
- PipeVorlage.xsteps:=x;
+  _xsteps:=x;
+  PhaseSpaceVorlage.xsteps:=x;
+  SpaceTimeVorlage.xsteps:=x;
+  TraceVorlage.xsteps:=x;
+  PipeVorlage.xsteps:=x;
 end;
 
 procedure tInputDateiInfoVorlagen.wSpurNummer(s: longint);
 begin
- _SpurNummer:=s;
- TraceVorlage.SpurNummer:=s;
+  _SpurNummer:=s;
+  TraceVorlage.SpurNummer:=s;
 end;
 
 procedure tInputDateiInfoVorlagen.wFeldNummer(f: longint);
 begin
- _FeldNummer:=f;
- TraceVorlage.FeldNummer:=f;
+  _FeldNummer:=f;
+  TraceVorlage.FeldNummer:=f;
 end;
 
 procedure tInputDateiInfoVorlagen.wAnalysator(a: string);
 begin
- _Analysator:=a;
- PipeVorlage.Analysator:=a;
+  _Analysator:=a;
+  PipeVorlage.Analysator:=a;
 end;
 
 procedure tInputDateiInfoVorlagen.wBytesPerSample(b: longint);
 begin
- _bytesPerSample:=b;
- PipeVorlage.bytesPerSample:=b;
+  _bytesPerSample:=b;
+  PipeVorlage.bytesPerSample:=b;
 end;
 
 procedure tInputDateiInfoVorlagen.wKodierung(k: tKodierung);
 begin
- _Kodierung:=k;
- PipeVorlage.Kodierung:=k;
+  _Kodierung:=k;
+  PipeVorlage.Kodierung:=k;
 end;
 
 function tInputDateiInfoVorlagen.GenauigkeitFromStr(s: string): boolean;
 begin
- result:=strToGen(_Genauigkeit,s);
- Genauigkeit:=_Genauigkeit;
+  result:=strToGen(_Genauigkeit,s);
+  Genauigkeit:=_Genauigkeit;
 end;
 
 function tInputDateiInfoVorlagen.Fehlerbehebungsprogramm: string;
 begin
- result:=copy(Fehlerbehebungskommando,1,pos(' ',Fehlerbehebungskommando+' ')-1);
+  result:=copy(Fehlerbehebungskommando,1,pos(' ',Fehlerbehebungskommando+' ')-1);
 end;
 
 function tInputDateiInfoVorlagen.Fehlerbehebungsparameter: string;
 begin
- result:=copy(Fehlerbehebungskommando,pos(' ',Fehlerbehebungskommando+' ')+1,length(Fehlerbehebungskommando));
+  result:=copy(Fehlerbehebungskommando,pos(' ',Fehlerbehebungskommando+' ')+1,length(Fehlerbehebungskommando));
 end;
 
 procedure tInputDateiInfoVorlagen.wParams(p: tExtrainfos);
 begin
- _params:=p;
- PhaseSpaceVorlage.params:=p;
- SpaceTimeVorlage.params:=p;
- TraceVorlage.params:=p;
- PipeVorlage.params:=p;
+  _params:=p;
+  PhaseSpaceVorlage.params:=p;
+  SpaceTimeVorlage.params:=p;
+  TraceVorlage.params:=p;
+  PipeVorlage.params:=p;
 end;
 
 // tFenster ********************************************************************
 
 procedure tFenster.berechneWerte(anzWerte: longint);
-var i: integer;
+var
+  i: integer;
 begin
   setlength(werte,anzWerte);
   for i:=0 to length(werte)-1 do begin
@@ -856,53 +888,53 @@ end;
 
 constructor tBeschriftung.create;
 begin
- inherited create;
- _inhalt:='';
+  inherited create;
+  _inhalt:='';
 end;
 
 destructor tBeschriftung.destroy;
 begin
- _inhalt:='';
- inherited destroy;
+  _inhalt:='';
+  inherited destroy;
 end;
 
 function tBeschriftung.strich: longint;
 begin
- result:=round(position);
+  result:=round(position);
 end;
 
 function tBeschriftung.links: longint;
 begin
- case lage of
+  case lage of
   lOben,lUnten: result:=strich-(bild.breite div 2);
   lLinks: result:=-bild.breite-4-Byte(Rahmen);
   lRechts: result:=bbreite+3+Byte(Rahmen);
- end{of Case};
+  end{of Case};
 end;
 
 function tBeschriftung.oben: longint;
 begin
- case lage of
+  case lage of
   lLinks,lRechts: result:=strich-(bild.hoehe div 2);
   lUnten: result:=-bild.hoehe-4-Byte(Rahmen);
   lOben: result:=bHoehe+3+Byte(Rahmen);
- end{of Case};
+  end{of Case};
 end;
 
 function tBeschriftung.rechts: longint;
 begin
- result:=links+bild.breite-1;
+  result:=links+bild.breite-1;
 end;
 
 function tBeschriftung.unten: longint;
 begin
- result:=oben+bild.hoehe-1;
+  result:=oben+bild.hoehe-1;
 end;
 
 procedure tBeschriftung.wInhalt(s: string);
 begin
- _inhalt:=s;
- bild:=fontRend.rendere(_inhalt);
+  _inhalt:=s;
+  bild:=fontRend.rendere(_inhalt);
 end;
 
 // tExtraInfos *****************************************************************
@@ -912,7 +944,7 @@ begin
   inherited create;
   maxW:=1;
   minW:=0;
-  transformationen:=tTransformationen.create;
+  transformationen:=tTransformation.create;
   np:=1;
   beta:=0;
   tsiz:=0;
@@ -924,29 +956,29 @@ end;
 
 destructor tExtraInfos.destroy;
 begin
- knownValues.free;
- transformationen.free;
- inherited destroy;
+  knownValues.free;
+  transformationen.free;
+  inherited destroy;
 end;
 
 function tExtraInfos.xstart: extended;
 begin
- result:=transformationen.xstart;
+  result:=transformationen.xstart;
 end;
 
 function tExtraInfos.xstop: extended;
 begin
- result:=transformationen.xstop;
+  result:=transformationen.xstop;
 end;
 
 function tExtraInfos.tstart: extended;
 begin
- result:=transformationen.tstart;
+  result:=transformationen.tstart;
 end;
 
 function tExtraInfos.tstop: extended;
 begin
- result:=transformationen.tstop;
+  result:=transformationen.tstop;
 end;
 
 procedure tExtraInfos.refreshKnownValues;
@@ -965,520 +997,821 @@ end;
 
 constructor tFontRenderer.create(schriftgroesze: longint);
 begin
- inherited create;
+  inherited create;
 
- gibAus('FontRenderer erzeugen (Schriftgröße '+inttostr(schriftgroesze)+') ...',1);
+  gibAus('FontRenderer erzeugen (Schriftgröße '+inttostr(schriftgroesze)+') ...',1);
 
- New(agg, Construct);
- agg^.font('/usr/share/fonts/TTF/DejaVuSans.ttf',schriftgroesze,false,false,RasterFontCache,0.0);
+  New(agg, Construct);
+  agg^.font('/usr/share/fonts/TTF/DejaVuSans.ttf',schriftgroesze,false,false,RasterFontCache,0.0);
 
- gibAus('... fertig',1);
+  gibAus('... fertig',1);
 end;
 
 destructor tFontRenderer.destroy;
 begin
- Dispose(agg,Destruct);
- inherited destroy;
+  Dispose(agg,Destruct);
+  inherited destroy;
 end;
 
 function tFontRenderer.rendere(s: string): tLLBild;
-var buf:                           array of byte;
-    ho,br,ymax,ymin,xmax,xmin,i,j: longint;
-    b:                             boolean;
-begin
- while pos('.',s)>0 do
-   s[pos('.',s)]:=',';
- br:=4*round(ceil(agg^.textWidth(char_ptr(s))));
- ho:=4*round(ceil(agg^.fontHeight));
- setlength(buf,ho*br*4);
- agg^.attach(@(buf[0]), br, ho, br * 4);
- agg^.clearAll(0, 0, 0);
- agg^.lineColor(0, 0, 0, 255);
- agg^.fillColor(255, 255, 255, 255);
- agg^.rectangle(-2, -2, br+2, ho+2);
- agg^.lineColor(255, 0, 0, 255);
- agg^.fillColor(0, 0, 0, 255);
- agg^.text(br div 2, ho div 2, char_ptr(s));
-
- ymax:=ho;
- b:=true;
- while b and (ymax>0) do begin
-   dec(ymax);
-   for i:=0 to br-1 do
-     if (buf[4*(i+br*ymax)+0]<>$ff) or
+var
+  buf:                           array of byte;
+  ho,br,ymax,ymin,xmax,xmin,i,j: longint;
+  b:                             boolean;
+begin
+  while pos('.',s)>0 do
+    s[pos('.',s)]:=',';
+  br:=4*round(ceil(agg^.textWidth(char_ptr(s))));
+  ho:=4*round(ceil(agg^.fontHeight));
+  setlength(buf,ho*br*4);
+  agg^.attach(@(buf[0]), br, ho, br * 4);
+  agg^.clearAll(0, 0, 0);
+  agg^.lineColor(0, 0, 0, 255);
+  agg^.fillColor(255, 255, 255, 255);
+  agg^.rectangle(-2, -2, br+2, ho+2);
+  agg^.lineColor(255, 0, 0, 255);
+  agg^.fillColor(0, 0, 0, 255);
+  agg^.text(br div 2, ho div 2, char_ptr(s));
+
+  ymax:=ho;
+  b:=true;
+  while b and (ymax>0) do begin
+    dec(ymax);
+    for i:=0 to br-1 do
+      if (buf[4*(i+br*ymax)+0]<>$ff) or
         (buf[4*(i+br*ymax)+1]<>$ff) or
         (buf[4*(i+br*ymax)+2]<>$ff) then
-       b:=false;
- end;
- if b then begin
-   gibAus('Leeres Bild!',3);
-   halt(1);
- end;
- ymin:=-1;
- b:=true;
- while b and (ymin<ymax) do begin
-   inc(ymin);
-   for i:=0 to br-1 do
-     if (buf[4*(i+br*ymin)+0]<>$ff) or
+        b:=false;
+  end;
+  if b then begin
+    gibAus('Leeres Bild!',3);
+    halt(1);
+  end;
+  ymin:=-1;
+  b:=true;
+  while b and (ymin<ymax) do begin
+    inc(ymin);
+    for i:=0 to br-1 do
+      if (buf[4*(i+br*ymin)+0]<>$ff) or
         (buf[4*(i+br*ymin)+1]<>$ff) or
         (buf[4*(i+br*ymin)+2]<>$ff) then
-       b:=false;
- end;
- if b then begin
-   gibAus('Leeres Bild!',3);
-   halt(1);
- end;
-
- xmax:=br;
- b:=true;
- while b and (xmax>0) do begin
-   dec(xmax);
-   for i:=ymin to ymax do
-     if (buf[4*(xmax+br*i)+0]<>$ff) or
+        b:=false;
+  end;
+  if b then begin
+    gibAus('Leeres Bild!',3);
+    halt(1);
+  end;
+
+  xmax:=br;
+  b:=true;
+  while b and (xmax>0) do begin
+    dec(xmax);
+    for i:=ymin to ymax do
+      if (buf[4*(xmax+br*i)+0]<>$ff) or
         (buf[4*(xmax+br*i)+1]<>$ff) or
         (buf[4*(xmax+br*i)+2]<>$ff) then
-       b:=false;
- end;
- if b then begin
-   gibAus('Leeres Bild!',3);
-   halt(1);
- end;
- xmin:=-1;
- b:=true;
- while b and (xmin<=xmax) do begin
-   inc(xmin);
-   for i:=ymin to ymax do
-     if (buf[4*(xmin+br*i)+0]<>$ff) or
+        b:=false;
+  end;
+  if b then begin
+    gibAus('Leeres Bild!',3);
+    halt(1);
+  end;
+  xmin:=-1;
+  b:=true;
+  while b and (xmin<=xmax) do begin
+    inc(xmin);
+    for i:=ymin to ymax do
+      if (buf[4*(xmin+br*i)+0]<>$ff) or
         (buf[4*(xmin+br*i)+1]<>$ff) or
         (buf[4*(xmin+br*i)+2]<>$ff) then
-       b:=false;
- end;
- if b then begin
-   gibAus('Leeres Bild!',3);
-   halt(1);
- end;
-
- dec(xmin);
- dec(ymin);
- inc(xmax);
- inc(ymax);
-
- result.breite:=xmax-xmin+1;
- result.hoehe:=ymax-ymin+1;
-
- setlength(result.farben,result.breite*result.hoehe);
- for i:=0 to result.breite-1 do
-   for j:=0 to result.hoehe-1 do begin
-     result.farben[i + j*result.breite].rgbBlue:= byte(buf[4*(i+xmin+br*(j+ymin))+0]);
-     result.farben[i + j*result.breite].rgbGreen:=byte(buf[4*(i+xmin+br*(j+ymin))+1]);
-     result.farben[i + j*result.breite].rgbRed:=  byte(buf[4*(i+xmin+br*(j+ymin))+2]);
-   end;
+        b:=false;
+  end;
+  if b then begin
+    gibAus('Leeres Bild!',3);
+    halt(1);
+  end;
+
+  dec(xmin);
+  dec(ymin);
+  inc(xmax);
+  inc(ymax);
+
+  result.breite:=xmax-xmin+1;
+  result.hoehe:=ymax-ymin+1;
+
+  setlength(result.farben,result.breite*result.hoehe);
+  for i:=0 to result.breite-1 do
+    for j:=0 to result.hoehe-1 do begin
+      result.farben[i + j*result.breite].rgbBlue:= byte(buf[4*(i+xmin+br*(j+ymin))+0]);
+      result.farben[i + j*result.breite].rgbGreen:=byte(buf[4*(i+xmin+br*(j+ymin))+1]);
+      result.farben[i + j*result.breite].rgbRed:=  byte(buf[4*(i+xmin+br*(j+ymin))+2]);
+    end;
 { for i:=0 to 1 do
-   for j:=0 to 1 do begin
-     result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbRed:=
-       result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbRed xor $ff;
-     result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbGreen:=
-       result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbGreen xor $ff;
-     result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbBlue:=
-       result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbBlue xor $ff;
-   end; }
- setlength(buf,0);
+    for j:=0 to 1 do begin
+      result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbRed:=
+        result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbRed xor $ff;
+      result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbGreen:=
+        result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbGreen xor $ff;
+      result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbBlue:=
+        result.farben[i*(result.breite-1) + j*(result.hoehe-1)*result.breite].rgbBlue xor $ff;
+    end; }
+  setlength(buf,0);
 end;
 
 // tTransformation *************************************************************
 
+constructor tTransformation.create;
+begin
+  inherited create;
+  fillchar(vorgaenger,sizeOf(vorgaenger),#0);
+  fillchar(nachfolger,sizeOf(nachfolger),#0);
+end;
+
+destructor tTransformation.destroy;
+var
+  i: longint;
+begin
+  for i:=0 to length(vorgaenger)-1 do
+    vorgaenger[i].loescheNachfolger(self);
+  setlength(vorgaenger,0);
+  if hatNachfolger then begin
+    gibAus('Ich habe noch '+inttostr(length(nachfolger))+' Nachfolger, da kann ich mich nicht zerstören!',3);
+    raise exception.create('Ich habe noch '+inttostr(length(nachfolger))+' Nachfolger, da kann ich mich nicht zerstören!');
+  end;
+  inherited destroy;
+end;
+
+destructor tTransformation.freeAll;
+var
+  i: longint;
+begin
+  for i:=0 to length(vorgaenger)-1 do
+    vorgaenger[i].loescheNachfolger(self);
+  if hatNachfolger then begin
+    gibAus('Ich habe noch '+inttostr(length(nachfolger))+' Nachfolger, da kann ich mich nicht zerstören!',3);
+    raise exception.create('Ich habe noch '+inttostr(length(nachfolger))+' Nachfolger, da kann ich mich nicht zerstören!');
+  end;
+  for i:=0 to length(vorgaenger)-1 do
+    vorgaenger[i].freeAll;
+  setlength(vorgaenger,0);
+  inherited destroy;
+end;
+
 procedure tTransformation.testeAuszerhalb(const p: tExtPoint);
 begin
- if (p['x']<0) or (p['x']>in_xs_ts['x']-1) or
-    (p['y']<0) or (p['y']>in_xs_ts['y']-1) then
-   raise exception.create('Punkt '+tExtPointToStr(p)+' liegt außerhalb des gültigen Eingabebereich (0..'+inttostr(in_xs_ts['x']-1)+' x 0..'+inttostr(in_xs_ts['y']-1)+')!');
+  if (p['x']<0) or (p['x']>in_xs_ts['x']-1) or
+    (p['y']<0) or (p['y']>in_xs_ts['y']-1) then begin
+    gibAus('Punkt '+tExtPointToStr(p)+' liegt außerhalb des gültigen Eingabebereich (0..'+inttostr(in_xs_ts['x']-1)+' x 0..'+inttostr(in_xs_ts['y']-1)+')!',3);
+    raise exception.create('Punkt '+tExtPointToStr(p)+' liegt außerhalb des gültigen Eingabebereich (0..'+inttostr(in_xs_ts['x']-1)+' x 0..'+inttostr(in_xs_ts['y']-1)+')!');
+  end;
+end;
+
+procedure tTransformation.aktualisiereAchsen; // nicht zum direkten Aufrufen
+begin
+end;
+
+procedure tTransformation.aktualisiereXsTs;   // nicht zum direkten Aufrufen
+begin
 end;
 
-function tTransformation.transformiereKoordinaten(const x,y: longint): tExtPoint;
-var p: tExtPoint;
+procedure tTransformation.aktualisiereWmia;   // nicht zum direkten Aufrufen
 begin
- p['x']:=x;
- p['y']:=y;
- result:=transformiereKoordinaten(p);
 end;
 
-function tTransformation.transformiereKoordinaten(const p: tExtPoint): tExtPoint;
+function tTransformation.rXstart: extended;
 begin
- result:=p;
- testeAuszerhalb(p);
+  result:=out_achsen['x','x'];
 end;
 
-function tTransformation.transformiereWert(const x: extended): extended;
+procedure tTransformation.wXstart(x: extended);
 begin
- result:=x;
+  if not (self is tKeineTransformation) then begin
+    gibAus('Will xstart schreiben, aber bin nicht der Anfang einer Transformationskette!',3);
+    raise exception.create('Will xstart schreiben, aber bin nicht der Anfang einer Transformationskette!');
+  end;
+  in_achsen['x','x']:=x;
+  aktualisiereAlles;
+end;
+
+function tTransformation.rXstop: extended;
+begin
+  result:=out_Achsen['x','y'];
+end;
+
+procedure tTransformation.wXstop(x: extended);
+begin
+  if not (self is tKeineTransformation) then begin
+    gibAus('Will xstop schreiben, aber bin nicht der Anfang einer Transformationskette!',3);
+    raise exception.create('Will xstop schreiben, aber bin nicht der Anfang einer Transformationskette!');
+  end;
+  in_achsen['x','y']:=x;
+  aktualisiereAlles;
 end;
 
-function tTransformation.xsteps_tsiz: tIntPoint;
+function tTransformation.rTstart: extended;
 begin
- result:=in_xs_ts;
+  result:=out_Achsen['y','x'];
 end;
 
-function tTransformation.achsen: t2x2Extended;
-var c,d: char;
+procedure tTransformation.wTstart(t: extended);
 begin
- for c:='x' to 'y' do
-   for d:='x' to 'y' do
-     result[c,d]:=in_achsen[c,d]*byte((in_xs_ts['x']>0) and (in_xs_ts['y']>0));
+  if not (self is tKeineTransformation) then begin
+    gibAus('Will tstart schreiben, aber bin nicht der Anfang einer Transformationskette!',3);
+    raise exception.create('Will tstart schreiben, aber bin nicht der Anfang einer Transformationskette!');
+  end;
+  in_achsen['y','x']:=t;
+  aktualisiereAlles;
+end;
+
+function tTransformation.rTstop: extended;
+begin
+  result:=out_Achsen['y','y'];
+end;
+
+procedure tTransformation.wTstop(t: extended);
+begin
+  if not (self is tKeineTransformation) then begin
+    gibAus('Will tstop schreiben, aber bin nicht der Anfang einer Transformationskette!',3);
+    raise exception.create('Will tstop schreiben, aber bin nicht der Anfang einer Transformationskette!');
+  end;
+  in_achsen['y','y']:=t;
+  aktualisiereAlles;
+end;
+
+function tTransformation.rWmin: extended;
+begin
+  result:=out_wmia['x'];
+end;
+
+procedure tTransformation.wWmin(w: extended);
+begin
+  out_wmia['x']:=w;
+  wmiaExplizit:=true;
+  aktualisiereAlles;
+end;
+
+function tTransformation.rWmax: extended;
+begin
+  result:=out_wmia['y'];
+end;
+
+procedure tTransformation.wWmax(w: extended);
+begin
+  wmiaExplizit:=true;
+  out_wmia['y']:=w;
+end;
+
+function tTransformation.rXsteps: longint;
+begin
+  result:=out_xs_ts['x'];
+end;
+
+procedure tTransformation.wXsteps(x: longint);
+begin
+  if not (self is tKeineTransformation) then begin
+    gibAus('Will xsteps schreiben, aber bin nicht der Anfang einer Transformationskette!',3);
+    raise exception.create('Will xsteps schreiben, aber bin nicht der Anfang einer Transformationskette!');
+  end;
+  in_xs_ts['x']:=x;
+end;
+
+function tTransformation.rTsiz: longint;
+begin
+  result:=out_xs_ts['y'];
+end;
+
+procedure tTransformation.wTsiz(t: longint);
+begin
+  if not (self is tKeineTransformation) then begin
+    gibAus('Will tsiz schreiben, aber bin nicht der Anfang einer Transformationskette!',3);
+    raise exception.create('Will tsiz schreiben, aber bin nicht der Anfang einer Transformationskette!');
+  end;
+  in_xs_ts['y']:=t;
+end;
+
+procedure tTransformation.fuegeNachfolgerHinzu(tr: tTransformation);
+begin
+  if assigned(tr) then begin
+    setlength(nachfolger,length(nachfolger)+1);
+    nachfolger[length(nachfolger)-1]:=tr;
+  end;
+end;
+
+procedure tTransformation.loescheNachfolger(tr: tTransformation);
+var
+  i,j: longint;
+begin
+  for i:=0 to length(nachfolger)-1 do
+    if nachfolger[i]=tr then begin
+      for j:=i+1 to length(nachfolger)-1 do
+        nachfolger[j-1]:=nachfolger[j];
+      setlength(nachfolger,length(nachfolger)-1);
+      exit;
+    end;
+  gibAus('Kann zu löschenden Nachfolger nicht finden!',3);
+  raise exception.create('Kann zu löschenden Nachfolger nicht finden!');
+end;
+
+procedure tTransformation.fuegeVorgaengerHinzu(tr: tTransformation);
+begin
+  if assigned(tr) then begin
+    setlength(vorgaenger,length(vorgaenger)+1);
+    vorgaenger[length(vorgaenger)-1]:=tr;
+  end;
+end;
+
+procedure tTransformation.loescheVorgaenger(tr: tTransformation);
+var
+  i,j: longint;
+begin
+  for i:=0 to length(vorgaenger)-1 do
+    if vorgaenger[i]=tr then begin
+      for j:=i+1 to length(vorgaenger)-1 do
+        vorgaenger[j-1]:=vorgaenger[j];
+      setlength(vorgaenger,length(vorgaenger)-1);
+      exit;
+    end;
+  gibAus('Kann zu löschenden Vorgänger nicht finden!',3);
+  raise exception.create('Kann zu löschenden Vorgänger nicht finden!');
+end;
+
+function tTransformation.hatNachfolger: boolean;
+begin
+  result:=length(nachfolger)>0;
+end;
+
+procedure tTransformation.aktualisiereAlles; // (inkl. Informieren der Nachfolger)
+var
+  i: longint;
+begin
+  aktualisiereAchsen;
+  aktualisiereWmia;
+  aktualisiereXsTs;
+  for i:=0 to length(nachfolger)-1 do
+    nachfolger[i].aktualisiereAlles;
+end;
+
+function tTransformation.ersetzeAnfangDurch(tr: tTransformation): boolean;
+begin
+  result:=false;
+
+  if length(vorgaenger)<>1 then begin
+    gibAus('Kann Anfang von Transformation nicht ersetzen, da nicht genau ein Vorgänger!',3);
+    exit;
+  end;
+
+  if vorgaenger[0] is tKeineTransformation then begin
+    vorgaenger[0].loescheNachfolger(self);
+    if not vorgaenger[0].hatNachfolger then
+      vorgaenger[0].free;
+    vorgaenger[0]:=tr;
+    vorgaenger[0].fuegeNachfolgerHinzu(self);
+    result:=true;
+  end
+  else
+    result:=vorgaenger[0].ersetzeAnfangDurch(tr);
+end;
+
+function tTransformation.beliebigerVorgaenger: tTransformation;
+begin
+  result:=vorgaenger[0];
+end;
+
+function tTransformation.transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint;
+begin
+  result:=p;
+  testeAuszerhalb(p);
+end;
+
+function tTransformation.transformiereKoordinaten(const p: tExtPoint; const tiefe: longint = -1): tExtPoint;
+begin
+  if (length(vorgaenger)>0) and (tiefe<>0) then
+    result:=vorgaenger[0].transformiereKoordinaten(p,tiefe-1)
+  else
+    result:=p;
+  result:=transformiereKoordinatenEinzeln(result);
+end;
+
+function tTransformation.transformiereKoordinaten(const x,y: longint; const tiefe: longint = -1): tExtPoint;
+var
+  p: tExtPoint;
+begin
+  p['x']:=x;
+  p['y']:=y;
+  result:=transformiereKoordinaten(p,tiefe);
+end;
+
+function tTransformation.wertZuPositionAufAchse(const l: tLage; x: extended): extended;
+var
+  c,d: char;
+  p:   tExtPoint;
+begin
+  c:=char(ord('x')+byte(l in [lOben,lUnten]));
+  d:=char(ord('y')-byte(l in [lOben,lUnten]));
+  p[c]:=(x-in_achsen[c,'x'])/(in_achsen[c,'y']-in_achsen[c,'x']);
+  p[d]:=byte(l in [lRechts,lOben]);
+
+  for d:='x' to 'y' do
+    p[d]:=p[d] * (in_xs_ts[d]-1);
+
+  transformiereKoordinaten(p,0);
+
+  result:=p[c]/(out_xs_ts[d]-1);
+end;
+
+function tTransformation.transformiereWertEinzeln(const x: extended): extended;
+begin
+  result:=x;
+end;
+
+function tTransformation.transformiereWert(const x: extended; const tiefe: longint = -1): extended;
+begin
+  if (length(vorgaenger)>0) and (tiefe<>0) then
+    result:=vorgaenger[0].transformiereWert(x,tiefe-1)
+  else
+    result:=x;
+  result:=transformiereWertEinzeln(result);
 end;
 
 function tTransformation.dumpParams: string;
 begin
- result:='';
+  result:='';
+end;
+
+function tTransformation.dumpParams(tiefe: longint): string;
+var
+  i: longint;
+begin
+  if tiefe=0 then
+    result:=''
+  else
+    for i:=0 to length(vorgaenger)-1 do begin
+      if length(vorgaenger)>1 then
+        result:=result+#13'< '+inttostr(i)+' >';
+      result:=result+#13+vorgaenger[i].dumpParams(tiefe-1);
+    end;
+  result:=result+inttostr(tiefe+1)+': '+dumpParams;
+end;
+
+// tUeberlagerung **************************************************************
+
+procedure tUeberlagerung.addKomponente(tr: tTransformation);
+begin
+  fuegeVorgaengerHinzu(tr);
 end;
 
 // tFFTTransformation **********************************************************
 
 constructor tFFTTransformation.create;
 begin
- inherited create;
- horizontal:=false;
- vertikal:=false;
+  inherited create;
+  horizontal:=false;
+  vertikal:=false;
 end;
 
-constructor tFFTTransformation.create(original: tFFTTransformation);
+constructor tFFTTransformation.create(vorg: tTransformation; hor,ver: boolean);
 begin
- inherited create;
- horizontal:=original.horizontal;
- vertikal:=original.vertikal;
+  inherited create;
+  fuegeVorgaengerHinzu(vorg);
+  horizontal:=hor;
+  vertikal:=ver;
 end;
 
-function tFFTTransformation.achsen: t2x2Extended;
-var c: char;
+procedure tFFTTransformation.aktualisiereAchsen;
+var
+  c: char;
 begin
- if horizontal then begin
-   result['x','x']:=0;
-   result['x','y']:=(in_xs_ts['x']-1)/(in_achsen['x','y']-in_achsen['x','x']);
- end
- else
-   for c:='x' to 'y' do
-     result['x',c]:=in_achsen['x',c];
- if vertikal then begin
-   result['y','x']:=0;
-   result['y','y']:=(in_xs_ts['y']-1)/(in_achsen['y','y']-in_achsen['y','x']);
- end
- else
-   for c:='x' to 'y' do
-     result['y',c]:=in_achsen['y',c];
+  if horizontal then begin
+    out_achsen['x','x']:=0;
+    out_achsen['x','y']:=(in_xs_ts['x']-1)/(in_achsen['x','y']-in_achsen['x','x']);
+  end
+  else
+    for c:='x' to 'y' do
+      out_achsen['x',c]:=in_achsen['x',c];
+  if vertikal then begin
+    out_achsen['y','x']:=0;
+    out_achsen['y','y']:=(in_xs_ts['y']-1)/(in_achsen['y','y']-in_achsen['y','x']);
+  end
+  else
+    for c:='x' to 'y' do
+      out_achsen['y',c]:=in_achsen['y',c];
 end;
 
 function tFFTTransformation.dumpParams: string;
 begin
- result:='FFT: ';
- if horizontal then result:=result+'h';
- if vertikal then result:=result+'v';
+  result:='FFT: ';
+  if horizontal then result:=result+'h';
+  if vertikal then result:=result+'v';
 end;
 
 // tSpiegelungsTransformation **************************************************
 
 constructor tSpiegelungsTransformation.create;
 begin
- inherited create;
+  inherited create;
 end;
 
-function tSpiegelungsTransformation.transformiereKoordinaten(const p: tExtPoint): tExtPoint;
+constructor tSpiegelungsTransformation.create(vorg: tTransformation);
 begin
- testeAuszerhalb(p);
- result['x']:=in_xs_ts['x']-1-p['x'];
- result['y']:=p['y'];
+  inherited create;
+  fuegeVorgaengerHinzu(vorg);
+end;
+
+function tSpiegelungsTransformation.transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint;
+begin
+  testeAuszerhalb(p);
+  result['x']:=in_xs_ts['x']-1-p['x'];
+  result['y']:=p['y'];
 end;
 
 function tSpiegelungsTransformation.dumpParams: string;
 begin
- result:='horizontale Spiegelung';
+  result:='horizontale Spiegelung';
 end;
 
 // tKonkreteKoordinatenTransformation ******************************************
 
 constructor tKonkreteKoordinatenTransformation.create;
-var c,d: char;
-begin
- for c:='x' to 'y' do begin
-   for d:='x' to 'y' do begin
-     lin[c,d]:=byte(c=d);
-     lnInt[c,d]:=0;
-     expExp[c,d]:=0;
-   end;
-   off[c]:=0;
-   lnFak[c]:=0;
-   expFak[c]:=0;
-   lnOff[c]:=1;
- end;
-end;
-
-constructor tKonkreteKoordinatenTransformation.create(original: tKonkreteKoordinatenTransformation);
-var c,d: char;
-begin
- for c:='x' to 'y' do begin
-   for d:='x' to 'y' do begin
-     lin[c,d]:=original.lin[c,d];
-     lnInt[c,d]:=original.lnInt[c,d];
-     expExp[c,d]:=original.expExp[c,d];
-   end;
-   off[c]:=original.off[c];
-   lnFak[c]:=original.lnFak[c];
-   expFak[c]:=original.expFak[c];
-   lnOff[c]:=original.lnOff[c];
- end;
+var
+  c,d: char;
+begin
+  for c:='x' to 'y' do begin
+    for d:='x' to 'y' do begin
+      lin[c,d]:=byte(c=d);
+      lnInt[c,d]:=0;
+      expExp[c,d]:=0;
+    end;
+    off[c]:=0;
+    lnFak[c]:=0;
+    expFak[c]:=0;
+    lnOff[c]:=1;
+  end;
 end;
 
 function tKonkreteKoordinatenTransformation.findeLineareParameter(syntaxtest: boolean; auszenSkala: char; s: string; xscale,yscale: extended; var off,xl,yl: extended; ueberschreiben: boolean; etf: tExprToFloat): boolean;
-var t:   string;
-    c:   char;
-    tmp: extended;
-begin
- result:=false;
- if ueberschreiben then begin
-   off:=0;
-   xl:=0;
-   yl:=0;
- end;
- while length(s)>0 do begin
-   t:=leftStr(s,max(binOpPos('+',s),binOpPos('-',s))-1);
-   if (binOpPos('+',t)>0) or (binOpPos('-',t)>0) then
-     t:=leftStr(s,min(binOpPos('+',s),binOpPos('-',s))-1);
-   if t='' then begin
-     t:=s;
-     s:='';
-   end
-   else
-     delete(s,1,length(t));
-   if t='' then exit;
-   c:=rightStr(t,1)[1];
-   if c in ['x','y'] then delete(t,length(t),1);
-   if leftStr(t,1)='+' then delete(t,1,1);
-   if t='' then tmp:=1
-   else if t='-' then tmp:=-1
-   else try
-     tmp:=etf(syntaxtest,t);
-     case c of
-       'x': tmp:=tmp*xscale;
-       'y': tmp:=tmp*yscale;
-     end;
-     case auszenSkala of
-       'x': tmp:=tmp/xscale;
-       'y': tmp:=tmp/yscale;
-     end;
-   except
-     exit;
-   end;
-   case c of
-     'x':
-       xl:=xl+tmp;
-     'y','t':
-       yl:=yl+tmp;
-     else
-       off:=off+tmp;
-   end{of case};
- end;
- result:=true;
-end;
-
-function tKonkreteKoordinatenTransformation.transformiereKoordinaten(const p: tExtPoint): tExtPoint;
-var c,d:   char;
-    lt,et: extended;
-begin
- testeAuszerhalb(p);
- for c:='x' to 'y' do begin
-   result[c]:=off[c];
-   lt:=lnOff[c];
-   et:=0;
-   for d:='x' to 'y' do begin
-     result[c]:=
-       result[c] + p[d]*lin[c,d];
-     lt:=lt+p[d]*lnInt[c,d];
-     et:=et+p[d]*expExp[c,d];
-   end;
-   result[c]:=
-     result[c] + lnFak[c] * ln(lt) + expFak[c] * exp(et);
- end;
+var
+  t:   string;
+  c:   char;
+  tmp: extended;
+begin
+  result:=false;
+  if ueberschreiben then begin
+    off:=0;
+    xl:=0;
+    yl:=0;
+  end;
+  while length(s)>0 do begin
+    t:=leftStr(s,max(binOpPos('+',s),binOpPos('-',s))-1);
+    if (binOpPos('+',t)>0) or (binOpPos('-',t)>0) then
+      t:=leftStr(s,min(binOpPos('+',s),binOpPos('-',s))-1);
+    if t='' then begin
+      t:=s;
+      s:='';
+    end
+    else
+      delete(s,1,length(t));
+    if t='' then exit;
+    c:=rightStr(t,1)[1];
+    if c in ['x','y'] then delete(t,length(t),1);
+    if leftStr(t,1)='+' then delete(t,1,1);
+    if t='' then tmp:=1
+    else if t='-' then tmp:=-1
+    else try
+      tmp:=etf(syntaxtest,t);
+      case c of
+        'x': tmp:=tmp*xscale;
+        'y': tmp:=tmp*yscale;
+      end;
+      case auszenSkala of
+        'x': tmp:=tmp/xscale;
+        'y': tmp:=tmp/yscale;
+      end;
+    except
+      exit;
+    end;
+    case c of
+      'x':
+        xl:=xl+tmp;
+      'y','t':
+        yl:=yl+tmp;
+      else
+        off:=off+tmp;
+    end{of case};
+  end;
+  result:=true;
+end;
+
+function tKonkreteKoordinatenTransformation.transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint;
+var
+  c,d:   char;
+  lt,et: extended;
+begin
+  testeAuszerhalb(p);
+  for c:='x' to 'y' do begin
+    result[c]:=off[c];
+    lt:=lnOff[c];
+    et:=0;
+    for d:='x' to 'y' do begin
+      result[c]:=
+        result[c] + p[d]*lin[c,d];
+      lt:=lt+p[d]*lnInt[c,d];
+      et:=et+p[d]*expExp[c,d];
+    end;
+    result[c]:=
+      result[c] + lnFak[c] * ln(lt) + expFak[c] * exp(et);
+  end;
 end;
 
 function tKonkreteKoordinatenTransformation.initAbbildung(syntaxtest: boolean; s: string; xscale,yscale: extended; etf: tExprToFloat): boolean;
-var c,d:   char;
-    i:     longint;
-    t,u,v: string;
-    tmp:   extended;
-begin
- result:=false;
- if not assigned(etf) then exit;
- for c:='x' to 'y' do begin
-   for d:='x' to 'y' do begin
-     lin[c,d]:=0;
-     lnInt[c,d]:=0;
-     expExp[c,d]:=0;
-   end;
-   off[c]:=0;
-   lnFak[c]:=0;
-   expFak[c]:=0;
-   lnOff[c]:=1;
- end;
- while pos(' ',s)>0 do
-   delete(s,pos(' ',s),1);
- if (not startetMit('(',s)) or
+var
+  c,d:   char;
+  i:     longint;
+  t,u,v: string;
+  tmp:   extended;
+begin
+  result:=false;
+  if not assigned(etf) then exit;
+  for c:='x' to 'y' do begin
+    for d:='x' to 'y' do begin
+      lin[c,d]:=0;
+      lnInt[c,d]:=0;
+      expExp[c,d]:=0;
+    end;
+    off[c]:=0;
+    lnFak[c]:=0;
+    expFak[c]:=0;
+    lnOff[c]:=1;
+  end;
+  while pos(' ',s)>0 do
+    delete(s,pos(' ',s),1);
+  if (not startetMit('(',s)) or
     (not endetMit(')',s)) then exit;
- if pos(';',s)=0 then exit;
- t:=erstesArgument(s,';');
- if (t='') or (s='') then exit;
- for c:='x' to 'y' do begin
-   while pos('(',t)>0 do begin
-     u:=t;
-     delete(u,1,pos('(',u));
-     if pos(')',u)=0 then exit;
-     u:=leftStr(u,pos(')',u)-1);
-     i:=pos('(',t);
-     while (i>=1) and not (t[i] in ['+','-']) do
-       dec(i);
-     if i=0 then i:=1;
-     v:=copy(t,i,pos('(',t)-i-3);
-     if leftStr(v,1)='+' then delete(v,1,1);
-     if v='' then tmp:=1
-     else if v='-' then tmp:=-1
-     else try
-       tmp:=etf(syntaxtest,v);
-       if c='x' then tmp:=tmp/xscale
-       else tmp:=tmp/yscale;
-     except
-       exit;
-     end;
-     if copy(t,pos('(',t)-3,3)='log' then begin
-       lnFak[c]:=tmp;
-       if not findeLineareParameter(syntaxtest,' ',u,xscale,yscale,lnOff[c],lnInt[c,'x'],lnInt[c,'y'],true,etf) then exit;
-     end
-     else if copy(t,pos('(',t)-3,3)='exp' then begin
-       expFak[c]:=tmp;
-       tmp:=0;
-       if not findeLineareParameter(syntaxtest,' ',u,xscale,yscale,tmp,expExp[c,'x'],expExp[c,'y'],true,etf) then exit;
-       if tmp<>0 then exit;
-     end
-     else exit;
-     delete(t,i,pos(')',t)-i+1);
-   end;
-   if t<>'' then
-     if not findeLineareParameter(syntaxtest,c,t,xscale,yscale,off[c],lin[c,'x'],lin[c,'y'],false,etf) then exit;
-   t:=s;
- end;
- result:=true;
+  if pos(';',s)=0 then exit;
+  t:=erstesArgument(s,';');
+  if (t='') or (s='') then exit;
+  for c:='x' to 'y' do begin
+    while pos('(',t)>0 do begin
+      u:=t;
+      delete(u,1,pos('(',u));
+      if pos(')',u)=0 then exit;
+      u:=leftStr(u,pos(')',u)-1);
+      i:=pos('(',t);
+      while (i>=1) and not (t[i] in ['+','-']) do
+        dec(i);
+      if i=0 then i:=1;
+      v:=copy(t,i,pos('(',t)-i-3);
+      if leftStr(v,1)='+' then delete(v,1,1);
+      if v='' then tmp:=1
+      else if v='-' then tmp:=-1
+      else try
+        tmp:=etf(syntaxtest,v);
+        if c='x' then tmp:=tmp/xscale
+        else tmp:=tmp/yscale;
+      except
+        exit;
+      end;
+      if copy(t,pos('(',t)-3,3)='log' then begin
+        lnFak[c]:=tmp;
+        if not findeLineareParameter(syntaxtest,' ',u,xscale,yscale,lnOff[c],lnInt[c,'x'],lnInt[c,'y'],true,etf) then exit;
+      end
+      else if copy(t,pos('(',t)-3,3)='exp' then begin
+        expFak[c]:=tmp;
+        tmp:=0;
+        if not findeLineareParameter(syntaxtest,' ',u,xscale,yscale,tmp,expExp[c,'x'],expExp[c,'y'],true,etf) then exit;
+        if tmp<>0 then exit;
+      end
+      else exit;
+      delete(t,i,pos(')',t)-i+1);
+    end;
+    if t<>'' then
+      if not findeLineareParameter(syntaxtest,c,t,xscale,yscale,off[c],lin[c,'x'],lin[c,'y'],false,etf) then exit;
+    t:=s;
+  end;
+  result:=true;
 end;
 
 function tKonkreteKoordinatenTransformation.dumpParams: string;
-var c,d: char;
-begin
- result:='';
- for c:='x' to 'y' do begin
-   result:=result+#13#10+c+' = ';
-   if off[c]<>0 then
-     result:=result + floattostr(off[c]) + ' ';
-   for d:='x' to 'y' do
-     if lin[c,d]<>0 then
-       result:=result + '+ ' + floattostr(lin[c,d]) + ' ' + d + ' ';
-   if lnFak[c]<>0 then begin
-     result:=result + '+ ' + floattostr(lnFak[c])+' log ( ';
-     if lnOff[c]<>0 then
-       result:=result + floattostr(lnoff[c]) + ' ';
-     for d:='x' to 'y' do
-       if lnInt[c,d]<>0 then
-         result:=result + '+ ' + floattostr(lnInt[c,d]) + ' ' + d + ' ';
-     result:=result + ') ';
-   end;
-   if expFak[c]<>0 then begin
-     result:=result + '+ ' + floattostr(expFak[c])+' exp ( ';
-     for d:='x' to 'y' do
-       if expExp[c,d]<>0 then
-         result:=result + '+ ' + floattostr(expExp[c,d]) + ' ' + d + ' ';
-     result:=result + ') ';
-   end;
- end;
- delete(result,1,2);
+var
+  c,d: char;
+begin
+  result:='';
+  for c:='x' to 'y' do begin
+    result:=result+#13#10+c+' = ';
+    if off[c]<>0 then
+      result:=result + floattostr(off[c]) + ' ';
+    for d:='x' to 'y' do
+      if lin[c,d]<>0 then
+        result:=result + '+ ' + floattostr(lin[c,d]) + ' ' + d + ' ';
+    if lnFak[c]<>0 then begin
+      result:=result + '+ ' + floattostr(lnFak[c])+' log ( ';
+      if lnOff[c]<>0 then
+        result:=result + floattostr(lnoff[c]) + ' ';
+      for d:='x' to 'y' do
+        if lnInt[c,d]<>0 then
+          result:=result + '+ ' + floattostr(lnInt[c,d]) + ' ' + d + ' ';
+      result:=result + ') ';
+    end;
+    if expFak[c]<>0 then begin
+      result:=result + '+ ' + floattostr(expFak[c])+' exp ( ';
+      for d:='x' to 'y' do
+        if expExp[c,d]<>0 then
+          result:=result + '+ ' + floattostr(expExp[c,d]) + ' ' + d + ' ';
+      result:=result + ') ';
+    end;
+  end;
+  delete(result,1,2);
 end;
 
 function tKonkreteKoordinatenTransformation.zielausdehnung: t2x2Longint;
-var RandPkt: tExtPoint;
-    i,j,k:   longint;
-    c,d:     char;
-begin
- for c:='x' to 'y' do
-   for d:='x' to 'y' do
-     result[c,d]:=-1;
- for k:=0 to 1 do
-   for i:=0 to (in_xs_ts['x']*(1-k)+in_xs_ts['y']*k)-1 do
-     for j:=0 to 1 do begin
-       RandPkt:=transformiereKoordinaten(
-         i*(1-k)                + j*k*(in_xs_ts['x']-1),
-         j*(1-k)*(in_xs_ts['y']-1) + i*k);
-       for c:='x' to 'y' do
-         for d:='x' to 'y' do
-           if ((i=0) and (j=0)) or ((d='y') xor (result[c,d]>floor(RandPkt[c]) + byte(d='y'))) then
-             result[c,d]:=floor(RandPkt[c]) + byte(d='y');
-     end;
-end;
-
-function tKonkreteKoordinatenTransformation.xsteps_tsiz: tIntPoint;
-var gr: t2x2Longint;
-    c:  char;
-begin
- gr:=zielausdehnung;
- for c:='x' to 'y' do
-   result[c]:=gr[c,'y']-gr[c,'x']+1;
+var
+  RandPkt: tExtPoint;
+  i,j,k:   longint;
+  c,d:     char;
+begin
+  for c:='x' to 'y' do
+    for d:='x' to 'y' do
+      result[c,d]:=-1;
+  for k:=0 to 1 do
+    for i:=0 to (in_xs_ts['x']*(1-k)+in_xs_ts['y']*k)-1 do
+      for j:=0 to 1 do begin
+        RandPkt:=transformiereKoordinaten(
+          i*(1-k)                + j*k*(in_xs_ts['x']-1),
+          j*(1-k)*(in_xs_ts['y']-1) + i*k);
+        for c:='x' to 'y' do
+          for d:='x' to 'y' do
+            if ((i=0) and (j=0)) or ((d='y') xor (result[c,d]>floor(RandPkt[c]) + byte(d='y'))) then
+              result[c,d]:=floor(RandPkt[c]) + byte(d='y');
+      end;
+end;
+
+procedure tKonkreteKoordinatenTransformation.aktualisiereXsTs;
+var
+  gr: t2x2Longint;
+  c:  char;
+begin
+  gr:=zielausdehnung;
+  for c:='x' to 'y' do
+    out_xs_ts[c]:=gr[c,'y']-gr[c,'x']+1;
 end;
 
 // tKoordinatenAusschnitt ******************************************************
 
 constructor tKoordinatenAusschnitt.create;
-var c,d: char;
+var
+  c,d: char;
 begin
- inherited create;
- for c:='x' to 'y' do
-   for d:='x' to 'y' do
-     gr[c,d]:=0;
+  inherited create;
+  for c:='x' to 'y' do
+    for d:='x' to 'y' do
+      gr[c,d]:=0;
 end;
 
-constructor tKoordinatenAusschnitt.create(original: tKoordinatenAusschnitt);
-var c,d: char;
+constructor tKoordinatenAusschnitt.create(vorg: tTransformation; xmin,xmax,tmin,tmax: longint);
 begin
- inherited create;
- for c:='x' to 'y' do
-   for d:='x' to 'y' do
-     gr[c,d]:=original.gr[c,d];
+  inherited create;
+  fuegeVorgaengerHinzu(vorg);
+  gr['x','x']:=xmin;
+  gr['x','y']:=xmax;
+  gr['y','x']:=tmin;
+  gr['y','y']:=tmax;
 end;
 
-function tKoordinatenAusschnitt.xsteps_tsiz: tIntPoint;
-var c: char;
+procedure tKoordinatenAusschnitt.aktualisiereXsTs;
+var
+  c: char;
 begin
- for c:='x' to 'y' do
-   result[c]:=max(0,min(in_xs_ts[c],gr[c,'y']+1)-gr[c,'x']);
+  for c:='x' to 'y' do
+    out_xs_ts[c]:=max(0,min(in_xs_ts[c],gr[c,'y']+1)-gr[c,'x']);
 end;
 
-function tKoordinatenAusschnitt.achsen: t2x2Extended;
-var c,d: char;
+procedure tKoordinatenAusschnitt.aktualisiereAchsen;
+var
+  c,d: char;
 begin
- for c:='x' to 'y' do
-   if in_xs_ts[c]<=1 then begin
-     for d:='x' to 'y' do
-       result[c,d]:=in_achsen[c,d];
-     if in_achsen[c,'x']<>in_achsen[c,'y'] then
-       fehler('Nur eine Koordinate, aber '+floattostr(in_achsen[c,'x'])+' = '+c+'start <> '+c+'stop = '+floattostr(in_achsen[c,'y'])+'!');
-   end
-   else
-     for d:='x' to 'y' do
-       result[c,d]:=in_achsen[c,'x'] + gr[c,d]/(in_xs_ts[c]-1)*(in_achsen[c,'y']-in_achsen[c,'x']);
+  for c:='x' to 'y' do
+    if in_xs_ts[c]<=1 then begin
+      for d:='x' to 'y' do
+        out_achsen[c,d]:=in_achsen[c,d];
+      if in_achsen[c,'x']<>in_achsen[c,'y'] then
+        fehler('Nur eine Koordinate, aber '+floattostr(in_achsen[c,'x'])+' = '+c+'start <> '+c+'stop = '+floattostr(in_achsen[c,'y'])+'!');
+    end
+    else
+      for d:='x' to 'y' do
+        out_achsen[c,d]:=in_achsen[c,'x'] + gr[c,d]/(in_xs_ts[c]-1)*(in_achsen[c,'y']-in_achsen[c,'x']);
 end;
 
-function tKoordinatenAusschnitt.transformiereKoordinaten(const p: tExtPoint): tExtPoint;
-var c: char;
+function tKoordinatenAusschnitt.transformiereKoordinatenEinzeln(const p: tExtPoint): tExtPoint;
+var
+  c: char;
 begin
- testeAuszerhalb(p);
- for c:='x' to 'y' do
-   result[c]:=max(0,min(gr[c,'y'],p[c])-gr[c,'x']);
+  testeAuszerhalb(p);
+  for c:='x' to 'y' do
+    result[c]:=max(0,min(gr[c,'y'],p[c])-gr[c,'x']);
 end;
 
 function tKoordinatenAusschnitt.dumpParams: string;
 begin
- result:='Koordinatenausschnitt: '+inttostr(gr['x','x'])+'..'+inttostr(gr['x','y'])+' x '+inttostr(gr['y','x'])+'..'+inttostr(gr['y','y']);
+  result:='Koordinatenausschnitt: '+inttostr(gr['x','x'])+'..'+inttostr(gr['x','y'])+' x '+inttostr(gr['y','x'])+'..'+inttostr(gr['y','y']);
 end;
 
 // tAgglomeration **************************************************************
@@ -1486,55 +1819,68 @@ end;
 constructor tAgglomeration.create;
 begin
   inherited create;
-  schritt:=0;
-  anzahl:=0;
+  schritt:=-1;
   horizontal:=false;
 end;
 
-constructor tAgglomeration.create(original: tAgglomeration);
+procedure tAgglomeration.addKomponente(tr: tTransformation);
 begin
-  inherited create;
-  schritt:=original.schritt;
-  anzahl:=original.anzahl;
-  horizontal:=original.horizontal;
+  fuegeVorgaengerHinzu(tr);
 end;
 
-function tAgglomeration.xsteps_tsiz: tIntPoint;
+procedure tAgglomeration.aktualisiereXsTs;
 var
   c: char;
 begin
   for c:='x' to 'y' do
-    result[c]:=in_xs_ts[c]*(1+(anzahl-1)*byte(horizontal xor (c='y')));
+    out_xs_ts[c]:=in_xs_ts[c]*(1+(length(vorgaenger)-1)*byte(horizontal xor (c='y')));
 end;
 
-function tAgglomeration.achsen: t2x2Extended;
+procedure tAgglomeration.aktualisiereAchsen;
 var
   c,d: char;
 begin
   for c:='x' to 'y' do
-    if in_xs_ts[c]<=1 then begin
+    if in_xs_ts[c]<=1 then begin // diese Dimension gibt es in der Quelle nicht
+      if (horizontal xor (c='y')) and (schritt<0) then
+        fehler('Die Richtung einer Agglomeration ohne explizite Schrittweite kann nicht senkrecht zur Dimension eindimensionaler Daten sein!');
       for d:='x' to 'y' do
-        result[c,d]:=in_achsen[c,d] + schritt*(anzahl-1)*byte((horizontal xor (c='y')) and (d='y'));
+        out_achsen[c,d]:=in_achsen[c,d] + schritt*(length(vorgaenger)-1)*byte((horizontal xor (c='y')) and (d='y'));
       if in_achsen[c,'x']<>in_achsen[c,'y'] then
         fehler('Nur eine Koordinate, aber '+floattostr(in_achsen[c,'x'])+' = '+c+'start <> '+c+'stop = '+floattostr(in_achsen[c,'y'])+'!');
     end
-    else begin
-      if horizontal xor (c='y') then
-        fehler('In der Richtung der Agglomeration ('+c+') können nicht mehrere Daten liegen!');
+    else // diese Dimension gibt es in der Quelle
       for d:='x' to 'y' do
-        result[c,d]:=in_achsen[c,d];
-    end;
+        out_achsen[c,d]:=
+          in_achsen[c,d] +
+          (in_achsen[c,'y']-in_achsen[c,'x'])/
+            (1+1/in_xs_ts[c]) *
+            (length(vorgaenger)-1) *
+              byte((horizontal xor (c='y')) and (d='y'));
 end;
 
-function tAgglomeration.transformiereKoordinaten(const p: tExtPoint): tExtPoint;
+function tAgglomeration.wertZuPositionAufAchse(const l: tLage; x: extended): extended;
+var
+  i: longint;
+  c: char;
 begin
-  testeAuszerhalb(p);
-  result:=p; // es ist etwas unpräzise, schließlich landet p des i-ten Datensatzes auf p + i * schritt * (byte(horizontal);byte(not horizontal))
+  i:=0;
+  if horizontal xor not (l in [lOben,lUnten]) then begin
+    c:=char(ord('x')+byte(l in [lOben,lUnten]));
+    while (i<length(vorgaenger)) and (vorgaenger[i].achsen[c,'y']<x) do
+      inc(i);
+  end;
+
+  if (i>=length(vorgaenger)) or
+      (vorgaenger[i].achsen[c,'x']>x) then result:=0
+  else result:=vorgaenger[i].wertZuPositionAufAchse(l,x);
+
+  result:=(result+i)/length(vorgaenger);
 end;
 
 function tAgglomeration.dumpParams: string;
 begin
-  result:='Agglomeration: '+inttostr(anzahl)+'x ';
+  result:='Agglomeration: '+inttostr(length(vorgaenger))+'x ';
   if horizontal then
     result:=result+'horizont'
   else
@@ -1546,475 +1892,462 @@ end;
 
 constructor tWerteKnickTransformation.create;
 begin
- inherited create;
- setlength(parameter,0);
-end;
-
-constructor tWerteKnickTransformation.create(original: tWerteKnickTransformation);
-var i: longint;
-begin
- inherited create;
- setlength(parameter,length(original.parameter));
- for i:=0 to length(parameter)-1 do
-   parameter[i]:=original.parameter[i];
+  inherited create;
+  setlength(parameter,0);
 end;
 
 destructor tWerteKnickTransformation.destroy;
 begin
- setlength(parameter,0);
- inherited destroy;
+  setlength(parameter,0);
+  inherited destroy;
 end;
 
-function tWerteKnickTransformation.transformiereWert(const x: extended): extended;
-var i: longint;
+function tWerteKnickTransformation.transformiereWertEinzeln(const x: extended): extended;
+var
+  i: longint;
 begin
- if x>=parameter[length(parameter)-2] then begin
-   result:=parameter[length(parameter)-1];
-   exit;
- end;
- i:=0;
- while (i<length(parameter)-2) and (x>=parameter[i+2]) do
-   inc(i,2);
- result:=x-parameter[i];
- result:=result/(parameter[i+2]-parameter[i]);
- result:=parameter[i+1]+result*(parameter[i+3]-parameter[i+1])
+  if x>=parameter[length(parameter)-2] then begin
+    result:=parameter[length(parameter)-1];
+    exit;
+  end;
+  i:=0;
+  while (i<length(parameter)-2) and (x>=parameter[i+2]) do
+    inc(i,2);
+  result:=x-parameter[i];
+  result:=result/(parameter[i+2]-parameter[i]);
+  result:=parameter[i+1]+result*(parameter[i+3]-parameter[i+1])
 end;
 
 function tWerteKnickTransformation.dumpParams: string;
-var i: longint;
+var
+  i: longint;
 begin
- result:='Knick:';
- for i:=0 to length(parameter) div 2 - 1 do
-   result:=result + ' (' + floattostr(parameter[2*i])+';'+floattostr(parameter[2*i+1])+')';
+  result:='Knick:';
+  for i:=0 to length(parameter) div 2 - 1 do
+    result:=result + ' (' + floattostr(parameter[2*i])+';'+floattostr(parameter[2*i+1])+')';
 end;
 
 // tWerteLogTransformation *****************************************************
 
 constructor tWerteLogTransformation.create;
 begin
- inherited create;
- logMin:=0.1;
-end;
-
-constructor tWerteLogTransformation.create(original: tWerteLogTransformation);
-begin
- inherited create;
- logMin:=original.logMin;
+  inherited create;
+  logMin:=0.1;
 end;
 
-function tWerteLogTransformation.transformiereWert(const x: extended): extended;
+function tWerteLogTransformation.transformiereWertEinzeln(const x: extended): extended;
 begin
- result:=ln(max(x/logMin,1))/ln(max(1/logMin,1));
+  result:=ln(max(x/logMin,1))/ln(max(1/logMin,1));
 end;
 
 function tWerteLogTransformation.dumpParams: string;
 begin
- result:='Logarithmus: '+floattostr(logMin);
+  result:='Logarithmus: '+floattostr(logMin);
 end;
 
 // tWerteLogAbsTransformation **************************************************
 
 constructor tWerteLogAbsTransformation.create;
 begin
- inherited create;
- logSkala:=0.1;
-end;
-
-constructor tWerteLogAbsTransformation.create(original: tWerteLogAbsTransformation);
-begin
- inherited create;
- logSkala:=original.logSkala;
+  inherited create;
+  logSkala:=0.1;
 end;
 
-function tWerteLogAbsTransformation.transformiereWert(const x: extended): extended;
+function tWerteLogAbsTransformation.transformiereWertEinzeln(const x: extended): extended;
 begin
- result:=(1+sign(x-0.5)*ln(logSkala*abs(x-0.5)+1)/ln(logSkala*0.5+1))/2;
+  result:=(1+sign(x-0.5)*ln(logSkala*abs(x-0.5)+1)/ln(logSkala*0.5+1))/2;
 end;
 
 function tWerteLogAbsTransformation.dumpParams: string;
 begin
- result:='Betragslogarithmus: '+floattostr(logSkala);
+  result:='Betragslogarithmus: '+floattostr(logSkala);
 end;
 
 // tWerteAbsTransformation *****************************************************
 
 constructor tWerteAbsTransformation.create;
 begin
- inherited create;
+  inherited create;
 end;
 
-function tWerteAbsTransformation.transformiereWert(const x: extended): extended;
+function tWerteAbsTransformation.transformiereWertEinzeln(const x: extended): extended;
 begin
- result:=2*abs(x-0.5);
+  result:=2*abs(x-0.5);
 end;
 
 function tWerteAbsTransformation.dumpParams: string;
 begin
- result:='Betrag';
+  result:='Betrag';
 end;
 
 // tTransformationen ***********************************************************
-
+(*
 constructor tTransformationen.create;
 begin
- inherited create;
- setlength(Schritte,0);
+  inherited create;
+  setlength(Schritte,0);
 end;
 
 constructor tTransformationen.create(original: tTransformationen);
 begin
- inherited create;
- setlength(Schritte,0);
- if not kopiereVon(original) then
-   halt(1);
+  inherited create;
+  setlength(Schritte,0);
+  if not kopiereVon(original) then
+    halt(1);
 end;
 
 destructor tTransformationen.destroy;
-var i: longint;
+var
+  i: longint;
 begin
- for i:=0 to length(Schritte)-1 do
-   if assigned(Schritte[i]) then
-     Schritte[i].free;
- setlength(Schritte,0);
- inherited destroy;
+  for i:=0 to length(Schritte)-1 do
+    if assigned(Schritte[i]) then
+      Schritte[i].free;
+  setlength(Schritte,0);
+  inherited destroy;
 end;
 
 function tTransformationen.gibInhalt(ii: longint): tTransformation;
 begin
- result:=Schritte[ii];
+  result:=Schritte[ii];
 end;
 
 procedure tTransformationen.nimmInhalt(ii: longint; inh: tTransformation);
 begin
- Schritte[ii]:=inh;
+  Schritte[ii]:=inh;
 end;
 
 function tTransformationen.rXstart: extended;
 begin
- result:=gibAchsen['x','x'];
+  result:=gibAchsen['x','x'];
 end;
 
 procedure tTransformationen.wXstart(x: extended);
 begin
- if kCount>0 then begin
-   gibAus('Will xstart schreiben, aber der kCount ist '+inttostr(kCount),3);
-   raise exception.create('Will xstart schreiben, aber der kCount ist '+inttostr(kCount));
- end;
- _xtstao['x','x']:=x;
+  if kCount>0 then begin
+    gibAus('Will xstart schreiben, aber der kCount ist '+inttostr(kCount),3);
+    raise exception.create('Will xstart schreiben, aber der kCount ist '+inttostr(kCount));
+  end;
+  _xtstao['x','x']:=x;
 end;
 
 function tTransformationen.rXstop: extended;
 begin
- result:=gibAchsen['x','y'];
+  result:=gibAchsen['x','y'];
 end;
 
 procedure tTransformationen.wXstop(x: extended);
 begin
- if kCount>0 then begin
-   gibAus('Will xstop schreiben, aber der kCount ist '+inttostr(kCount),3);
-   raise exception.create('Will xstop schreiben, aber der kCount ist '+inttostr(kCount));
- end;
- _xtstao['x','y']:=x;
+  if kCount>0 then begin
+    gibAus('Will xstop schreiben, aber der kCount ist '+inttostr(kCount),3);
+    raise exception.create('Will xstop schreiben, aber der kCount ist '+inttostr(kCount));
+  end;
+  _xtstao['x','y']:=x;
 end;
 
 function tTransformationen.rTstart: extended;
 begin
- result:=gibAchsen['y','x'];
+  result:=gibAchsen['y','x'];
 end;
 
 procedure tTransformationen.wTstart(t: extended);
 begin
- if kCount>0 then begin
-   gibAus('Will tstart schreiben, aber der kCount ist '+inttostr(kCount),3);
-   raise exception.create('Will tstart schreiben, aber der kCount ist '+inttostr(kCount));
- end;
- _xtstao['y','x']:=t;
+  if kCount>0 then begin
+    gibAus('Will tstart schreiben, aber der kCount ist '+inttostr(kCount),3);
+    raise exception.create('Will tstart schreiben, aber der kCount ist '+inttostr(kCount));
+  end;
+  _xtstao['y','x']:=t;
 end;
 
 function tTransformationen.rTstop: extended;
 begin
- result:=gibAchsen['y','y'];
+  result:=gibAchsen['y','y'];
 end;
 
 procedure tTransformationen.wTstop(t: extended);
 begin
- if kCount>0 then begin
-   gibAus('Will tstop schreiben, aber der kCount ist '+inttostr(kCount),3);
-   raise exception.create('Will tstop schreiben, aber der kCount ist '+inttostr(kCount));
- end;
- _xtstao['y','y']:=t;
+  if kCount>0 then begin
+    gibAus('Will tstop schreiben, aber der kCount ist '+inttostr(kCount),3);
+    raise exception.create('Will tstop schreiben, aber der kCount ist '+inttostr(kCount));
+  end;
+  _xtstao['y','y']:=t;
 end;
 
 function tTransformationen.rWmin: extended;
 begin
- result:=_wmia['x'];
+  result:=_wmia['x'];
 end;
 
 procedure tTransformationen.wWmin(w: extended);
 begin
- _wmia['x']:=w;
+  _wmia['x']:=w;
 end;
 
 function tTransformationen.rWmax: extended;
 begin
- result:=_wmia['y'];
+  result:=_wmia['y'];
 end;
 
 procedure tTransformationen.wWmax(w: extended);
 begin
- _wmia['y']:=w;
+  _wmia['y']:=w;
 end;
 
 function tTransformationen.rXsteps: longint;
 begin
- result:=xsteps_tsiz['x'];
+  result:=xsteps_tsiz['x'];
 end;
 
 procedure tTransformationen.wXsteps(x: longint);
 begin
- if kCount>0 then begin
-   gibAus('Will xsteps schreiben, aber der kCount ist '+inttostr(kCount),3);
-   raise exception.create('Will xsteps schreiben, aber der kCount ist '+inttostr(kCount));
- end;
- _xs_ts['x']:=x;
+  if kCount>0 then begin
+    gibAus('Will xsteps schreiben, aber der kCount ist '+inttostr(kCount),3);
+    raise exception.create('Will xsteps schreiben, aber der kCount ist '+inttostr(kCount));
+  end;
+  _xs_ts['x']:=x;
 end;
 
 function tTransformationen.rTsiz: longint;
 begin
- result:=xsteps_tsiz['y'];
+  result:=xsteps_tsiz['y'];
 end;
 
 function tTransformationen.xsteps_tsiz: tIntPoint;
 begin
- if count=0 then result:=_xs_ts
- else result:=last.xsteps_tsiz;
+  if count=0 then result:=_xs_ts
+  else result:=last.xsteps_tsiz;
 end;
 
 procedure tTransformationen.wTsiz(t: longint);
 begin
- if kCount>0 then begin
-   gibAus('Will tsiz schreiben, aber der kCount ist '+inttostr(kCount),3);
-   raise exception.create('Will tsiz schreiben, aber der kCount ist '+inttostr(kCount));
- end;
- _xs_ts['y']:=t;
+  if kCount>0 then begin
+    gibAus('Will tsiz schreiben, aber der kCount ist '+inttostr(kCount),3);
+    raise exception.create('Will tsiz schreiben, aber der kCount ist '+inttostr(kCount));
+  end;
+  _xs_ts['y']:=t;
 end;
 
 function tTransformationen.count: longint;
 begin
- result:=length(Schritte);
+  result:=length(Schritte);
 end;
 
 function tTransformationen.kCount: longint;
-var i: longint;
+var
+  i: longint;
 begin
- result:=0;
- for i:=0 to count-1 do
-   if Inhalt[i] is tKoordinatenTransformation then
-     inc(result);
+  result:=0;
+  for i:=0 to count-1 do
+    if Inhalt[i] is tKoordinatenTransformation then
+      inc(result);
 end;
 
 function tTransformationen.wCount: longint;
-var i: longint;
+var
+  i: longint;
 begin
- result:=0;
- for i:=0 to count-1 do
-   if Inhalt[i] is tWerteTransformation then
-     inc(result);
+  result:=0;
+  for i:=0 to count-1 do
+    if Inhalt[i] is tWerteTransformation then
+      inc(result);
 end;
 
 procedure tTransformationen.achsenUndGroeszeAktualisieren;
-var i: longint;
+var
+  i: longint;
 begin
- for i:=0 to count-1 do begin
-   if i=0 then begin
-     schritte[i].in_xs_ts:=_xs_ts;
-     schritte[i].in_achsen:=_xtstao;
-   end
-   else begin
-     schritte[i].in_xs_ts:=schritte[i-1].xsteps_tsiz;
-     schritte[i].in_achsen:=schritte[i-1].achsen;
-   end
- end;
+  for i:=0 to count-1 do begin
+    if i=0 then begin
+      schritte[i].in_xs_ts:=_xs_ts;
+      schritte[i].in_achsen:=_xtstao;
+    end
+    else begin
+      schritte[i].in_xs_ts:=schritte[i-1].xsteps_tsiz;
+      schritte[i].in_achsen:=schritte[i-1].achsen;
+    end
+  end;
 end;
 
 function tTransformationen.gibAchsen: t2x2Extended;
 begin
- if count=0 then result:=_xtstao
- else result:=last.achsen;
+  if count=0 then result:=_xtstao
+  else result:=last.achsen;
 end;
 
 function tTransformationen.last: tTransformation;
 begin
- result:=gibInhalt(count-1);
+  result:=gibInhalt(count-1);
 end;
 
 procedure tTransformationen.clear;
-var i: longint;
+var
+  i: longint;
 begin
- for i:=0 to length(Schritte)-1 do
-   if assigned(Schritte[i]) then
-     Schritte[i].free;
- setlength(Schritte,0);
+  for i:=0 to length(Schritte)-1 do
+    if assigned(Schritte[i]) then
+      Schritte[i].free;
+  setlength(Schritte,0);
 end;
 
 procedure tTransformationen.clearWerte;
-var i,j: longint;
-begin
- for i:=0 to length(Schritte)-1 do
-   if assigned(Schritte[i]) and (Schritte[i] is tWerteTransformation) then
-     Schritte[i].free;
- j:=0;
- for i:=0 to length(Schritte)-1 do
-   if assigned(Schritte[i]) then begin
-     Schritte[j]:=Schritte[i];
-     inc(j);
-   end;
- setlength(Schritte,j);
- achsenUndGroeszeAktualisieren;
+var
+  i,j: longint;
+begin
+  for i:=0 to length(Schritte)-1 do
+    if assigned(Schritte[i]) and (Schritte[i] is tWerteTransformation) then
+      Schritte[i].free;
+  j:=0;
+  for i:=0 to length(Schritte)-1 do
+    if assigned(Schritte[i]) then begin
+      Schritte[j]:=Schritte[i];
+      inc(j);
+    end;
+  setlength(Schritte,j);
+  achsenUndGroeszeAktualisieren;
 end;
 
 procedure tTransformationen.addFFT(hor,ver: boolean);
 begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tFFTTransformation.create;
- with last as tFFTTransformation do begin
-   horizontal:=hor;
-   vertikal:=ver;
- end;
- achsenUndGroeszeAktualisieren;
+  setlength(Schritte,length(Schritte)+1);
+  Schritte[length(Schritte)-1]:=tFFTTransformation.create;
+  with last as tFFTTransformation do begin
+    horizontal:=hor;
+    vertikal:=ver;
+  end;
+  achsenUndGroeszeAktualisieren;
 end;
 
 procedure tTransformationen.AddSpiegelung;
 begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tSpiegelungsTransformation.create;
- achsenUndGroeszeAktualisieren;
+  setlength(Schritte,length(Schritte)+1);
+  Schritte[length(Schritte)-1]:=tSpiegelungsTransformation.create;
+  achsenUndGroeszeAktualisieren;
 end;
 
 function tTransformationen.add(inh: tTransformation): boolean;
 begin
- result:=false;
- setlength(Schritte,length(Schritte)+1);
- if inh is tFFTTransformation then
-   Schritte[length(Schritte)-1]:=tFFTTransformation.create(inh as tFFTTransformation)
- else if inh is tKoordinatenAusschnitt then
-   Schritte[length(Schritte)-1]:=tKoordinatenAusschnitt.create(inh as tKoordinatenAusschnitt)
- else if inh is tKonkreteKoordinatenTransformation then
-   Schritte[length(Schritte)-1]:=tKonkreteKoordinatenTransformation.create(inh as tKonkreteKoordinatenTransformation)
- else if inh is tSpiegelungsTransformation then
-   Schritte[length(Schritte)-1]:=tSpiegelungsTransformation.create
- else if inh is tWerteKnickTransformation then
-   Schritte[length(Schritte)-1]:=tWerteKnickTransformation.create(inh as tWerteKnickTransformation)
- else if inh is tWerteLogTransformation then
-   Schritte[length(Schritte)-1]:=tWerteLogTransformation.create(inh as tWerteLogTransformation)
- else if inh is tWerteLogAbsTransformation then
-   Schritte[length(Schritte)-1]:=tWerteLogAbsTransformation.create(inh as tWerteLogAbsTransformation)
- else if inh is tWerteAbsTransformation then
-   Schritte[length(Schritte)-1]:=tWerteAbsTransformation.create
- else begin
-   gibAus('Ich kann unbekannten Transformationstyp ('+inh.ClassName+') nicht einfügen, da ich ihn nicht kopieren kann!',3);
-   exit;
- end;
- achsenUndGroeszeAktualisieren;
- result:=true;
+  result:=false;
+  setlength(Schritte,length(Schritte)+1);
+  if inh is tFFTTransformation then
+    Schritte[length(Schritte)-1]:=tFFTTransformation.create(inh as tFFTTransformation)
+  else if inh is tKoordinatenAusschnitt then
+    Schritte[length(Schritte)-1]:=tKoordinatenAusschnitt.create(inh as tKoordinatenAusschnitt)
+  else if inh is tAgglomeration then
+    Schritte[length(Schritte)-1]:=tAgglomeration.create(inh as tAgglomeration)
+  else if inh is tKonkreteKoordinatenTransformation then
+    Schritte[length(Schritte)-1]:=tKonkreteKoordinatenTransformation.create(inh as tKonkreteKoordinatenTransformation)
+  else if inh is tSpiegelungsTransformation then
+    Schritte[length(Schritte)-1]:=tSpiegelungsTransformation.create
+  else if inh is tWerteKnickTransformation then
+    Schritte[length(Schritte)-1]:=tWerteKnickTransformation.create(inh as tWerteKnickTransformation)
+  else if inh is tWerteLogTransformation then
+    Schritte[length(Schritte)-1]:=tWerteLogTransformation.create(inh as tWerteLogTransformation)
+  else if inh is tWerteLogAbsTransformation then
+    Schritte[length(Schritte)-1]:=tWerteLogAbsTransformation.create(inh as tWerteLogAbsTransformation)
+  else if inh is tWerteAbsTransformation then
+    Schritte[length(Schritte)-1]:=tWerteAbsTransformation.create
+  else begin
+    gibAus('Ich kann unbekannten Transformationstyp ('+inh.ClassName+') nicht einfügen, da ich ihn nicht kopieren kann!',3);
+    exit;
+  end;
+  achsenUndGroeszeAktualisieren;
+  result:=true;
 end;
 
 function tTransformationen.add(st: boolean; s: string; f: tMyStringlist; etf: tExprToFloat): boolean;
-var i:   longint;
-begin
- result:=false;
- if s='Knick' then begin
-   setlength(Schritte,length(Schritte)+1);
-   Schritte[length(Schritte)-1]:=tWerteKnickTransformation.create;
-   with (last as tWerteKnickTransformation) do begin
-     setlength(parameter,2);
-     parameter[0]:=0;
-     parameter[1]:=0;
-     repeat
-       if not f.metaReadln(s,true) then begin
-         gibAus('Unerwartetes Dateiende!',3);
-         exit;
-       end;
-       if s='Ende' then break;
-       setlength(parameter,length(parameter)+2);
-       parameter[length(parameter)-2]:=
-         etf(st,erstesArgument(s,' '));
-       if s='' then s:=inttostr(length(parameter) div 2 - 1);
-       parameter[length(parameter)-1]:=
-         etf(st,s);
-     until false;
-     for i:=0 to length(parameter)-1 do
-       if odd(i) then
-         parameter[i]:=
-           parameter[i]/
-             (length(parameter) div 2);
-     setlength(parameter,length(parameter)+2);
-     parameter[length(parameter)-2]:= 1;
-     parameter[length(parameter)-1]:= 1;
-   end;
-   result:=true;
-   exit;
- end;
- if startetMit('Log:',s) then begin
-   setlength(Schritte,length(Schritte)+1);
-   Schritte[length(Schritte)-1]:=tWerteLogTransformation.create;
-   (last as tWerteLogTransformation).logMin:=etf(st,s);
-   result:=true;
-   exit;
- end;
- if startetMit('AbsLog:',s) then begin
-   setlength(Schritte,length(Schritte)+1);
-   Schritte[length(Schritte)-1]:=tWerteLogAbsTransformation.create;
-   (last as tWerteLogAbsTransformation).logSkala:=etf(st,s);
-   result:=true;
-   exit;
- end;
- if s='Abs' then begin
-   setlength(Schritte,length(Schritte)+1);
-   Schritte[length(Schritte)-1]:=tWerteAbsTransformation.create;
-   result:=true;
-   exit;
- end;
- gibAus('Kenne Nachbearbeitungsmethode '''+s+''' nicht!',3);
+var
+  i:   longint;
+begin
+  result:=false;
+  if s='Knick' then begin
+    setlength(Schritte,length(Schritte)+1);
+    Schritte[length(Schritte)-1]:=tWerteKnickTransformation.create;
+    with (last as tWerteKnickTransformation) do begin
+      setlength(parameter,2);
+      parameter[0]:=0;
+      parameter[1]:=0;
+      repeat
+        if not f.metaReadln(s,true) then begin
+          gibAus('Unerwartetes Dateiende!',3);
+          exit;
+        end;
+        if s='Ende' then break;
+        setlength(parameter,length(parameter)+2);
+        parameter[length(parameter)-2]:=
+          etf(st,erstesArgument(s,' '));
+        if s='' then s:=inttostr(length(parameter) div 2 - 1);
+        parameter[length(parameter)-1]:=
+          etf(st,s);
+      until false;
+      for i:=0 to length(parameter)-1 do
+        if odd(i) then
+          parameter[i]:=
+            parameter[i]/
+              (length(parameter) div 2);
+      setlength(parameter,length(parameter)+2);
+      parameter[length(parameter)-2]:= 1;
+      parameter[length(parameter)-1]:= 1;
+    end;
+    result:=true;
+    exit;
+  end;
+  if startetMit('Log:',s) then begin
+    setlength(Schritte,length(Schritte)+1);
+    Schritte[length(Schritte)-1]:=tWerteLogTransformation.create;
+    (last as tWerteLogTransformation).logMin:=etf(st,s);
+    result:=true;
+    exit;
+  end;
+  if startetMit('AbsLog:',s) then begin
+    setlength(Schritte,length(Schritte)+1);
+    Schritte[length(Schritte)-1]:=tWerteLogAbsTransformation.create;
+    (last as tWerteLogAbsTransformation).logSkala:=etf(st,s);
+    result:=true;
+    exit;
+  end;
+  if s='Abs' then begin
+    setlength(Schritte,length(Schritte)+1);
+    Schritte[length(Schritte)-1]:=tWerteAbsTransformation.create;
+    result:=true;
+    exit;
+  end;
+  gibAus('Kenne Nachbearbeitungsmethode '''+s+''' nicht!',3);
 end;
 
 function tTransformationen.add(syntaxtest: boolean; s: string; xscale,yscale: extended; etf: tExprToFloat): boolean;
 begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tKonkreteKoordinatenTransformation.create;
- result:=(last as tKonkreteKoordinatenTransformation).initAbbildung(syntaxtest,s,xscale,yscale,etf);
- achsenUndGroeszeAktualisieren;
+  setlength(Schritte,length(Schritte)+1);
+  Schritte[length(Schritte)-1]:=tKonkreteKoordinatenTransformation.create;
+  result:=(last as tKonkreteKoordinatenTransformation).initAbbildung(syntaxtest,s,xscale,yscale,etf);
+  achsenUndGroeszeAktualisieren;
 end;
 
 function tTransformationen.append(inhs: tTransformationen): boolean;
-var i: longint;
+var
+  i: longint;
 begin
- result:=true;
- for i:=0 to inhs.count-1 do
-   result:=result and add(inhs[i]);
- achsenUndGroeszeAktualisieren;
+  result:=true;
+  for i:=0 to inhs.count-1 do
+    result:=result and add(inhs[i]);
+  achsenUndGroeszeAktualisieren;
 end;
 
 procedure tTransformationen.addAusschnitt(xmin,xmax,tmin,tmax: longint);
 begin
- setlength(Schritte,length(Schritte)+1);
- Schritte[length(Schritte)-1]:=tKoordinatenAusschnitt.create;
- (last as tKoordinatenAusschnitt).gr['x','x']:=xmin;
- (last as tKoordinatenAusschnitt).gr['x','y']:=xmax;
- (last as tKoordinatenAusschnitt).gr['y','x']:=tmin;
- (last as tKoordinatenAusschnitt).gr['y','y']:=tmax;
- achsenUndGroeszeAktualisieren;
+  setlength(Schritte,length(Schritte)+1);
+  Schritte[length(Schritte)-1]:=tKoordinatenAusschnitt.create;
+  (last as tKoordinatenAusschnitt).gr['x','x']:=xmin;
+  (last as tKoordinatenAusschnitt).gr['x','y']:=xmax;
+  (last as tKoordinatenAusschnitt).gr['y','x']:=tmin;
+  (last as tKoordinatenAusschnitt).gr['y','y']:=tmax;
+  achsenUndGroeszeAktualisieren;
 end;
 
 function tTransformationen.addAgglomeration(horizontal: boolean; schritt: extended; anzahl: longint): boolean;
 begin
   result:=false;
-  if horizontal and (xsteps<>1) then begin
-    gibAus('Horizontale Agglomeration über in x-Richtung ausgedehnte Werte ist nicht erlaubt!',3);
-    exit;
-  end;
-  if (not horizontal) and (tsiz<>1) then begin
-    gibAus('Vertikale Agglomeration über in t-Richtung ausgedehnte Werte ist nicht erlaubt!',3);
+  if (xsteps_tsiz[char(ord('y')-byte(horizontal))]>1) xor (schritt<0) then begin
+    gibAus('Eine explizite Schrittweite ist genau dann anzugeben, wenn die Werte in der Agglomerationsrichtung keine Ausdehnung haben!',3);
     exit;
   end;
   setlength(Schritte,length(Schritte)+1);
@@ -2028,80 +2361,150 @@ end;
 
 function tTransformationen.kopiereVon(original: tTransformationen): boolean;
 begin
- clear;
- _xs_ts:=original._xs_ts;
- _xtstao:=original._xtstao;
- _wmia:=original._wmia;
- result:=append(original);
+  clear;
+  _xs_ts:=original._xs_ts;
+  _xtstao:=original._xtstao;
+  _wmia:=original._wmia;
+  result:=append(original);
 end;
 
 function tTransformationen.transformiereKoordinaten(const lage: tLage; const x: extended): extended;
-var p:   tExtPoint;
-    c,d: char;
+var
+  p:   tExtPoint;
+  c,d: char;
 begin
- c:=char(ord('x')+byte(not(lage in [lOben,lUnten])));
- d:=char(ord('x')+byte(lage in [lOben,lUnten]));
- if lage in [lLinks,lUnten] then p[d]:=0
- else p[d]:=1;
+  c:=char(ord('x')+byte(not(lage in [lOben,lUnten])));
+  d:=char(ord('x')+byte(lage in [lOben,lUnten]));
 
- p[c]:=(x-gibAchsen[c,'x'])/(gibAchsen[c,'y']-gibAchsen[c,'x']);
- for d:='x' to 'y' do
-   p[d]:=p[d]*(_xs_ts[d]-1);
- p:=transformiereKoordinaten(p);
- result:=p[c]/xsteps_tsiz[c];
+  p[d]:=byte(lage in [lRechts,lOben]);
+  p[c]:=(x-_xtstao[c,'x'])/(_xtstao[c,'y']-_xtstao[c,'x']);
+  for d:='x' to 'y' do
+    p[d]:=p[d]*(_xs_ts[d]-1);
+  p:=transformiereKoordinaten(p);
+  result:=p[c]/xsteps_tsiz[c];   writeln(' ',floattostr(result));
 end;
 
 function tTransformationen.transformiereKoordinaten(const x,y: extended): tExtPoint;
 begin
- result['x']:=x;
- result['y']:=y;
- result:=transformiereKoordinaten(result);
+  result['x']:=x;
+  result['y']:=y;
+  result:=transformiereKoordinaten(result);
 end;
 
 function tTransformationen.transformiereKoordinaten(const p: tExtPoint): tExtPoint;
-var i:     longint;
+var
+  i:     longint;
 begin
- result:=p;
- for i:=0 to count-1 do
-   result:=inhalt[i].transformiereKoordinaten(result);
+  result:=p;
+  for i:=0 to count-1 do
+    result:=inhalt[i].transformiereKoordinaten(result);
 end;
 
 function tTransformationen.transformiereWert(const x: extended): extended;
-var i: longint;
+var
+  i: longint;
 begin
- result:=x;
- for i:=0 to count-1 do
-   result:=inhalt[i].transformiereWert(result);
+  result:=x;
+  for i:=0 to count-1 do
+    result:=inhalt[i].transformiereWert(result);
 end;
 
 function tTransformationen.dumpParams: string;
-var i: longint;
+var
+  i: longint;
 begin
- result:=inttostr(xsteps)+' x '+inttostr(tsiz)+' ('+floattostr(xstart)+'..'+floattostr(xstop)+' x '+floattostr(tstart)+'..'+floattostr(tstop)+')';
- for i:=0 to count-1 do
-   result:=result+#10' '+inhalt[i].dumpParams;
+  result:=inttostr(xsteps)+' x '+inttostr(tsiz)+' ('+floattostr(xstart)+'..'+floattostr(xstop)+' x '+floattostr(tstart)+'..'+floattostr(tstop)+')';
+  for i:=0 to count-1 do
+    result:=result+#10' '+inhalt[i].dumpParams;
 end;
 
 procedure tTransformationen.berechneZielausdehnung(out grenzen: t2x2Longint);
-var RandPkt: tExtPoint;
-    i,j,k:   longint;
-    c,d:     char;
-begin
- for c:='x' to 'y' do
-   for d:='x' to 'y' do
-     grenzen[c,d]:=-1;
- for k:=0 to 1 do
-   for i:=0 to (_xs_ts['x']*(1-k)+_xs_ts['y']*k)-1 do
-     for j:=0 to 1 do begin
-       RandPkt:=transformiereKoordinaten(
-         i*(1-k)                 + j*k*(_xs_ts['x']-1),
-         j*(1-k)*(_xs_ts['y']-1) + i*k);
-       for c:='x' to 'y' do
-         for d:='x' to 'y' do
-           if ((d='y') xor (grenzen[c,d]>floor(RandPkt[c]) + byte(d='y'))) or
+var
+  RandPkt: tExtPoint;
+  i,j,k:   longint;
+  c,d:     char;
+begin
+  for c:='x' to 'y' do
+    for d:='x' to 'y' do
+      grenzen[c,d]:=-1;
+  for k:=0 to 1 do
+    for i:=0 to (_xs_ts['x']*(1-k)+_xs_ts['y']*k)-1 do
+      for j:=0 to 1 do begin
+        RandPkt:=transformiereKoordinaten(
+          i*(1-k)                 + j*k*(_xs_ts['x']-1),
+          j*(1-k)*(_xs_ts['y']-1) + i*k);
+        for c:='x' to 'y' do
+          for d:='x' to 'y' do
+            if ((d='y') xor (grenzen[c,d]>floor(RandPkt[c]) + byte(d='y'))) or
               ((k=0) and (i=0) and (j=0)) then
-             grenzen[c,d]:=floor(RandPkt[c]) + byte(d='y');
-     end;
+              grenzen[c,d]:=floor(RandPkt[c]) + byte(d='y');
+      end;
+end;
+*)
+
+function liesTWerteTransformationen(st: boolean; s: string; f: tMyStringlist; etf: tExprToFloat; var tr: tTransformation): boolean;
+var
+  i:   longint;
+  tmp: tTransformation;
+begin
+  result:=false;
+  if s='Knick' then begin
+    tmp:=tWerteKnickTransformation.create;
+    with (tmp as tWerteKnickTransformation) do begin
+      setlength(parameter,2);
+      parameter[0]:=0;
+      parameter[1]:=0;
+      repeat
+        if not f.metaReadln(s,true) then begin
+          gibAus('Unerwartetes Dateiende!',3);
+          exit;
+        end;
+        if s='Ende' then break;
+        setlength(parameter,length(parameter)+2);
+        parameter[length(parameter)-2]:=
+          etf(st,erstesArgument(s,' '));
+        if s='' then s:=inttostr(length(parameter) div 2 - 1);
+        parameter[length(parameter)-1]:=
+          etf(st,s);
+      until false;
+      for i:=0 to length(parameter)-1 do
+        if odd(i) then
+          parameter[i]:=
+            parameter[i]/
+              (length(parameter) div 2);
+      setlength(parameter,length(parameter)+2);
+      parameter[length(parameter)-2]:= 1;
+      parameter[length(parameter)-1]:= 1;
+    end;
+    result:=true;
+    tmp.fuegeVorgaengerHinzu(tr);
+    tr:=tmp;
+    exit;
+  end;
+  if startetMit('Log:',s) then begin
+    tmp:=tWerteLogTransformation.create;
+    (tmp as tWerteLogTransformation).logMin:=etf(st,s);
+    result:=true;
+    tmp.fuegeVorgaengerHinzu(tr);
+    tr:=tmp;
+    exit;
+  end;
+  if startetMit('AbsLog:',s) then begin
+    tmp:=tWerteLogAbsTransformation.create;
+    (tmp as tWerteLogAbsTransformation).logSkala:=etf(st,s);
+    result:=true;
+    tmp.fuegeVorgaengerHinzu(tr);
+    tr:=tmp;
+    exit;
+  end;
+  if s='Abs' then begin
+    tmp:=tWerteAbsTransformation.create;
+    result:=true;
+    tmp.fuegeVorgaengerHinzu(tr);
+    tr:=tmp;
+    exit;
+  end;
+  gibAus('Kenne Bearbeitungsmethode '''+s+''' nicht!',3);
 end;
 
 end.