2 Vektoren und 1 Punkt, wo näher drann?

[Aphton]

Also entweder so, wie bei Antwort #7 beschrieben, lösen ODER vielleicht so... (längere Variante; sofern keine Fehler vorhanden sind)

[Medium]

Irks, wo Trigonometrie vermeidbar ist, sollte man das finde ich auch tun. Die ist langsam, anfällig für unerwartete Fehler (Polstellen und so Gemeinheiten), und gerade in der Nähe von Grenzfällen auch hart an der sinnvoll verwendbaren Genauigkeit von Floats. Das ist alles prima mit schöner, schlanker linearen Algebra lösbar, was fast immer der bessere Weg ist, wenn er möglich ist.

Edit: Zudem würde man so auch ein unsinniges "h" bekommen, wenn die Höhe nicht mehr auf der Hypotenuse steht, sondern auf ihrer Verlängerung zur Geraden. Das wäre der gleiche Fall, der bei einer algebraischen Lösung (Geradenschnitt) einen Parameter ausserhalb (0, 1) liefert, und dadurch sehr einfach erkenn- und behandelbar ist.

[Jonas Shinaniganz]

Okay Ich habe jetzt weitestgehend Antwort7 umgesetzt und auch einen Vektor2D eingeführt.

Delphi-Quellcode:

function TSetPoints.PrevLineCloser(Index : Integer; X, Y : Double): Boolean;
var
  NewPoint : TFloatPoint;

  A : TVector2d;
  B : TVector2d;
  B0 : TVector2d;
  H1, H2 : Double;

  PrevPoint, NextPoint, IndexPoint : TFloatPoint;

begin
  Result := True;

  NewPoint.X := X;
  NewPoint.Y := Y;

  PrevPoint.X := FPoints[Index - 1].FX;
  PrevPoint.Y := FPoints[Index - 1].FY;

  NextPoint.X := FPoints[Index + 1].FX;
  NextPoint.Y := FPoints[Index + 1].FY;

  IndexPoint.X := FPoints[Index].FX;
  IndexPoint.Y := FPoints[Index].FX;

  A := Vector2DGetFromTwoPoints(PrevPoint, NewPoint);
  B := Vector2DGetFromTwoPoints(PrevPoint, IndexPoint);

  B0 := Vektor2DMultiplyTwo(Vektor2DDivideWithFloat(B,1), B);
  H1 := Vector2DCrossProduct(A, B0);

  A := Vector2DGetFromTwoPoints(NextPoint, NewPoint);
  B := Vector2DGetFromTwoPoints(NextPoint, IndexPoint);

  B0 := Vektor2DMultiplyTwo(Vektor2DDivideWithFloat(B,1), B);
  H2 := Vector2DCrossProduct(A, B0);

  if (H1 < H2) then
    Result := False;
end;

Meine Funktionen zur Vektorrechnung sehen so aus:

Delphi-Quellcode:

function Vector2DCrossProduct(Vekt1, Vekt2 : TVector2D) : Double;
begin
  Result := Vekt1.X * Vekt2.Y - Vekt1.Y * Vekt2.X;
end;

Delphi-Quellcode:

function Vektor2DMultiplyTwo(Vekt1 : TVector2D; Vekt2 : TVector2D) : TVector2d;
begin
  Result.X := Vekt1.X + Vekt2.X;
  Result.Y := Vekt1.Y + Vekt2.Y;
end;

Delphi-Quellcode:

function Vektor2DDivideWithFloat(Vekt : TVector2D; Value : Double) : TVector2d;
begin
  Result.X := Value / Vekt.X;
  Result.Y := Value / Vekt.X;
end;

Delphi-Quellcode:

function Vector2DPointToOrt(P1 : TFloatPoint) : TVector2d;
begin
  Result.X := P1.X;
  Result.Y := P1.Y;
end;

Mein Vektor2D record ist so von euch übernommen:

Delphi-Quellcode:

  TVector2d = record
    procedure Assign(const newX, newY: Double);
    function Length: Double;
  case Boolean of
    False: (X: Double; Y: Double);
    True: (Values: Array[0..1] of Double);
  end;

Die Floatpoints sind:

Delphi-Quellcode:

  TFloatPoint = packed record
    X : Single;
    Y : Single;
  end;

Jetzt habe Ich leider immernoch nicht das gewünschte Verhalten, scheinbar sind H1 und H2 noch nicht wirklich das, was sie sein sollen. Ich Debugge nochmal ein bisschen und Poste hier meine Sourcen.

[Namenloser]

Ich sehe hier einen Fehler:
B0 := Vektor2DMultiplyTwo(Vektor2DDivideWithFloat(B,1), B);
Wenn Vektor2DMultiplyTwo das tun würde, was man erwartet (andere Baustelle, s.u.), nämlich zwei Vektoren komponentenweise zu multiplizieren, würde diese Rechnung darauf hinauslaufen, dass du immer den Vektor (1, 1) für B0 erhältst (weil (1/x)*x immer 1 ist (sofern x ≠ 0)).

Das wäre natürlich unsinnig. Du musst durch den Betrag des Vektors dividieren. Dieser ist definiert über den Satz des Pythagoras: |v| = sqrt(v.x² + v.y²), was deinem v.Length entsprechen sollte.
Korrekt wäre also:

Delphi-Quellcode:

B0.X := B.X/B.Length;
B0.Y := B.Y/B.Length;

Weiter zur nächsten Baustelle:

Delphi-Quellcode:

function Vektor2DMultiplyTwo(Vekt1 : TVector2D; Vekt2 : TVector2D) : TVector2d;
begin
  Result.X := Vekt1.X + Vekt2.X;
  Result.Y := Vekt1.Y + Vekt2.Y;
end;

Wieso heißt die Funktion „Multiply“, obwohl sie die Vektoren schlichtweg addiert?