werteunit.pas, epostunit.pas: tIntPoint -> tInt64Point

2 files changed, 54 insertions, 33 deletions

diff --git a/epostunit.pas b/epostunit.pas
index 52ee25a..3009bfc 100644
--- a/epostunit.pas
+++ b/epostunit.pas
@@ -174,7 +174,7 @@ type
     procedure spiegle(threads: longint); overload;
     procedure spiegle(threads,tMin,tMax: longint); overload;
     procedure fuelleMitDummys(sT: boolean);
-    procedure verschiebe(threads: longint; richtung: tIntPoint);
+    procedure verschiebe(threads: longint; richtung: tInt64Point);
     procedure ermittlePhasenWinkel(threads: longint);
     procedure fft2dNachbearbeitung(threads: longint; nB: tFFTDatenordnung);
     procedure schreibeWert(var f: textfile; x,y: longint);
@@ -395,8 +395,8 @@ type
   tVerschiebeThread = class(tLogThread)
     we:              tWerte;
     xMi,xMa,tMi,tMa: longint;
-    rtg:             tIntPoint;
-    constructor create(werte: tWerte; xMin,xMax,tMin,tMax: longint; richtung: tIntPoint);
+    rtg:             tInt64Point;
+    constructor create(werte: tWerte; xMin,xMax,tMin,tMax: longint; richtung: tInt64Point);
     procedure stExecute; override;
   end;
   tPhasenWinkelThread = class(tLogThread)
@@ -3951,7 +3951,7 @@ var
   s:                       string;
   b:                       boolean;
   bekannteBefehle:         tMyStringList;
-  maxPos:                  tIntPoint;
+  maxPos:                  tInt64Point;
   betraege:                tWerte;
 begin
   result:=false;
@@ -4038,7 +4038,7 @@ begin
   end{of case};
   betraege.free;
 
-  gibAus('zentrieren ('+tIntPointToStr(maxPos)+')',3);
+  gibAus('zentrieren ('+tInt64PointToStr(maxPos)+')',3);
   verschiebe(threads,maxPos);
 
   gibAus('berechne inverse x-FFT ...',3);
@@ -5226,15 +5226,15 @@ begin
     end;
 end;
 
-procedure tWerte.verschiebe(threads: longint; richtung: tIntPoint);
+procedure tWerte.verschiebe(threads: longint; richtung: tInt64Point);
 var
-  einheitsZelle:     tIntPoint;
+  einheitsZelle:     tInt64Point;
   teilRichtung:      char;
   verschiebeThreads: array of tVerschiebeThread;
   i:                 longint;
   fertig:            boolean;
 begin
-  einheitsZelle:=berechneEinheitsZelle(richtung,intPoint(_xSteps,_tSiz div (1+byte(istKomplex))));
+  einheitsZelle:=berechneEinheitsZelle(richtung,int64Point(_xSteps,_tSiz div (1+byte(istKomplex))));
 
   teilRichtung:=char(ord('x')+byte(einheitsZelle['y']>einheitsZelle['x']));
   if einheitsZelle[teilRichtung]<threads then
@@ -7391,7 +7391,7 @@ end;
 
 // tVerschiebeThread ***********************************************************
 
-constructor tVerschiebeThread.create(werte: tWerte; xMin,xMax,tMin,tMax: longint; richtung: tIntPoint);
+constructor tVerschiebeThread.create(werte: tWerte; xMin,xMax,tMin,tMax: longint; richtung: tInt64Point);
 begin
   inherited create;
   we:=werte;
@@ -7400,7 +7400,7 @@ begin
   tMi:=tMin;
   tMa:=tMax;
   rtg:=richtung;
-  gibAus('VerschiebeThread erzeugt: '+intToStr(xMin)+'-'+intToStr(xMax)+' '+intToStr(tMin)+'-'+intToStr(tMax)+' '+tIntPointToStr(richtung)+' '+intToStr(byte(we.istKomplex)),1);
+  gibAus('VerschiebeThread erzeugt: '+intToStr(xMin)+'-'+intToStr(xMax)+' '+intToStr(tMin)+'-'+intToStr(tMax)+' '+tInt64PointToStr(richtung)+' '+intToStr(byte(we.istKomplex)),1);
   suspended:=false;
 end;
 
diff --git a/werteunit.pas b/werteunit.pas
index 55bb4a5..c23aa38 100644
--- a/werteunit.pas
+++ b/werteunit.pas
@@ -20,7 +20,8 @@ type
     Auch die korrekte Parallelisierung obliegt dem übergeordneten Programmteil.
 }
   private
-    procedure sortiereNachWert(var positionen: tIntPointArray; logarithmischesPivot: boolean);
+    procedure sortiereNachWert(var positionen: tInt64PointArray; logarithmischesPivot: boolean);
+    function bestimmeDominanzQuadrat(von,nach: tInt64Point; xFak,yFak: extended): extended; inline;
   public
     werte:                                       array of wGen;
     params:                                      tExtraInfos;
@@ -74,9 +75,9 @@ type
     function ermittleRandMinimum: extended;
     function ermittleRandPerzentil(p: extended): extended;
     procedure kantenFilter(betraege: tLLWerte; xFak,yFak: extended; filterTyp: tKantenFilterTyp); overload;
-    procedure kantenFilter(betraege: tLLWerte; xFak,yFak: extended; filterTyp: tKantenFilterTyp; einseitig: boolean; out maxPos: tIntPoint); overload;
+    procedure kantenFilter(betraege: tLLWerte; xFak,yFak: extended; filterTyp: tKantenFilterTyp; einseitig: boolean; out maxPos: tInt64Point); overload;
     procedure fenstereWerte(xMi,xMa,tMi,tMa: int64; xFen,tFen: tFenster; hg: extended);
-    procedure verschiebe(richtung: tIntPoint; xV,xB,tV,tB: longint);
+    procedure verschiebe(richtung: tInt64Point; xV,xB,tV,tB: longint);
     procedure ermittlePhasenWinkel(xMi,xMa: longint);
     procedure macheKomplex(tMi,tMa: int64; kmm: tKomplexMachModus; mT: tMersenneTwister);
     procedure entferneHeiszePixel(schwelle,minusSchwelle,plusSchwelle: extended);
@@ -106,12 +107,12 @@ uses systemunit;
 
 // tLLWerte ********************************************************************
 
-procedure tLLWerte.sortiereNachWert(var positionen: tIntPointArray; logarithmischesPivot: boolean);
+procedure tLLWerte.sortiereNachWert(var positionen: tInt64PointArray; logarithmischesPivot: boolean);
 var
   mins,maxs:                tExtendedArray;
   pivot,wert,wertLi,wertRe: extended;
   vons,biss:                tLongintArray;
-  tmp:                      tIntPoint;
+  tmp:                      tInt64Point;
   i,li,re,cnt:              int64;
 begin
   setLength(vons,1);
@@ -202,6 +203,26 @@ begin
       fehler('Interner Fehler: Werte sind nicht sortiert, sollten sie aber sein!');
 end;
 
+function tLLWerte.bestimmeDominanzQuadrat(von,nach: tInt64Point; xFak,yFak: extended): extended;
+var
+  ref:       extended;
+  vo,nac,mi: tExtPoint;
+begin
+  ref:=werte[von['x']+von['y']*params.xSteps];
+  vo:=extPoint(von);
+  nac:=extPoint(nach);
+  mi:=vo;
+  while round(vo-nac)<>int64Point(0,0) do begin
+    mi:=0.5*(vo+nac);
+    if werte[round(mi['x'])+round(mi['y'])*params.xSteps]>=ref then
+      nac:=mi
+    else
+      vo:=mi;
+  end;
+  vo:=vo-mi;
+  result:=sqr(vo['x']*xFak)+sqr(vo['x']*yFak);
+end;
+
 constructor tLLWerte.create(ps: tExtraInfos);
 begin
   inherited create;
@@ -1988,22 +2009,22 @@ end;
 function tLLWerte.ermittleRandPerzentil(p: extended): extended;
 var
   i:    int64;
-  posi: tIntPointArray;
+  posi: tInt64PointArray;
 begin
   setLength(posi,2*(params.xSteps+params.tSiz-2));
   for i:=0 to length(posi)-1 do
     posi[i]['x']:=0;
   for i:=0 to params.xSteps-1 do begin
     posi[i]:=
-      intPoint(i,0);
+      int64Point(i,0);
     posi[i+params.xSteps]:=
-      intPoint(i,params.tSiz-1);
+      int64Point(i,params.tSiz-1);
   end;
   for i:=1 to params.tSiz-2 do begin
     posi[i-1+2*params.xSteps]:=
-      intPoint(0,i);
+      int64Point(0,i);
     posi[i-3+2*params.xSteps+params.tSiz]:=
-      intPoint(params.xSteps-1,i);
+      int64Point(params.xSteps-1,i);
   end;
   sortiereNachWert(posi,false);
   i:=round(p*(length(posi)-1));
@@ -2024,18 +2045,18 @@ end;
 
 procedure tLLWerte.kantenFilter(betraege: tLLWerte; xFak,yFak: extended; filterTyp: tKantenFilterTyp);
 var
-  dummy: tIntPoint;
+  dummy: tInt64Point;
 begin
   kantenFilter(betraege,xFak,yFak,filterTyp,false,dummy);
 end;
 
-procedure tLLWerte.kantenFilter(betraege: tLLWerte; xFak,yFak: extended; filterTyp: tKantenFilterTyp; einseitig: boolean; out maxPos: tIntPoint);
+procedure tLLWerte.kantenFilter(betraege: tLLWerte; xFak,yFak: extended; filterTyp: tKantenFilterTyp; einseitig: boolean; out maxPos: tInt64Point);
 var
-  maxima:               tIntPointArray;
+  maxima:               tInt64PointArray;
   i,iM,j,jM,mCnt,di,dj: int64;
   wert,minWert,maxWert: extended;
   istVollKomplex:       byte; // 1=nein, 2=ja
-  schiebung:            tIntPoint;
+  schiebung:            tInt64Point;
 begin
   istVollKomplex:=params.tSiz div betraege.params.tSiz;
   if (betraege.params.tSiz*istVollKomplex <> params.tSiz) or
@@ -2074,19 +2095,19 @@ begin
   setLength(maxima,mCnt);
 
   betraege.sortiereNachWert(maxima,true);
-  maxPos:=maxima[1];
+  maxPos:=maxima[0];
   maxWert:=0;
-  for i:=1 to length(maxima)-1 do begin
-    minWert:=0;
+  for i:=0 to length(maxima)-1 do begin
+    minWert:=sqr(maxima[i]['x']*xFak)+sqr(maxima[i]['y']*yFak);
     for j:=0 to i-1 do begin
-      wert:=sqr((maxima[j]['x']-maxima[i]['x'])*xFak)+sqr((maxima[j]['y']-maxima[i]['y'])*yFak);
-      if (j=0) or (wert<minWert) then begin
+      wert:=bestimmeDominanzQuadrat(maxima[i],maxima[j],xFak,yFak);
+      if wert<minWert then begin
         minWert:=wert;
-        if (minWert<=maxWert) and (i<>1) then
+        if minWert<=maxWert then
           break;
       end;
     end;
-    if (i=1) or (minWert>maxWert) then begin
+    if (i=0) or (minWert>maxWert) then begin
       maxWert:=minWert;
       maxPos:=maxima[i];
     end;
@@ -2126,7 +2147,7 @@ begin
       filterTyp:=kfTiefpass;
     end
     else
-      schiebung:=intPoint(0,0);
+      schiebung:=int64Point(0,0);
     iM:=params.xSteps;
     jM:=params.tSiz div 2;
     for j:=0 to jM-1 do begin
@@ -2166,7 +2187,7 @@ begin
         (werte[i+j*params.xSteps]-hg)*xFen.werte[i]*tFen.werte[j];
 end;
 
-procedure tLLWerte.verschiebe(richtung: tIntPoint; xV,xB,tV,tB: longint);
+procedure tLLWerte.verschiebe(richtung: tInt64Point; xV,xB,tV,tB: longint);
 var
   xS,tS,x,t,xN,tN,xM,tM: longint;
   imPart:                boolean;