Wie kann man viele Punkte schnell vergleichen?

[Matze]

Puh, das wird komplex. Aber stimmt, das wäre evtl. schneller. Danke für den Hinweis.

Wie angedeutet, brauche ich jeweils den Punkt direkt vor dem Fenster, dann den ersten und letzten im Fenster und den ersten Punkt, der wieder aus dem Fenster draußen ist.
D.h. ich müsste immer den aktuellen und den nächsten Punkt mit den Fensterkanten vergleichen. Und es kommen zu den x-Wertenauch noch die y-Werte hinzu und die Vergleiche mit den Fensterober- und -unterkanten. Ohje ....

@Himi: Ich weiß nicht, ob das funktioniert, da ich keinen bestimmten Wert suche. D.h. die Suche würde bei mir fast immer "kein Treffer" liefern.

[himitsu]

Klar funktioniert das.
Du suchst also einfach nur den wert, welcher Größer-Gleich deinem Startpunkt ist und welcher am nähesten an diesem Punkt liegt.

Schau dir mal die Find-Methode der TStringList an.
Über diese wird zwar ein bestimmter Wert gesucht, aber wenn nix gefunden wird, dann gibt diese die Position zurück welcher der Wert eingefügt werden könnte.

[Matze]

Ich guck mal, ob ich den Algorithmus verstehe und ihn umsetzen kann.

[Namenloser]

Wie viele Punkte sind es denn ungefähr? Wie wäre es mit einem Quadtree? (Kann sein, dass himitsu mit Binärer Suche das gleiche meinte).

PS: Unten ist auch eine Seite mit Beispielen verlinkt.

[Medium]

Im 3D-Bereich wird zum "culling" (Ablehnen von Polygonen/Vertices) gerne das Separating Axis Theorem ausgenutzt. Gerade mit achsenparallelen Rechtecken kann man da einiges optimieren, und das kann extrem flott gezüchtet werden. (Wird immerhin zum Frustum-Culling teils Bild für Bild in Spielen gemacht, und sogar in 3D mit schiefen Ebenen.) Es gibt die Wikipediaseite auch auf Deutsch, ich fand die Englische jetzt nur weit aus anschaulicher.
Das dürfte mehr oder minder State of the Art sein, es sei denn es gibt für 2D eine noch flottere Klamotte die mir dann unbekannt wäre

[Uwe Raabe]

Wenn ich das recht verstehe, betrachtest du lediglich die X-Werte der Punkte mit den jeweiligen Fenstergrenzen. Die Y-Werte interessieren dabei noch gar nicht.

Die Punkte scheinen in X aufsteigend sortiert zu sein, sonst funktioniert dein Algorithmus nämlich nicht.

Wenn man nun die Fenstergrenzen ebenfalls sortiert und mit Index-Arrays arbeitet, kann man mit zwei Durchläufen die Punktbereiche in den Fenstern ermitteln.

Hier der passende Code:

Delphi-Quellcode:

{ Punkte gibt die X-Werte der Punkte an, FensterLo die Untergrenzen, FensterHi die Obergrenzen der Fenster.
  insideLo und insideHi geben die Indizes der Punkte an, die gerade noch in dem jeweiligen Fenster liegen }
procedure FindeFenster(const Punkte, FensterLo, FensterHi: array of Double; var insideLo, insideHi: TIntegerDynArray);
var
  CntPunkte: Integer;
  CntFenster: Integer;
  orderLo: TIntegerDynArray;
  orderHi: TIntegerDynArray;
  I: Integer;
  idx: Integer;
  rng: Integer;
begin
  CntPunkte := Length(Punkte);
  CntFenster := Length(FensterLo);

  Assert(CntPunkte > 0);
  Assert(CntFenster > 0);
  Assert(CntFenster = Length(FensterHi));

  SetLength(insideLo, CntFenster);
  SetLength(insideHi, CntFenster);

  { orderLo enthält eine Liste von Indizes auf FensterLo, so daß die Werte aufsteigend sortiert sind.
    orderHi enthält eine Liste von Indizes auf FensterHi, so daß die Werte aufsteigend sortiert sind.
    Läßt sich mit einem angepassten QuickSort leicht implementieren. }

  orderLo := GetSortOrder(FensterLo);
  orderHi := GetSortOrder(FensterHi);

  { erster Durchlauf: untere Grenzen ermitteln }
  idx := 0;
  rng := orderLo[idx];
  for I := 0 to Length(Punkte) - 1 do begin
    if Punkte[I] >= FensterLo[rng] then begin
      { untere Grenze des nächsten Fensters überschritten }
      insideLo[rng] := I;
      { die folgenden Fenster prüfen bis wir eins finden, in dem wir noch nicht sind }
      Inc(idx);
      while idx < CntFenster do begin
        rng := orderLo[idx];
        if Punkte[I] < FensterLo[rng] then
          Break;
        insideLo[rng] := I;
        Inc(idx);
      end;
      { schon alle Fenster überprüft? }
      if idx >= CntFenster then
        Break;
      rng := orderLo[idx]
    end;
  end;

  { zweiter Durchlauf: obere Grenzen ermitteln }
  idx := CntFenster - 1;
  rng := orderHi[idx];
  for I := CntPunkte - 1 downto 0 do begin
    if Punkte[I] <= FensterHi[rng] then begin
      { obere Grenze des nächsten Fensters unterschritten }
      insideHi[rng] := I;
      { die folgenden Fenster prüfen bis wir eins finden, in dem wir noch nicht sind }
      Dec(idx);
      while idx >= 0 do begin
        rng := orderHi[idx];
        if Punkte[I] > FensterHi[rng] then
          Break;
        insideHi[rng] := I;
        Dec(idx);
      end;
      { schon alle Fenster überprüft? }
      if idx < 0 then
        Break;
      rng := orderHi[idx];
    end;
  end;
end;

Die Funktion GetSortOrder ruft einen angepassten Quicksort auf:

Delphi-Quellcode:

procedure QuickSort(const Values: array of Double; var Index: array of Integer; L, R: Integer);
var
  I, J, T: Integer;
  P: Double;
begin
  repeat
    I := L;
    J := R;
    P := Values[Index[(L + R) shr 1]];
    repeat
      while (Values[Index[I]] < P) do
        Inc(I);
      while (Values[Index[J]] > P) do
        Dec(J);
      if I <= J then
      begin
        if I <> J then
        begin
          T := Index[I];
          Index[I] := Index[J];
          Index[J] := T;
        end;
        Inc(I);
        Dec(J);
      end;
    until I > J;
    if L < J then
      QuickSort(Values, Index, L, J);
    L := I;
  until I >= R;
end;

function GetSortOrder(const Values: array of Double): TIntegerDynArray;
var
  I: Integer;
begin
  SetLength(result, Length(Values));
  for I := 0 to Length(result) - 1 do
    result[I] := I;

  QuickSort(Values, result, 0, Length(result) - 1);
end;

[Medium]

Öhm, sortiert und nur für eine Achse ginge das doch noch VIEL einfacher! Die Fenstergrenzen müssen dafür auch nach gleicher Weise wie die Punkte sortiert sein, und du kommst mit nur einem Durchlauf aus.

Mal so ein Fetzen Pseudocode:

Delphi-Quellcode:

type
  TWindow = class;
  TEdge = class
  public
    Value: Float;
    IsLeftEdge: Boolean; // im Konstruktor zuweisen, wird noch wichtig :)
    Window: TWindow; // im Konstruktor zuweisen, quasi der Parent, also Rückbezug
  end;
  TWindow = class
  public
    Left, Right: TEdge;
    LeftPointLeft: Float;
    LeftPointRight: Float;
    RightPointLeft: Float;
    RightPointRight: Float;
  end;

var
  Windows: array of TWindow;
  Edges: array of TEdge; // referenzen auf alle Edges aus dem Windows-Array sortiert nach Value
  CurrentEdgeIndex: Integer;
begin
  for i := 0 to maxPoints do
  begin
    if Points[i].X > Edges[CurrentEdgeIndex].Value then
    begin
      if Edges[CurrentEdgeIndex].IsLeftEdge then
      begin
        Edges[CurrentEdgeIndex].Window.LeftPointLeft := Points[i-1].Value;
        Edges[CurrentEdgeIndex].Window.LeftPointRight := Points[i].Value;
      end
      else
      begin
        Edges[CurrentEdgeIndex].Window.RightPointLeft := Points[i-1].Value;
        Edges[CurrentEdgeIndex].Window.RightPointRight := Points[i].Value;
      end;
      inc(CurrentEdgeIndex);
    end;
  end;
end;

Und schwupps stehen im TWindows-Array alle Punkte, die links und rechts der X-Fenstergrenzen liegen, in O(n).

Man könnte natürlich auch die Punkte in die TEdge Instanzen werfen, und sich dieses IsLeftEdge damit sparen:

Delphi-Quellcode:

type
  TWindow = class;
  TEdge = class
  public
    Value: Float;
    LeftValue, RightValue: Float;
  end;
  TWindow = class
  public
    Left, Right: TEdge;
  end;

var
  Windows: array of TWindow;
  Edges: array of TEdge; // referenzen auf alle Edges aus dem Windows-Array sortiert nach Value
  CurrentEdgeIndex: Integer;
begin
  for i := 0 to maxPoints do
  begin
    if Points[i].X > Edges[CurrentEdgeIndex].Value then
    begin
      Edges[CurrentEdgeIndex].LeftValue := Points[i-1].Value;
      Edges[CurrentEdgeIndex].RightValue := Points[i].Value;
      inc(CurrentEdgeIndex);
    end;
  end;
end;

Das spart evtl. noch (sehr minimal) Zeit in der Schleife (ein Vergleich und ein paar Dereferenzierungen, uhu), und die Werte stehen ggf. an sinnvollerer Stelle, je nach dem wie du es nachher brauchst.

[Matze]

Huch, schön, dass euch das Thema auch so interessiert. Erst einmal danke für die zahlreichen Beiträge.

Zitat von NamenLozer:

Wie viele Punkte sind es denn ungefähr?

Ich vermute, das wird 50.000 nicht deutlich überschreiben, aber theoretisch könnten es auch 1 Million sein. Das ganze muss fortlaufend für 8 Kurven berechnet werden. D.h. es muss schnell gehen.

1 Million Punkte zu prüfen hat heute ca. 2-3 Sekunden gedauert nach meinem bisherigen Vorgehen. Das ist natürlich langsam.

Die binäre Suche und die anderen Algorithmen werden vermutlich nicht funktionieren, zumindest nicht wie gewünscht.

Würde die Steigung der Kurve immer positiv sein, wäre denkbar, mit dieser Suche, die jeweils linken und rechten Kanten der Fenster zu bestimmen. Ist die Steigung innerhalb eines Fensters sehr groß und tritt die Kurve unten in das Fenster ein, komme ich mit den Algorithmen dennoch nur zur linken Kante. D.h. ich muss sämtliche Werte in den Fenstern weiterhin prüfen, da hier der Y-Wert ausschlaggebend ist.

Eine weitere Schwierigkeit ist, dass die Kurve auch "zurück laufen" kann. Es handelt sich also nicht um eine mathematische Funktion.
Ja, langsam wird's kompliziert.

Grüße, Matze

[blackfin]

Zitat:

Das ganze muss fortlaufend für 8 Kurven berechnet werden. D.h. es muss schnell gehen.

Ist das eine Echtzeit-Operation?
Wenn ja, wär es vielleicht sogar anzudenken, das ganze über die Grafikkarte und OpenGL zu machen und die Punkte als Vertices in die Grafikkarte zu jagen.
Dann hättest du schlussendlich so ziemlich alle Möglichkeiten, die dir Occlusion Tests der Hardware so bieten.
Aber ich denke, für dein Projekt ist das wohl etwas zuviel des Guten?

[Namenloser]

Zitat von Matze:

Ich vermute, das wird 50.000 nicht deutlich überschreiben, aber theoretisch könnten es auch 1 Million sein. Das ganze muss fortlaufend für 8 Kurven berechnet werden. D.h. es muss schnell gehen.

Das heißt also, die Daten kommen in Echtzeit herein? Also es ist nicht möglich, die Daten vorher optimiert (z.B. als Quadtree) abzuspeichern? Das verkompliziert die Sache natürlich...

[edit]
Das wäre jetzt der Punkt, wo ich anfangen würde, über manuelle Optimierungen und Multithreading das meiste aus der Implementierung herauszuholen, da ich bezweifle, dass es in diesem Fall eine schnellere Lösung gibt, als für jeden Punkt den Vergleich auszuführen, wenn die Daten in Echtzeit hereinkommen. Denn jede optimierte Suche setzt irgendeine Sortierung voraus, und die minimale Laufzeit für einen Sortieralgorithmus beträgt laut Wikipedia O(n*log(n)). Ein einfacher Durchlauf über alle Punkte hingegen hat eine lineare Laufzeit von O(n), und ist somit bei deinen Datenmengen wahrscheinlich schneller als die Sortierung allein. Disclaimer: Ich habe kein Informatik studiert (noch nicht ).
[/edit]