Radon-Transformation neu

1 files changed, 125 insertions, 0 deletions

diff --git a/epostunit.pas b/epostunit.pas
index 660a6de..0afa38c 100644
--- a/epostunit.pas
+++ b/epostunit.pas
@@ -177,6 +177,7 @@ type
     function berechneIntegral(sT: boolean; f: tMyStringList; threads: longint; quelle: tWerte): boolean;
     function berechneFFT(sT: boolean; f: tMyStringList; threads: longint; warn: tWarnStufe): boolean;
     function berechneFFT2d(sT: boolean; f: tMyStringList; threads: longint; warn: tWarnStufe): boolean;
+    function berechneRadonTransformation(sT: boolean; f: tMyStringList; threads: longint; quelle: tWerte): boolean;
     function erzeugeLinearesBild(sT: boolean; var f: tMyStringList; threads: longint): boolean;
     function erzeugeAscii(sT: boolean; f: tMyStringList): boolean;
     function erzeugeLineout(sT: boolean; f: tMyStringList): boolean;
@@ -464,6 +465,12 @@ type
     destructor destroy; override;
     procedure stExecute; override;
   end;
+  tRadonTransformationsThread = class(tLogThread)
+    qu,zi:   tWerte;
+    xMi,xMa: longint;
+    constructor create(quelle,ziel: tWerte; xMin,xMax: longint);
+    procedure stExecute; override;
+  end;
 
 function neuePalette(f: tMyStringList): boolean;
 function initBmpHeader(w,h: longint): tBmpHeader;
@@ -5375,6 +5382,72 @@ begin
   result:=true;
 end;
 
+function tWerte.berechneRadonTransformation(sT: boolean; f: tMyStringList; threads: longint; quelle: tWerte): boolean;
+var
+  Zeit:                                  extended;
+  winkelSchritte,verschiebungsSchritte:  int64;
+  s:                                     string;
+  bekannteBefehle:                       tMyStringList;
+  i:                                     longint;
+  fertig:                                boolean;
+  radonTransformationsThreads:           array of tRadonTransformationsThread;
+begin
+  result:=false;
+  warteAufBeendigungDesLeseThreads;
+  Zeit:=now;
+  winkelSchritte:=180;
+  verschiebungsSchritte:=180;
+  bekannteBefehle:=tMyStringList.create;
+  repeat
+    if not f.metaReadln(s,true) then begin
+      gibAus('Unerwartetes Dateiende!',3);
+      bekannteBefehle.free;
+      exit;
+    end;
+    bekannteBefehle.clear;
+    if istDasBefehl('Ende',s,bekannteBefehle,false) then break;
+    if istDasBefehl('Winkelschritte:',s,bekannteBefehle,true) then begin
+      winkelSchritte:=round(exprToFloat(sT,s));
+      continue;
+    end;
+    if istDasBefehl('Verschiebungsschritte:',s,bekannteBefehle,true) then begin
+      verschiebungsSchritte:=round(exprToFloat(sT,s));
+      continue;
+    end;
+    bekannteBefehle.sort;
+    gibAus('Verstehe Option '''+s+''' nicht bei Erstellung einer Radon-Transformation!'#10'Ich kenne:'#10+bekannteBefehle.text,3);
+    bekannteBefehle.free;
+    exit;
+  until false;
+  bekannteBefehle.free;
+
+  _xSteps:=winkelSchritte;
+  _tSiz:=verschiebungsSchritte;
+  transformationen:=tRTTransformation.create(quelle.transformationen,winkelSchritte,verschiebungsSchritte);
+
+  if not sT then begin
+    holeRAM(0);
+    gibAus('berechne Radon-Transformation ...',3);
+    setLength(radonTransformationsThreads,threads);
+    for i:=0 to length(radonTransformationsThreads)-1 do
+      radonTransformationsThreads[i]:=tRadonTransformationsThread.create(
+        quelle,
+        self,
+        round(_xSteps/length(radonTransformationsThreads)*i),
+        round(_xSteps/length(radonTransformationsThreads)*(i+1))-1
+      );
+    repeat
+      fertig:=true;
+      for i:=0 to length(radonTransformationsThreads)-1 do
+        fertig:=radonTransformationsThreads[i].fertig and fertig;
+      if not fertig then
+        sleep(10);
+    until fertig;
+    gibAus('... fertig! '+timetostr(now-Zeit),3);
+  end;
+  result:=true;
+end;
+
 function tWerte.erzeugeLinearesBild(sT: boolean; var f: tMyStringList; threads: longint): boolean;
 var
   s,datei:                               string;
@@ -8550,6 +8623,58 @@ begin
   gibAus('SkalierungsThread beendet',1);
 end;
 
+// tRadonTransformationsThread *************************************************
+
+constructor tRadonTransformationsThread.create(quelle,ziel: tWerte; xMin,xMax: longint);
+begin
+  inherited create;
+  qu:=quelle;
+  zi:=ziel;
+  xMi:=xMin;
+  xMa:=xMax;
+  suspended:=false;
+  gibAus('RadonTransformationsThread erzeugt: '+intToStr(xMi)+'-'+intToStr(xMa),1);
+end;
+
+procedure tRadonTransformationsThread.stExecute;
+var
+  dx,dy: extended;
+begin
+  gibAus('RadonTransformationsThread gestartet',1);
+  dx:=(zi._xStop-zi._xStart)/(zi._xSteps-1);
+  dy:=(zi._tStop-zi._tStart)/(zi._tSiz-1);
+  case zi.genauigkeit of
+    gSingle:
+      case qu.genauigkeit of
+        gSingle:
+          zi.sWerte.radonTransformation(xMi,xMa,dx,dy,pTLLWerteSingle(@qu.sWerte));
+        gDouble:
+          zi.sWerte.radonTransformation(xMi,xMa,dx,dy,pTLLWerteDouble(@qu.dWerte));
+        gExtended:
+          zi.sWerte.radonTransformation(xMi,xMa,dx,dy,pTLLWerteExtended(@qu.eWerte));
+      end{of case};
+    gDouble:
+      case qu.genauigkeit of
+        gSingle:
+          zi.dWerte.radonTransformation(xMi,xMa,dx,dy,pTLLWerteSingle(@qu.sWerte));
+        gDouble:
+          zi.dWerte.radonTransformation(xMi,xMa,dx,dy,pTLLWerteDouble(@qu.dWerte));
+        gExtended:
+          zi.dWerte.radonTransformation(xMi,xMa,dx,dy,pTLLWerteExtended(@qu.eWerte));
+      end{of case};
+    gExtended:
+      case qu.genauigkeit of
+        gSingle:
+          zi.eWerte.radonTransformation(xMi,xMa,dx,dy,pTLLWerteSingle(@qu.sWerte));
+        gDouble:
+          zi.eWerte.radonTransformation(xMi,xMa,dx,dy,pTLLWerteDouble(@qu.dWerte));
+        gExtended:
+          zi.eWerte.radonTransformation(xMi,xMa,dx,dy,pTLLWerteExtended(@qu.eWerte));
+      end{of case};
+  end{of case};
+  gibAus('RadonTransformationsThread beendet',1);
+end;
+
 // sonstiges *******************************************************************
 
 function findePalette(out palette: tPalette; name: string): boolean;