werteunit.pas: tLLWerte.nullenEinfuegen() kann nun auch zentrieren

2 files changed, 25 insertions, 19 deletions

diff --git a/epostunit.pas b/epostunit.pas
index 763d2fe..a26f8ca 100644
--- a/epostunit.pas
+++ b/epostunit.pas
@@ -5476,11 +5476,11 @@ begin
   holeRAM(3);
   case genauigkeit of
     gSingle:
-      sWerte.nullenEinfuegen(_xSteps div (1+byte(wo['x'])),_tSiz div (1+byte(wo['y'])));
+      sWerte.nullenEinfuegen(false,_xSteps div (1+byte(wo['x'])),_tSiz div (1+byte(wo['y'])));
     gDouble:
-      dWerte.nullenEinfuegen(_xSteps div (1+byte(wo['x'])),_tSiz div (1+byte(wo['y'])));
+      dWerte.nullenEinfuegen(false,_xSteps div (1+byte(wo['x'])),_tSiz div (1+byte(wo['y'])));
     gExtended:
-      eWerte.nullenEinfuegen(_xSteps div (1+byte(wo['x'])),_tSiz div (1+byte(wo['y'])));
+      eWerte.nullenEinfuegen(false,_xSteps div (1+byte(wo['x'])),_tSiz div (1+byte(wo['y'])));
   end{of case};
 
   result:=true;
@@ -6009,11 +6009,11 @@ begin
   holeRAM(3);
   case genauigkeit of
     gSingle:
-      sWerte.nullenEinfuegen(_xSteps div 2,_tSiz div 2);
+      sWerte.nullenEinfuegen(false,_xSteps div 2,_tSiz div 2);
     gDouble:
-      dWerte.nullenEinfuegen(_xSteps div 2,_tSiz div 2);
+      dWerte.nullenEinfuegen(false,_xSteps div 2,_tSiz div 2);
     gExtended:
-      eWerte.nullenEinfuegen(_xSteps div 2,_tSiz div 2);
+      eWerte.nullenEinfuegen(false,_xSteps div 2,_tSiz div 2);
   end{of case};
 
   // sonst transformieren wir Zeilen, die nur Nullen beinhalten, in der 1. inversen FFT
@@ -6129,7 +6129,7 @@ begin
     hilfsWerte._xSteps:=round(power(2,ceil(ln(_tSiz+1)/ln(2))));
     hilfsWerte._tSiz:=hilfsWerte._xSteps;
     hilfsWerte.holeRAM(3);
-    hilfsWerte.eWerte.nullenEinfuegen(quelle._xSteps,quelle._tSiz);
+    hilfsWerte.eWerte.nullenEinfuegen(true,quelle._xSteps,quelle._tSiz);
     gibAus('berechne t-FFT für Radon-Transformation ...',3);
     if not hilfsWerte.fft(threads,true,false,doRes,doResSmi,nil,nil,pvFehler,warn) then begin
       gibAus('Es traten Fehler auf!',3);
diff --git a/werteunit.pas b/werteunit.pas
index d5d414b..0f397e0 100644
--- a/werteunit.pas
+++ b/werteunit.pas
@@ -121,7 +121,7 @@ type
     procedure produkt(f1: pTLLWerteExtended; f2: pTLLWerteExtended; xMi,xMa,xOf,tMi,tMa,tOf: int64; konj: boolean; daO: tFFTDatenordnung); overload;
     procedure wertAusUmgebungMitteln(x,y: longint); inline;
     procedure extrahiereKanten(xMi,xMa,tMi,tMa: longint; vert: boolean; expo: int64);
-    procedure nullenEinfuegen(vX,vY: int64);
+    procedure nullenEinfuegen(zentr: boolean; vX,vY: int64);
     procedure skaliere(tMi,tMa: int64; skalierung: string; trafo: tTransformation; kvs: tKnownValues; cbgv: tCallBackGetValue);
   end;
   tLLWerteSingle = specialize tLLWerte<single>;
@@ -2581,24 +2581,30 @@ begin
     werte[xMa+j*params.xSteps]:=0;
 end;
 
-procedure tLLWerte.nullenEinfuegen(vX,vY: int64);
+procedure tLLWerte.nullenEinfuegen(zentr: boolean; vX,vY: int64);
 var
-  i: int64;
+  i,xSh,ySh: int64;
 begin
   // Der Speicher ist schon geholt, die Werte stehen aber noch an alter Stelle.
   // Es muss also (ggf.) noch umkopiert und Nullen eingefügt werden.
 
   if vX<>params.xSteps then begin
-    if 2*vX>params.xSteps then
-      fehler('x-Streckung von '+intToStr(vX)+' zu '+intToStr(params.xSteps)+' Werten funktioniert nicht - ich brauche mindestens einen Faktor 2!');
-    // die Nullen und das nullte Element müssen nicht verschoben werden
-    for i:=vY-1 downto 1 do
-      move(werte[i*vX],werte[i*params.xSteps],sizeOf(wGen)*vX);
-    for i:=0 to vY-1 do
-      fillChar(werte[i*params.xSteps+vX],sizeOf(wGen)*(params.xSteps-vX),0);
+    if (2+byte(zentr))*vX>params.xSteps then
+      fehler('x-Streckung von '+intToStr(vX)+' zu '+intToStr(params.xSteps)+' Werten funktioniert nicht - ich brauche mindestens einen Faktor '+intToStr(2+byte(zentr))+'!');
+    xSh:=byte(zentr)*(params.xSteps-vX+1) div 2;
+    ySh:=byte(zentr)*(params.tSiz-vY+1) div 2;
+    // die Nullen und ggf. auch das nullte Element müssen nicht verschoben werden
+    for i:=vY-1 downto byte(not zentr) do
+      move(werte[i*vX],werte[xSh+(i+ySh)*params.xSteps],sizeOf(wGen)*vX);
+    for i:=0 to vY-1 do begin
+      fillChar(werte[(i+ySh)*params.xSteps],sizeOf(wGen)*xSh,0);
+      fillChar(werte[(i+ySh)*params.xSteps+vX+xSh],sizeOf(wGen)*(params.xSteps-vX-xSh),0);
+    end;
+  end;
+  if vY<>params.tSiz then begin
+    fillChar(werte[0],sizeOf(wGen)*params.xSteps*ySh,0);
+    fillChar(werte[params.xSteps*(vY+ySh)],sizeOf(wGen)*params.xSteps*(params.tSiz-vY-ySh),0);
   end;
-  if vY<>params.tSiz then
-    fillChar(werte[params.xSteps*vY],sizeOf(wGen)*params.xSteps*(params.tSiz-vY),0);
 end;
 
 procedure tLLWerte.skaliere(tMi,tMa: int64; skalierung: string; trafo: tTransformation; kvs: tKnownValues; cbgv: tCallBackGetValue);