Drehsinn von Ebenen

[Bjoerk]

Für D2 hab ich's doch direkt über deinem Post gepostet?

Delphi-Quellcode:

function TD2Points.ClockwiseOrder(const J: integer): boolean;
var
  I, K: integer;
  D: double;
begin
  I := Prev(J);
  K := Next(J);
  D := FItems[I].X * FItems[J].Y + FItems[J].X * FItems[K].Y + FItems[K].X * FItems[I].Y
    - FItems[J].Y * FItems[K].X - FItems[K].Y * FItems[I].X - FItems[I].Y * FItems[J].X;
  Result := D > 0;
end;

So gehts für D3 schon mal nicht.

Code:

     xA, yA, zA, 1
     xB, yB, zB, 1
Det   xC, yC, zC, 1  > 0
      0,  0,  0, 1

[Jens01]

Zitat:

D2, D3

Na, schon etwas überarbeitet?

Ich über den Ansatz Matrix komme ich nicht, aber über den Ansatz mit Vektoren.
Das müßte doch einfach mit dem Crossprodukt gehen, oder? Ich habe sowas für Polygonflächen in 3D.
Ist das nicht schon das Gesuchte :

Delphi-Quellcode:

    A     := 0;
    for i := 2 to Self.Count - 1 do
    begin
      t := Triangle.Create(Self[0], Self[i], Self[i - 1]);
      A := A + t.CrossProdukt;
    end;
    Result := A.Length / 2;

function Triangle.CrossProdukt: Vektor;
var
  R1, R2: Vektor;
begin
// FA, FB, FC => Vektoren des Triangle
  R1     := FC - FA;
  R2     := FB - FA;
  Result := R1.CrossProduct(R2);
end;

[Bjoerk]

Hi Bud,

wollte nicht "überarbeitet" rüberkommen. Sorry. Kann sein, daß das Kreuzprdukt bei bei D2 funzt, aber defintiv nicht bei D3.

Damit hat's (bis jetzt) für alle Beispiele gefunzt (aber nur, wenn man das System in den Urpsrung (0,0,0) verschiebt).

Delphi-Quellcode:

    |xA, yA, zA, 1|
    |xB, yB, zB, 1|
Det |xC, yC, zC, 1| > 0
    | 1,  1,  1, 1|

[Jens01]

Zitat:

aber nur, wenn man das System in den Urpsrung (0,0,0) verschiebt

Ist das ein Problem?

[Bjoerk]

Das ist sicherlich no problem. Arber, das Problem ist, einen geeigneten Vektor zu finden um die fehlende Zeile der Determinante zu ergänzen. Hatte eben einen Fall wo es nicht ging. Ich lass es jetzt. Wenn noch jemand eine Idee zu hat, bitte her damit. Ich bin meinem Latein am Ende. Muß halt aufpassen daß ich die Ebenen korrekt eingebe.

Delphi-Quellcode:

    |xA, yA, zA, 1|
    |xB, yB, zB, 1|
Det |xC, yC, zC, 1| > 0
    | ?, ?,   ?, ?|

Dank' Dir und Gruß alle, die hier mitgewirkt haben.

[Jens01]

Du bist irgendwie so auf Matrix/Determinante fixiert. Vllt machst Du es doch mit dieser Flächenberechnung bzw Crossprodukt. Bis dahin...

[BUG]

Wie soll der Drehsinn in 3D überhaupt definiert sein
Wenn man das ganze auf eine festgelegte Ebene projiziert dann kann man wieder den 2D-Ansatz nehmen.
In deinem Beispiel wäre die Projektionsebene eine die parallel zur x- und zur y-Achse ist.

Ansonsten macht das Ganze imho nicht so viel Sinn.

[Bjoerk]

Hab auch nochmal überlegt. Ich mach es lieber mit einem Referenzvektor. Den soll/kann eine Ebene bekommen. Wären entweder (1, 0, 0) oder (0, 1, 0) oder (0, 0, 1) oder (-1, 0, 0) oder (0, -1, 0) oder (0, 0, -1) und vergleiche auf <0.

Code:

  IsNeg = (PlaneNormal.X * V.X < 0) or (PlaneNormal.Y * V.Y < 0) or (PlaneNormal.Z * V.Z < 0).

Ich denke mal dieser Vektor wäre auch die 4. Zeile für die Determinante von #19. Keine Ahnung?

Wenn A,B,C die 1. Ersten drei Punkte der Ebene sind, dann geht der Normaldingens doch so, oder?

Delphi-Quellcode:

function TPolyeder.PlaneNormal(const A, B, C: integer): TPolyederPoint;
var
  AB, AC: TPolyederPoint;
begin
  AB.X := FPoints[B].X - FPoints[A].X;
  AB.Y := FPoints[B].Y - FPoints[A].Y;
  AB.Z := FPoints[B].Z - FPoints[A].Z;

  AC.X := FPoints[C].X - FPoints[A].X;
  AC.Y := FPoints[C].Y - FPoints[A].Y;
  AC.Z := FPoints[C].Z - FPoints[A].Z;

  Result.X := AB.Y * AC.Z - AB.Z * AC.Y;
  Result.Y := AB.Z * AC.X - AB.X * AC.Z;
  Result.Z := AB.X * AC.Y - AB.Y * AC.X;

  Showmessage(Format('%.4f, %.4f, %.4f', [Result.X, Result.Y, Result.Z]));
end;