"Nullen einfügen" neu

1 files changed, 110 insertions, 0 deletions

diff --git a/typenunit.pas b/typenunit.pas
index e101d46..6bbbdb4 100644
--- a/typenunit.pas
+++ b/typenunit.pas
@@ -458,6 +458,28 @@ type
     constructor create;
     function dumpParams: string; override;
   end;
+  tGroeszenVerdopplungsTransformation = class (tKoordinatenTransformation)
+  private
+    _horizontal,_vertikal: boolean;
+    procedure wHorizontal(h: boolean);
+    procedure wVertikal(v: boolean);
+  public
+    constructor create;
+    property horizontal: boolean
+      read _horizontal
+      write wHorizontal;
+    property vertikal: boolean
+      read _vertikal
+      write wVertikal;
+    procedure aktualisiereAchsen; override;
+    procedure aktualisiereXsTs; override;
+//    function transformiereKoordinatenEinzeln(const p: tExtPoint; auszerhalbIstFehler: boolean = true): tExtPoint; override;       // das ist erst relevant, wenn
+//    function transformiereKoordinatenEinzelnInvers(const p: tExtPoint; auszerhalbIstFehler: boolean = true): tExtPoint; override; // man _vorne_ Nullen anfügen kann!
+    // keine Änderung der Werte(skalierung)
+    function wertZuPositionAufAchse(const l: tLage; x: extended; auszerhalbIstFehler: boolean = true): extended; override;
+    function positionAufAchseZuWert(const l: tLage; x: extended; auszerhalbIstFehler: boolean = true): extended; override;
+    function dumpParams: string; override;
+  end;
   tLambdaZuOmegaTransformation = class (tKoordinatenTransformation)
   private
     _faktor:               extended;
@@ -2495,6 +2517,94 @@ begin
   result:='* ' + tExtPointToStr(fak) + ' ' + inherited dumpParams;
 end;
 
+// tGroeszenVerdopplungsTransformation *****************************************
+
+constructor tGroeszenVerdopplungsTransformation.create;
+begin
+  inherited create;
+  _horizontal:=false;
+  _vertikal:=false;
+end;
+
+procedure tGroeszenVerdopplungsTransformation.wHorizontal(h: boolean);
+begin
+  _horizontal:=h;
+  aktualisiereXsTs;
+  aktualisiereAchsen;
+end;
+
+procedure tGroeszenVerdopplungsTransformation.wVertikal(v: boolean);
+begin
+  _vertikal:=v;
+  aktualisiereXsTs;
+  aktualisiereAchsen;
+end;
+
+procedure tGroeszenVerdopplungsTransformation.aktualisiereAchsen;
+begin
+  outAchsen:=inAchsen;
+  if horizontal then
+    outAchsen['x','y']:=2*outAchsen['x','y']-outAchsen['x','x'];
+  if vertikal then
+    outAchsen['y','y']:=2*outAchsen['y','y']-outAchsen['y','x'];
+end;
+
+procedure tGroeszenVerdopplungsTransformation.aktualisiereXsTs;
+begin
+  outXSTS:=inXSTS;
+  if horizontal then
+    outXSTS['x']:=2*outXSTS['x'];
+  if vertikal then
+    outXSTS['y']:=2*outXSTS['y'];
+end;
+
+function tGroeszenVerdopplungsTransformation.wertZuPositionAufAchse(const l: tLage; x: extended; auszerhalbIstFehler: boolean = true): extended;
+var
+  extra: extended;
+begin
+  if auszerhalbIstFehler then
+    testeAuszerhalb(l,x);
+  if (((l in [lOben,lUnten]) and horizontal) or // wenn in der abgefragten Richtung
+    ((l in [lLinks,lRechts]) and vertikal)) and // verdoppelt wurde und
+    (x > inAchsen[paralleleRichtung[l],'y']) then begin // der Wert in der 2. Hälfte liegt
+      // dann verschieben wir den Wert um die Hälfte
+    x:=x-(inAchsen[paralleleRichtung[l],'y']-inAchsen[paralleleRichtung[l],'x']) * (1+1/(inXSTS[paralleleRichtung[l]]-1));
+      // und addieren diese danach wieder
+    extra:=inXSTS[paralleleRichtung[l]];
+  end
+  else
+    extra:=0;
+  result:=beliebigerVorgaenger.wertZuPositionAufAchse(l,x,auszerhalbIstFehler)+extra;
+end;
+
+function tGroeszenVerdopplungsTransformation.positionAufAchseZuWert(const l: tLage; x: extended; auszerhalbIstFehler: boolean = true): extended;
+var
+  extra: extended;
+begin
+  if (((l in [lOben,lUnten]) and horizontal) or // wenn in der abgefragten Richtung
+    ((l in [lLinks,lRechts]) and vertikal)) and // verdoppelt wurde und
+    (x >= inXSTS[paralleleRichtung[l]]) then begin // der Wert in der 2. Hälfte liegt
+      // dann verschieben wir den Wert um die Hälfte
+    x:=x-inXSTS[paralleleRichtung[l]];
+      // und addieren diese danach wieder
+    extra:=(inAchsen[paralleleRichtung[l],'y']-inAchsen[paralleleRichtung[l],'x'])*(1+1/(inXSTS[paralleleRichtung[l]]-1));
+  end
+  else
+    extra:=0;
+  result:=beliebigerVorgaenger.wertZuPositionAufAchse(l,x,auszerhalbIstFehler)+extra;
+  if auszerhalbIstFehler then
+    testeAuszerhalb(l,x);
+end;
+
+function tGroeszenVerdopplungsTransformation.dumpParams: string;
+begin
+  result:=inherited dumpParams;
+  if horizontal then
+    result:='horizontal verdoppeln, '+result;
+  if horizontal then
+    result:='vertikal verdoppeln, '+result;
+end;
+
 // tLambdaZuOmegaTransformation ************************************************
 
 constructor tLambdaZuOmegaTransformation.create;