lambda-zu-omega Verzerrung neu

1 files changed, 140 insertions, 0 deletions

diff --git a/epostunit.pas b/epostunit.pas
index 3833348..e083d6d 100644
--- a/epostunit.pas
+++ b/epostunit.pas
@@ -147,6 +147,7 @@ type
     function fitteGausze(st: boolean; f: tMyStringlist; threads: longint): boolean;
     function berechneZeitfrequenzanalyse(st: boolean; f: tMyStringlist; threads: longint; quelle: tWerte; Warn: tWarnstufe): boolean;
     function berechneVerzerrung(st: boolean; f: tMyStringlist; threads: longint; quelle: tWerte; Warn: tWarnstufe): boolean;
+    function berechneLambdaZuOmegaVerzerrung(st: boolean; f: tMyStringList; threads: longint; quelle: tWerte): boolean;
     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;
@@ -354,6 +355,14 @@ type
     constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; zielpositionen: tIntPointArray; zielgewichte: tExtPointArray; zielanzahlen: tExtendedArray; Vorbearbeitungen,Nachbearbeitungen: tTransformation; vorAnz,nachAnz: longint);
     procedure stExecute; override;
   end;
+  tVerzerrLOThread = class(tLogThread)
+    qu,zi:           tWerte;
+    ho,ve:           boolean;
+    verhHo,verhVe:   extended;       // lambda_min / (lambda_max - lambda_min)
+    xMi,xMa,tMi,tMa: longint;        // bzgl. Ziel
+    constructor create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; verhaeltnisHorizontal, verhaeltnisVertikal: extended);
+    procedure stExecute; override;
+  end;
 
 function neuePalette(f: tMyStringlist): boolean;
 function initBmpHeader(w,h: longint): tBmpHeader;
@@ -3312,6 +3321,85 @@ begin
   result:=true;
 end;
 
+function tWerte.berechneLambdaZuOmegaVerzerrung(st: boolean; f: tMyStringList; threads: longint; quelle: tWerte): boolean;
+var
+  i:                       longint;
+  Zeit:                    extended;
+  verzerrLOThreads:        array of tVerzerrLOThread;
+  fertig:                  boolean;
+  s:                       string;
+procedure aufraeumen;
+var
+  ii: longint;
+begin
+  for ii:=0 to length(verzerrLOThreads)-1 do
+    if assigned(verzerrLOThreads[ii]) then
+      verzerrLOThreads[ii].free;
+  setlength(verzerrLOThreads,0);
+end;
+begin
+  result:=false;
+  warteaufBeendigungDesLeseThreads;
+  gibAus('lambda-zu-omega-Verzerrung berechnen ... ',3);
+  Zeit:=now;
+  Genauigkeit:=gExtended;
+  Transformationen:=tLambdaZuOmegaTransformation.create;
+  Transformationen.fuegeVorgaengerHinzu(quelle.Transformationen);
+
+  repeat
+    if not f.metaReadln(s,true) then begin
+      gibAus('Unerwartetes Dateiende!',3);
+      aufraeumen;
+      exit;
+    end;
+    if s='Ende' then break;
+    if quelle.dichtenParameterErkannt(st,s,threads,0,_xsteps-1,0,_tsiz-1) then continue;
+    if startetMit('Threadanzahl:',s) then begin
+      threads:=strtoint(s);
+      continue;
+    end;
+    if s='horizontal' then begin
+      (Transformationen as tLambdaZuOmegaTransformation).horizontal:=true;
+      continue;
+    end;
+    if s='vertikal' then begin
+      (Transformationen as tLambdaZuOmegaTransformation).vertikal:=true;
+      continue;
+    end;
+    gibAus('Verstehe Option '''+s+''' nicht bei Erstellung einer Verzerrung!',3);
+    aufraeumen;
+    exit;
+  until false;
+
+  _xsteps:=quelle._xsteps;
+  _tsiz:=quelle._tsiz;
+  if not st then begin
+    eWerte.holeRam(3);
+    gibAus('Threads starten',3);
+    setlength(verzerrLOThreads,threads);
+    for i:=0 to length(verzerrLOThreads)-1 do
+      verzerrLOThreads[i]:=
+        tVerzerrLOThread.create(
+          quelle,
+          self,
+          round(i/length(verzerrLOThreads)*_xsteps),
+          round((i+1)/length(verzerrLOThreads)*_xsteps-1),
+          0,
+          _tsiz-1,
+          (Transformationen as tLambdaZuOmegaTransformation).verhaeltnisHorizontal,
+          (Transformationen as tLambdaZuOmegaTransformation).verhaeltnisVertikal);
+    repeat
+      fertig:=true;
+      for i:=0 to length(verzerrLOThreads)-1 do
+        fertig:=fertig and verzerrLOThreads[i].fertig;
+      if not fertig then sleep(10);
+    until fertig;
+  end;
+  aufraeumen;
+  gibAus('... fertig '+timetostr(now-Zeit),3);
+  result:=true;
+end;
+
 function tWerte.berechneIntegral(st: boolean; f: tMyStringlist; threads: longint; quelle: tWerte): boolean;
 var
   i,tmin,tmax,xmin,xmax: longint;
@@ -6223,6 +6311,58 @@ begin
   gibAus('Verzerrthread beendet',1);
 end;
 
+// tVerzerrLOThread ************************************************************
+
+constructor tVerzerrLOThread.create(quelle,ziel: tWerte; xMin,xMax,tMin,tMax: longint; verhaeltnisHorizontal, verhaeltnisVertikal: extended);
+begin
+  inherited create;
+  qu:=quelle;
+  zi:=ziel;
+  xMi:=xMin;
+  xMa:=xMax;
+  tMi:=tMin;
+  tMa:=tMax;
+  verhHo:=verhaeltnisHorizontal;
+  verhVe:=verhaeltnisVertikal;
+  gibAus('VerzerrLOthread erzeugt: '+inttostr(xmin)+'-'+inttostr(xmax)+' '+inttostr(tmin)+'-'+inttostr(tmax),1);
+  suspended:=false;
+end;
+
+procedure tVerzerrLOThread.stExecute;
+begin
+  gibAus('VerzerrLOthread gestartet '+floattostr(qu._minW)+' '+floattostr(qu._maxW),1);
+  case zi.genauigkeit of
+    gSingle:
+      case qu.genauigkeit of
+        gSingle:
+          zi.sWerte.kopiereLOVerzerrt(pTLLWerteSingle(@qu.sWerte),xMi,xMa,tMi,tMa,verhHo,verhVe);
+        gDouble:
+          zi.sWerte.kopiereLOVerzerrt(pTLLWerteDouble(@qu.dWerte),xMi,xMa,tMi,tMa,verhHo,verhVe);
+        gExtended:
+          zi.sWerte.kopiereLOVerzerrt(pTLLWerteExtended(@qu.eWerte),xMi,xMa,tMi,tMa,verhHo,verhVe);
+      end{of case};
+    gDouble:
+      case qu.genauigkeit of
+        gSingle:
+          zi.dWerte.kopiereLOVerzerrt(pTLLWerteSingle(@qu.sWerte),xMi,xMa,tMi,tMa,verhHo,verhVe);
+        gDouble:
+          zi.dWerte.kopiereLOVerzerrt(pTLLWerteDouble(@qu.dWerte),xMi,xMa,tMi,tMa,verhHo,verhVe);
+        gExtended:
+          zi.dWerte.kopiereLOVerzerrt(pTLLWerteExtended(@qu.eWerte),xMi,xMa,tMi,tMa,verhHo,verhVe);
+      end{of case};
+    gExtended:
+      case qu.genauigkeit of
+        gSingle:
+          zi.eWerte.kopiereLOVerzerrt(pTLLWerteSingle(@qu.sWerte),xMi,xMa,tMi,tMa,verhHo,verhVe);
+        gDouble:
+          zi.eWerte.kopiereLOVerzerrt(pTLLWerteDouble(@qu.dWerte),xMi,xMa,tMi,tMa,verhHo,verhVe);
+        gExtended:
+          zi.eWerte.kopiereLOVerzerrt(pTLLWerteExtended(@qu.eWerte),xMi,xMa,tMi,tMa,verhHo,verhVe);
+      end{of case};
+  end{of case};
+  gibAus('VerzerrLOthread beendet',1);
+end;
+
 // sonstiges *******************************************************************
 
 function findePalette(out Palette: pTPalette; name: string): boolean;