Beginn der Typenumstrukturiereung (tPoint -> tIntPoint, ...)

1 files changed, 62 insertions, 65 deletions

diff --git a/epostunit.pas b/epostunit.pas
index cd66982..cb8a286 100644
--- a/epostunit.pas
+++ b/epostunit.pas
@@ -75,7 +75,7 @@ type
     function findeAlleDateien(nam: string; var dat: tGenerischeInputDateiInfoArray; Vorlage: tGenerischeInputDateiInfo): boolean;
     function ermittleExterneInputParameter(var f: tInputfile; out dateien: tGenerischeInputDateiInfoArray): boolean;
     function ermittleInterneInputParameter(var dateien: tGenerischeInputDateiInfoArray): boolean;
-    procedure initVerzerrung(quelle: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,mt: longint; oberst: boolean; epsilon: extended; verzerrung: tTransformationen; ZPs: tPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; Warn: tWarnstufe);
+    procedure initVerzerrung(quelle: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,mt: longint; oberst: boolean; epsilon: extended; verzerrung: tTransformationen; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; Warn: tWarnstufe);
     function rXsteps: longint;
     procedure wXsteps(xs: longint);
     function rTsiz: longint;
@@ -294,25 +294,25 @@ type
   end;
   tVerzerrInitThread = class(tLogThread)
     qu,zi:                    tWerte;
-    ZPs:                      tPointArray;
+    ZPs:                      tIntPointArray;
     ZGs:                      tExtPointArray;
     ZAs:                      tExtendedArray;
     xMi,xMa,tMi,tMa,x0,t0,mt: longint;        // bzgl. Ziel
     eps:                      extended;
     verz:                     tTransformationen;
     Warnstufe:                tWarnstufe;
-    constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tTransformationen; zielpositionen: tPointArray; zielgewichte: tExtPointArray; Warn: tWarnstufe);
+    constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tTransformationen; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; Warn: tWarnstufe);
     destructor destroy; override;
     procedure stExecute; override;
   end;
   tVerzerrThread = class(tLogThread)
     qu,zi:           tWerte;
-    ZPs:             tPointArray;
+    ZPs:             tIntPointArray;
     ZGs:             tExtPointArray;
     ZAs:             tExtendedArray;
     xMi,xMa,tMi,tMa: longint;        // bzgl. Ziel
     vb,nb:           tTransformationen;
-    constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tTransformationen);
+    constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tTransformationen);
     destructor destroy; override;
     procedure stExecute; override;
   end;
@@ -1109,7 +1109,7 @@ begin
  result:=true;
 end;
 
-procedure tWerte.initVerzerrung(quelle: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,mt: longint; oberst: boolean; epsilon: extended; verzerrung: tTransformationen; ZPs: tPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; Warn: tWarnstufe);
+procedure tWerte.initVerzerrung(quelle: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,mt: longint; oberst: boolean; epsilon: extended; verzerrung: tTransformationen; ZPs: tIntPointArray; ZGs: tExtPointArray; ZAs: tExtendedArray; Warn: tWarnstufe);
 var i,j:  longint;
     vits: array[boolean] of tVerzerrInitThread;
     b:    boolean;
@@ -1121,22 +1121,22 @@ begin
    for i:=tMin to tMax do
      for j:=xMin to xMax do begin
        ZGs[j+i*quelle._xsteps]:=verzerrung.transformiereKoordinaten(j,i);
-       ZPs[j+i*quelle._xsteps].x:=floor(ZGs[j+i*quelle._xsteps].x);
-       ZPs[j+i*quelle._xsteps].y:=floor(ZGs[j+i*quelle._xsteps].y);
-       ZGs[j+i*quelle._xsteps].x:=
-         ZGs[j+i*quelle._xsteps].x - ZPs[j+i*quelle._xsteps].x;
-       ZGs[j+i*quelle._xsteps].y:=
-         ZGs[j+i*quelle._xsteps].y - ZPs[j+i*quelle._xsteps].y;
-       ZPs[j+i*quelle._xsteps].x:=ZPs[j+i*quelle._xsteps].x - x0Abs; // Zielpositionen um die Nullposition verschieben
-       ZPs[j+i*quelle._xsteps].y:=ZPs[j+i*quelle._xsteps].y - t0Abs;
-       ZAs[ZPs[j+i*quelle._xsteps].x + ZPs[j+i*quelle._xsteps].y*_xsteps]:=
-         ZAs[ZPs[j+i*quelle._xsteps].x + ZPs[j+i*quelle._xsteps].y*_xsteps] + (1-ZGs[j+i*quelle._xsteps].x)*(1-ZGs[j+i*quelle._xsteps].y);
-       ZAs[ZPs[j+i*quelle._xsteps].x + 1 + ZPs[j+i*quelle._xsteps].y*_xsteps]:=
-         ZAs[ZPs[j+i*quelle._xsteps].x + 1 + ZPs[j+i*quelle._xsteps].y*_xsteps] + ZGs[j+i*quelle._xsteps].x*(1-ZGs[j+i*quelle._xsteps].y);
-       ZAs[ZPs[j+i*quelle._xsteps].x + (ZPs[j+i*quelle._xsteps].y + 1)*_xsteps]:=
-         ZAs[ZPs[j+i*quelle._xsteps].x + (ZPs[j+i*quelle._xsteps].y + 1)*_xsteps] + (1-ZGs[j+i*quelle._xsteps].x)*ZGs[j+i*quelle._xsteps].y;
-       ZAs[ZPs[j+i*quelle._xsteps].x + 1 + (ZPs[j+i*quelle._xsteps].y + 1)*_xsteps]:=
-         ZAs[ZPs[j+i*quelle._xsteps].x + 1 + (ZPs[j+i*quelle._xsteps].y + 1)*_xsteps] + ZGs[j+i*quelle._xsteps].x*ZGs[j+i*quelle._xsteps].y;
+       ZPs[j+i*quelle._xsteps]['x']:=floor(ZGs[j+i*quelle._xsteps]['x']);
+       ZPs[j+i*quelle._xsteps]['y']:=floor(ZGs[j+i*quelle._xsteps]['y']);
+       ZGs[j+i*quelle._xsteps]['x']:=
+         ZGs[j+i*quelle._xsteps]['x'] - ZPs[j+i*quelle._xsteps]['x'];
+       ZGs[j+i*quelle._xsteps]['y']:=
+         ZGs[j+i*quelle._xsteps]['y'] - ZPs[j+i*quelle._xsteps]['y'];
+       ZPs[j+i*quelle._xsteps]['x']:=ZPs[j+i*quelle._xsteps]['x'] - x0Abs; // Zielpositionen um die Nullposition verschieben
+       ZPs[j+i*quelle._xsteps]['y']:=ZPs[j+i*quelle._xsteps]['y'] - t0Abs;
+       ZAs[ZPs[j+i*quelle._xsteps]['x'] + ZPs[j+i*quelle._xsteps]['y']*_xsteps]:=
+         ZAs[ZPs[j+i*quelle._xsteps]['x'] + ZPs[j+i*quelle._xsteps]['y']*_xsteps] + (1-ZGs[j+i*quelle._xsteps]['x'])*(1-ZGs[j+i*quelle._xsteps]['y']);
+       ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + ZPs[j+i*quelle._xsteps]['y']*_xsteps]:=
+         ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + ZPs[j+i*quelle._xsteps]['y']*_xsteps] + ZGs[j+i*quelle._xsteps]['x']*(1-ZGs[j+i*quelle._xsteps]['y']);
+       ZAs[ZPs[j+i*quelle._xsteps]['x'] + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps]:=
+         ZAs[ZPs[j+i*quelle._xsteps]['x'] + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps] + (1-ZGs[j+i*quelle._xsteps]['x'])*ZGs[j+i*quelle._xsteps]['y'];
+       ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps]:=
+         ZAs[ZPs[j+i*quelle._xsteps]['x'] + 1 + (ZPs[j+i*quelle._xsteps]['y'] + 1)*_xsteps] + ZGs[j+i*quelle._xsteps]['x']*ZGs[j+i*quelle._xsteps]['y'];
      end;
  end
  else begin
@@ -1953,8 +1953,7 @@ begin
   end;
   warteaufBeendigungDesLeseThreads;
   Zeit:=now;
-  Transformationen.kopiereVon(quelle.Transformationen);
-  Transformationen.clearWerte;
+  Transformationen:=tTransformationen.create;
   Fenster.Breite:=0;
   Fenster.aktiv:=false;
   Fenster.Rand:=0;
@@ -2030,6 +2029,8 @@ begin
       floattostrtrunc(disk2kontFak('t',tmax-tmin+1),2,true)+')',3);
     exit;
   end;
+  Transformationen.xsteps:=_xsteps;
+  Transformationen.tsiz:=_tsiz;
   if quelle._tsiz<>1 then begin
     Transformationen.xstart:=quelle.disk2kont('t',tmin);      // quelle._tstart + tmin/(quelle._tsiz-1)*(quelle._tstop-quelle._tstart);
     Transformationen.xstop:= quelle.disk2kont('t',tmax);      // quelle._tstart + tmax/(quelle._tsiz-1)*(quelle._tstop-quelle._tstart);
@@ -2072,17 +2073,14 @@ begin
     end;
     gibAus(' (Parseval-Fehler = '+floattostr(pvFehler)+')',3);
   end;
-  Transformationen.tstop:=(_tsiz div 2-1)/(Transformationen.tstop-Transformationen.tstart)/2;
-  Transformationen.tstart:=0;
+  Transformationen.addFFT(false,true);
   if (Transformationen.tstop<=freqmax) or (freqmax<=0) then
     _tsiz:=_tsiz div 2
   else begin
     freqmax:=Transformationen.tstop * round((_tsiz div 2)/Transformationen.tstop*freqmax) / (_tsiz div 2);
     _tsiz:=round((_tsiz div 2)/Transformationen.tstop*freqmax);
-    Transformationen.tstop:=freqmax;
-  end;                              gibAus(inttostr(_xsteps)+' '+inttostr(_tsiz),3);
-  Transformationen.xsteps:=_xsteps;
-  Transformationen.tsiz:=_tsiz;
+  end;
+  Transformationen.addAusschnitt(0,_xsteps-1,0,_tsiz-1);
   if not st then
     eWerte.holeRAM(0);
   gibAus('... fertig '+ZeitDarstellen(now-Zeit),3);
@@ -2092,7 +2090,7 @@ end;
 function tWerte.berechneVerzerrung(st: boolean; var f: tInputfile; threads: longint; const quelle: tWerte; Warn: tWarnstufe): boolean;
 var i,j:                     longint;
     grenzen:                 t2x2Longint;
-    ZPs:                     tPointArray;     // Zielpositionen
+    ZPs:                     tIntPointArray;     // Zielpositionen
     ZGs:                     tExtPointArray;  // Zielgewichte
     ZAs:                     tExtendedArray;  // Anzahl Quellen, die auf entsprechende Zielposition abgebildet werden
     Zeit,epsilon:            extended;
@@ -2761,18 +2759,17 @@ begin
        fontRend:=fontRenderer;
        lage:=Achsen[i].lage;
 //       position:=(wert-miw)/(maw-miw);
-  gibAus(' -> -> '+inttostr(Transformationen.count),3);
-  for j:=0 to Transformationen.count-1 do
-    gibAus(' '+inttostr(j)+' '+Transformationen.Inhalt[j].dumpParams,3);
        position:=Transformationen.transformiereKoordinaten(Achsen[i].Lage,wert);
        if (position<0) or (position>1) then begin
+         gibAus('Der Wert '+floattostr(wert)+' liegt außerhalb des Bildes ('+floattostr(position)+') - das sollte eigentlich nicht passieren!',3);
          beschriftungen[length(beschriftungen)-1].free;
          setlength(beschriftungen,length(beschriftungen)-1);
-         continue;
+       end
+       else begin
+         if lage in [lOben,lUnten] then position:=position*bBreite
+         else position:=position*bHoehe;
+         inhalt:=floattostr(wert);
        end;
-       if lage in [lOben,lUnten] then position:=position*bBreite
-       else position:=position*bHoehe;
-       inhalt:=floattostr(wert);
      end;
      wert:=wert+schritt;
    end;
@@ -2810,8 +2807,8 @@ begin
  gibAus('Alle Threads beendet, Konturen einfügen ...',1);
  for i:=0 to length(verwKonturen)-1 do
    for j:=0 to length(konturen^[verwKonturen[i]].orte)-1 do begin
-     xp:=kont2disk('x',konturen^[verwKonturen[i]].orte[j].x);
-     tp:=kont2disk('t',konturen^[verwKonturen[i]].orte[j].y);
+     xp:=kont2disk('x',konturen^[verwKonturen[i]].orte[j]['x']);
+     tp:=kont2disk('t',konturen^[verwKonturen[i]].orte[j]['y']);
 
      if (xmin<=xp) and (xp<=xmax) and (tmin<=tp) and (tp<=tmax) then begin
        k:=0;
@@ -3809,9 +3806,9 @@ begin
     result:=nan;
     exit;
   end;
-  result:=orte[0].x;
+  result:=orte[0]['x'];
   for i:=1 to length(orte)-1 do
-    result:=min(result,orte[i].x);
+    result:=min(result,orte[i]['x']);
 end;
 
 function tKontur.rxmax: extended;
@@ -3821,9 +3818,9 @@ begin
     result:=nan;
     exit;
   end;
-  result:=orte[0].x;
+  result:=orte[0]['x'];
   for i:=1 to length(orte)-1 do
-    result:=max(result,orte[i].x);
+    result:=max(result,orte[i]['x']);
 end;
 
 function tKontur.rtmin: extended;
@@ -3833,9 +3830,9 @@ begin
     result:=nan;
     exit;
   end;
-  result:=orte[0].y;
+  result:=orte[0]['y'];
   for i:=1 to length(orte)-1 do
-    result:=min(result,orte[i].y);
+    result:=min(result,orte[i]['y']);
 end;
 
 function tKontur.rtmax: extended;
@@ -3845,9 +3842,9 @@ begin
     result:=nan;
     exit;
   end;
-  result:=orte[0].y;
+  result:=orte[0]['y'];
   for i:=1 to length(orte)-1 do
-    result:=max(result,orte[i].y);
+    result:=max(result,orte[i]['y']);
 end;
 
 function tKontur.init(st: boolean; var f: tInputfile; w: pTWerteArray; mt: longint): boolean;
@@ -3926,8 +3923,8 @@ begin
         j:=0;
         while j<length(Orte) do begin
           k:=j;
-          while (j<length(Orte)) and (Orte[j].y=Orte[k].y) do begin
-            if Orte[j].x>Orte[k].x then
+          while (j<length(Orte)) and (Orte[j]['y']=Orte[k]['y']) do begin
+            if Orte[j]['x']>Orte[k]['x'] then
               k:=j;
             inc(j);
           end;
@@ -3942,8 +3939,8 @@ begin
         j:=0;
         while j<length(Orte) do begin
           k:=j;
-          while (j<length(Orte)) and (Orte[j].y=Orte[k].y) do begin
-            if Orte[j].x<Orte[k].x then
+          while (j<length(Orte)) and (Orte[j]['y']=Orte[k]['y']) do begin
+            if Orte[j]['x']<Orte[k]['x'] then
               k:=j;
             inc(j);
           end;
@@ -3985,9 +3982,9 @@ begin
     readln(tf,s);
     s:=erstesArgument(s,'#');
     if s='' then continue;
-    tmp.y:=strtofloat(erstesArgument(s));
-    tmp.x:=strtofloat(erstesArgument(s));
-    if (tmp.x<xmi) or (tmp.x>xma) or (tmp.y<tmi) or (tmp.y>tma) then continue;
+    tmp['y']:=strtofloat(erstesArgument(s));
+    tmp['x']:=strtofloat(erstesArgument(s));
+    if (tmp['x']<xmi) or (tmp['x']>xma) or (tmp['y']<tmi) or (tmp['y']>tma) then continue;
     if i>=length(orte) then
       setlength(orte,length(orte)+Speicherhappen);
     orte[i]:=tmp;
@@ -4068,15 +4065,15 @@ begin
  end;
  avg:=0;
  for i:=von to bis do
-   avg:=avg+Orte[i].y;
+   avg:=avg+Orte[i]['y'];
  avg:=avg/(bis-von+1);
  i:=von;
  j:=bis;
 
  while i<j do begin
-   while (i<=j) and (Orte[i].y<=avg) do
+   while (i<=j) and (Orte[i]['y']<=avg) do
      inc(i);
-   while (i<=j) and (Orte[j].y>=avg) do
+   while (i<=j) and (Orte[j]['y']>=avg) do
      dec(j);
    if i<j then begin
      tmp:=Orte[i];
@@ -4090,7 +4087,7 @@ begin
  end;
  if (j<von) or (i>bis) then begin
    for i:=von+1 to bis do
-     if Orte[i].y <> Orte[von].y then begin
+     if Orte[i]['y'] <> Orte[von]['y'] then begin
        gibAus(' interner Quicksort-Fehler: "komisch, die Orte sind doch unterschiedlich ..."',1);
        halt;
      end;
@@ -4350,7 +4347,7 @@ end;
 
 // tVerzerrInitThread **********************************************************
 
-constructor tVerzerrInitThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tTransformationen; zielpositionen: tPointArray; zielgewichte: tExtPointArray; Warn: tWarnstufe);
+constructor tVerzerrInitThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax,x0Abs,t0Abs,threads: longint; epsilon: extended; verzerrung: tTransformationen; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; Warn: tWarnstufe);
 begin
  inherited create;
  qu:=quelle;
@@ -4383,12 +4380,11 @@ begin
  gibAus('VerzerrInitThread gestartet ('+inttostr(xMi)+'-'+inttostr(xMa)+'/'+inttostr(tMi)+'-'+inttostr(tMa)+')',1);
  zi.initVerzerrung(qu,xMi,xMa,tMi,tMa,x0,t0,mt,false,eps,verz,ZPs,ZGs,ZAs,Warnstufe);
  gibAus('VerzerrInitThread beendet',1);
- fertig:=true;
 end;
 
 // tVerzerrThread **************************************************************
 
-constructor tVerzerrThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tTransformationen);
+constructor tVerzerrThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tTransformationen);
 begin
  inherited create;
  qu:=quelle;
@@ -4443,8 +4439,6 @@ begin
      end{of case};
  end{of case};
  gibAus('Verzerrthread beendet',1);
- if not behalteLogs then cleanuplog(GetThreadID);
- fertig:=true;
 end;
 
 // sonstiges *******************************************************************
@@ -4909,7 +4903,10 @@ var bt: tBefehlThread;
 begin
  bt:=tBefehlThread.create(s,result);
  if st or not result then begin
-   bt.free;
+   try
+     bt.free;
+   except
+   end;
    exit;
  end;
  bt.suspended:=false;