Hidden-Lines-Algorithmus

[Behrendt]

Hallo Leute!
Im Zuge meiner Informatik-Facharbeit Jgst. 12 habe ich die Aufgabe bekommen mit Delphi den Hidden-Lines-Algorithmus zu programmieren. Als ich das Thema bekommen habe, war ich erstmal etwas perplex, da wir in Delphi zuvor nie viel mehr als ein paar simple Canvas-Spielereien gemachth haben. Aber ich habe jetzt mal angefangen mich dieser Thematik anzunehmen. Erstmal habe ich die Umwandlung von dreidimensionalen Koordinaten auf 2-dimensionale Koordinaten geschrieben. Desweiteren habe ich schon mal ein bisschen mit Verbindungen der Punkte rumgespielt, aber ich denke die ganz normale LineTo-Methode ist nicht sehr geeignet für das was ich vorhabe oder? Da wäre ja viel zu viel Rechenaufwand mit verbunden. Es wäre sicherlich einfacher die Punkte bzw. die zu zeichnenden Polygone vorzusotieren und dann nacheinander übermalen zu lassen. Geritten von dieser Idee habe ich mir mal den Polygon-Befehl angeguckt, aber steige da noch nicht ganz durch, da ich ja dafür irgendwie ein TPoint-Array benutzen muss. Aber über die globale Deklarieung des selbigen komme ich auch garnicht raus. Das Handbuch bzw. die Hilfe gibt da auch nicht sehr viel her. Ich hänge euch mal meinen Code an, ich hoffe ihr steigt da so weit durch, ist bestimmt ein Horror für euch, denn ich bin ungeübt im programmieren muss ich sagen! Bin für alle Tipps dankbar, nicht nur die zum Polygon-Zeichnen, sondern auch was Lesbarkeit, Redundanz, etc. angeht könnt ihr kritisieren was das Zeug hält!

Delphi-Quellcode:

var
  Form1: TForm1;
  x,xp,y,yp,z,d,h,a:integer;
  Ko_X:array [1..100] of Real;
  Ko_Y:array [1..100] of Real;
  Ko_Z:array [1..100] of Real;
  Ko_Xp:array [1..100] of Real;
  Ko_Yp:array [1..100] of Real;
implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var i,j:integer;
begin
a:=Trunc(Image1.Width/2); // Verschiebt den Ursprung des Koordinatensystems auf der Leinwand
d:=StrToInt(Edit1.Text); // Beschreibt den Abstand des Betrachters zur Bildebene
h:=Trunc(Image1.Height/2); // Verschiebt den Ursprung des Koordinatensystems auf der Leinwand

// Koordinaten der Punkte des Würfels
Ko_X[1]:=(100);
Ko_Y[1]:=(100);
Ko_Z[1]:=(100);
Ko_X[2]:=(100);
Ko_Y[2]:=(100);
Ko_Z[2]:=(200);
Ko_X[3]:=(200);
Ko_Y[3]:=(100);
Ko_Z[3]:=(200);
Ko_X[4]:=(200);
Ko_Y[4]:=(100);
Ko_Z[4]:=(100);
Ko_X[5]:=(100);
Ko_Y[5]:=(200);
Ko_Z[5]:=(100);
Ko_X[6]:=(100);
Ko_Y[6]:=(200);
Ko_Z[6]:=(200);
Ko_X[7]:=(200);
Ko_Y[7]:=(200);
Ko_Z[7]:=(200);
Ko_X[8]:=(200);
Ko_Y[8]:=(200);
Ko_Z[8]:=(100);

with Image1.Canvas do
  begin
  { Einstellen der Farbe, in der gezeichnet wird }
  Brush.Color := clblack;
  Pen.Color := clblack;
  { Umrechnen der gegebenen 3-dimensionalen Koordinaten
    in 2-dimensionale Koordinaten auf der Bildebene }
  for i:= 1 to 8 do
    begin
      Ko_Xp[i]:=a+(d/(d+Ko_Z[i]))*Ko_X[i];
      Ko_Yp[i]:=h+(d/(d+Ko_Z[i]))*Ko_Y[i];
    end;
  i:=1;

  // Kanten
  for j:= 1 to 8 do
    begin
      moveto(Trunc(Ko_Xp[i]),Trunc(Ko_Yp[i]));
      if i=4 then i:=0;
      if i=8 then i:=4;
      lineto(Trunc(Ko_Xp[i+1]),Trunc(Ko_Yp[i+1]));
      if i=0 then i:=5;
      i:=i+1;
    end;
  end;
end;

procedure TForm1.Button2Click(Sender: TObject);
// Löschen der Bildebene
begin
  with Image1.Canvas do
    begin
    Brush.Color := clwhite;
    Pen.Color := clwhite;
    rectangle(0,0,Trunc(Image1.Width),Trunc(Image1.Height));
    end;
end;


end.

MfG
Behrendt

[Zacherl]

Was mir spontan auffällt sind die vielen Trunc() Befehle an eigentlich unnötigen Stellen. Koordinaten werden sowieso immer als ganze Zahlen angegeben, von daher musst du sie nicht erst durch Trunc jagen. Das gillt sowohl für MoveTo, LineTo, RectAngle sowie auch für Image.Width / Height, etc

Die einzige Trunc Stelle die sinnvoll ist wäre diese:

Delphi-Quellcode:

Trunc(Image1.Width/2)

Aber selbst hier würde ich ein

Delphi-Quellcode:

Image1.Width div 2

bevorzugen.

[Behrendt]

Ohne Trunc klappt es aber nicht. Dann krieg ich immer "Interger nicht kompatibel zu Extended" als Fehlermeldung beim kompilieren. Was ja auch logisch ist, die LineTo Befehle können ja nur Integer Zahlen sein weil ganze Pixel, aber die Berechnungen habe ich extra in Real gemacht, damits da genauer bliebt. Ob das dann aber wieder notwendig ist weiß ich auch nicht, aber sicher ist sicher. :stupid:

[Kroko1999]

(a) in Button2Click ist das Trunc unnötig
(b)

Delphi-Quellcode:

Width shr 1;

ist noch schneller als div
(c) zu deinem Problem mal google bzw. Tiefensortierung als Stichwort

[Zacherl]

Wieso bitte ist in Button2 das Trunc notwendig? :gruebel:

[Behrendt]

Ok stimmt, das habe ich übersehen, bei den Buttons kann und werde ich es dann entfernen. Mit den Koordinaten meinte ich die Koordinaten der Punkte im Raum, da hab ich für die Umrechnung Real gewählt. ;)
Und wie ist das mit dem Polygon - geht das nur über TPoint-Array? Wenn ja wie funktionieren diese? Meine Versuche haben da bisher kläglich fehlgeschlagen :/

[Kroko1999]

(A) Mal die Hilfe gelesen

Zitat:

Zeichnet eine Folge von Linien auf der Zeichenfläche. Dazu werden die in Points übergebenen Punkte durch Linien miteinander verbunden. Zuletzt wird die Form durch eine Linie zwischen dem Letzten und dem ersten Punkt geschlossen.

Klasse
TCanvas

Syntax


[Delphi] procedure Polygon(var Points: array of TPoint);


Beschreibung
Mit der Methode Polygon können Sie unter Verwendung des aktuellen Stifts eine in sich geschlossene, vieleckige Form zeichnen. Die fertiggestellte Form wird mit den aktuell für Brush festgelegten Parametern gefüllt.

Der Parameter Points ist ein Array mit den Scheitelpunkten des Polygons.

, also geht es nur so
(B) Tipp: Wandle den array of "Float"-points in ein Array of "Integer"-Points einma komplett um und zeichne dann dein(e) Polygon(e)
(C) verwende statt Trunc Round(wird genauer)!

[mimi]

Delphi-Quellcode:

Ko_X:array [1..100] of Real;
  Ko_Y:array [1..100] of Real;
  Ko_Z:array [1..100] of Real;
  Ko_Xp:array [1..100] of Real;
  Ko_Yp:array [1..100] of Real;

Das könntest du auch noch optimieren:

Delphi-Quellcode:

  TMyPoint = record
    y,z:Real
  end;

  ko, koP:array[100] of TMyPoint

Ich hoffe du kannst damit was anfangen.

dann kannst du mit: ko[index].y:=wert z.b. auf einzelne Fehler zurückgreifen.

Ein Record sammelt einfach nur Variablen. Damit ersparst du dir viel Abreit !

[Behrendt]

Da bin ich wieder. Ich habe mir mal die Tipps hier zu Gemüte geführt und dann heute etwas optimierungsarbeit geleistet. Ist zwar jetzt etwas mehr Code glaube ich, aber viel angenehmer zu lesen und leichter zu handhaben. Desweiteren denke ich, dass das erlernen des records ziemlich gut war für mich.

Delphi-Quellcode:

unit m_beta02;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls;

type
  TPoly = record
    Punkt1,Punkt2,Punkt3,Punkt4: TPoint;
  end;

type
  TMyPoint = record
    X_Koordinate,Y_Koordinate,Z_Koordinate: Real;
  end;

  type
  TForm1 = class(TForm)
    Image1: TImage;
    Button1: TButton;
    Edit1: TEdit;
    Label1: TLabel;
    Button2: TButton;
    procedure Button2Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;
  Punkt:array [1..100] of TMyPoint;
  Ko_B:array [1..100] of TPoint;
  poly:array [1..100] of TPoly;
implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var i,d,h,a:integer;
begin
a:=Image1.Width div 2; // Verschiebt den Ursprung des Koordinatensystems auf der Leinwand
d:=StrToInt(Edit1.Text); // Beschreibt den Abstand des Betrachters zur Bildebene
h:=Image1.Height div 2; // Verschiebt den Ursprung des Koordinatensystems auf der Leinwand

// Koordinaten der Punkte des Würfels
with Punkt[1] do
  begin
    X_Koordinate:= (100);
    Y_Koordinate:= (100);
    Z_Koordinate:= (100);
  end;

with Punkt[2] do
  begin
    X_Koordinate:= (100);
    Y_Koordinate:= (100);
    Z_Koordinate:= (200);
  end;

with Punkt[3] do
  begin
    X_Koordinate:= (200);
    Y_Koordinate:= (100);
    Z_Koordinate:= (200);
  end;

with Punkt[4] do
  begin
    X_Koordinate:= (200);
    Y_Koordinate:= (100);
    Z_Koordinate:= (100);
  end;

with Punkt[5] do
  begin
    X_Koordinate:= (100);
    Y_Koordinate:= (200);
    Z_Koordinate:= (100);
  end;

with Punkt[6] do
  begin
    X_Koordinate:= (100);
    Y_Koordinate:= (200);
    Z_Koordinate:= (200);
  end;

with Punkt[7] do
  begin
    X_Koordinate:= (200);
    Y_Koordinate:= (200);
    Z_Koordinate:= (200);
  end;

with Punkt[8] do
  begin
    X_Koordinate:= (200);
    Y_Koordinate:= (200);
    Z_Koordinate:= (100);
  end;

{ Umrechnen der gegebenen 3-dimensionalen Koordinaten
  in 2-dimensionale Koordinaten auf der Bildebene }

  for i:= 1 to 8 do
    begin
      Ko_B[i]:=Point
                ( round(a+(d/(d+Punkt[i].Z_Koordinate))*Punkt[i].X_Koordinate),
                  round(h+(d/(d+Punkt[i].Z_Koordinate))*Punkt[i].Y_Koordinate));
    end;
{ Definition der Polygone }

with poly[1] do
  begin
    Punkt1:= Ko_B[2];
    Punkt2:= Ko_B[3];
    Punkt3:= Ko_B[7];
    Punkt4:= Ko_B[6];
  end;

with poly[2] do
  begin
    Punkt1:= Ko_B[5];
    Punkt2:= Ko_B[6];
    Punkt3:= Ko_B[7];
    Punkt4:= Ko_B[8];
  end;

with poly[3] do
  begin
    Punkt1:= Ko_B[1];
    Punkt2:= Ko_B[2];
    Punkt3:= Ko_B[6];
    Punkt4:= Ko_B[5];
  end;

with poly[4] do
  begin
    Punkt1:= Ko_B[3];
    Punkt2:= Ko_B[4];
    Punkt3:= Ko_B[8];
    Punkt4:= Ko_B[7];
  end;

with poly[5] do
  begin
    Punkt1:= Ko_B[1];
    Punkt2:= Ko_B[4];
    Punkt3:= Ko_B[8];
    Punkt4:= Ko_B[5];
  end;

with poly[6] do
  begin
    Punkt1:= Ko_B[1];
    Punkt2:= Ko_B[2];
    Punkt3:= Ko_B[3];
    Punkt4:= Ko_B[4];
  end;


{ Zeichnen des Objektes }

with Image1.Canvas do
  begin
  { Einstellen der Farbe, in der gezeichnet wird }
    Brush.Color := clwhite;
    Pen.Color := clblack;
  { Zeichnen der Polygone in richtiger Reihenfolge }
    for i:= 1 to high(poly) do
    Polygon([poly[i].Punkt1,poly[i].Punkt2,poly[i].Punkt3,poly[i].Punkt4]);
 end;
end;

procedure TForm1.Button2Click(Sender: TObject);

// Löschen der Bildebene

begin
  with Image1.Canvas do
    begin
      Brush.Color := clwhite;
      Pen.Color := clwhite;
      rectangle(0,0,Image1.Width,Image1.Height);
    end;
end;


end.

So wie das Programm jetzt ist kriege ich schon nen anständigen Würfel gezeichnet. Mehr als ich mir zu Anfang hätte erträumen lassen. Allerdings steckt dahinter ja noch kein Algorithmus. Also muss ich es irgendwie hinkriegen, dass jedem zu zeichnendem Polygon eine gewisse Priorität zugewiesen wird, so dass ich diese dann sortieren kann und in einer Schleife zeichnen lassen kann. Ich denke so Sachen wie Z-Buffer sind hierfür zu komplex oder? Ich lese mir gerade etwas zur erwähnten Tiefensortierung durch und da wird schon mit Normalen gearbeitet. Was meint ihr? Sind diese Sachen notwendig, und wenn ja überhaupt machbar? Habe die Abgabe am 10.März!
MfG
Christian

[mimi]

Also der code ist schonmal nicht schlecht, Aber du kannst ihn weiter verkürzten

Delphi-Quellcode:

with poly[6] do
  begin
    Punkt1:= Ko_B[1];
    Punkt2:= Ko_B[2];
    Punkt3:= Ko_B[3];
    Punkt4:= Ko_B[4];
  end;

Das wiederholst du acht mal. Schau mal nach was Funktionen bzw. Proceduren sind. Dann könnte man das so zusammen fasssen:

Delphi-Quellcode:

procedure From1.SetPoly(const Index, index1, index2, index3, index4:Integer);
begin
  poly[index].Punkt1:= Ko_B[index1];
  poly[index].Punkt2:= Ko_B[index2];
  poly[index].Punkt3:= Ko_B[index3];
  poly[index].Punkt4:= Ko_B[index4];
end; //  From1.SetPoly

// aufgerufen könnte diese Procedure so werden:
SetPoly(1,2,3,7,6);

ich hoffe das Prinzip ist dir Klar...
Hier findest du noch mehr Interessante sachen:
http://www.delphi-treff.de/tutorials/

[Behrendt]

Dankeschön, das kannte ich noch nicht. Unser Infolehrer hat uns immer gesagt, wir sollten bloß keine Prozeduren oder so etwas selbst einfügen in den Text oO Aber das Prinzip ist natürlich einleuchtend, habs dann für die Punkte auch noch direkt mitgemacht und somit natürlich dann auch wieder etliche Zeilen Code gespart. Danke!

[Matze]

Ich habe die Off-Topic-Beitrage, in denen über den Info-Lehrer diskutiert wird, entfernt. Das gehört nicht hier her und es gab schon so viele Diskussionen darüber. Info-Lehrer sind nicht immer die besten, damit muss man sich abfinden.

Schriebt nun bitte nur noch Dinge, die auch zum Thema gehören, danke.

[Laufi]

Wo ist das wo ich geschrieben habe? :gruebel:

Liebe Grüsse
Laufi

[mimi]

@Behrendt
Proceduren und Funktionen sind Praktische Hilfsmittel um einen Code "Sauber" zu halten.
Natürlich spielt die OOP auch eine wichtige Rolle dabei. Schönen Code zu erstellen der leicht gewartet werden kann.

Ach ja nicht zu vergessen, den code in mehrer Units aufteilen auch wenn das zu Problemen führen kann über die ich immer wieder gerne Stolpere. Eine Fehler Meldung in diesem Zusammenhang ist die Meldung,
wenn du zwei Units hast die sich gegenseitig "brauchen". und du nicht einfach in den zweiten Uses abschnitt ausweichen kannst.

Aber für dich währe das glaube ich noch zu früh... daher reichen Records erstmal würde ich sagen.

Zu deinem Problem kann ich dir leider nicht weiter Helfen.... also das mit dem Würfel. Außer hier mal zu suchen:
www.delphigl.com

[Behrendt]

So, ich denke ich bin fertig mit dem Programm.

Delphi-Quellcode:

unit m_beta03;

interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls;
type
  TPoly = record
    Punkt1,Punkt2,Punkt3,Punkt4: TPoint;
    h_0,h_1,h_2,h_3,h_4: Integer;
  end;
type
  TMyPoint = record
    X_Koordinate,Y_Koordinate,Z_Koordinate: Real;
  end;
type
  TForm1 = class(TForm)
    Image1: TImage;
    Button1: TButton;
    Edit1: TEdit;
    Label1: TLabel;
    Button2: TButton;
    ListBox1: TListBox;
    procedure SetPunkt(const Index:Integer; KoorX,KoorY,KoorZ:Real);
    procedure SetPoly(const Index, index1, index2, index3, index4:Integer);
    procedure Tiefensortierung;
    procedure Button2Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;
var
  Form1: TForm1;
  distanz:array [1..100] of Real;
  poly_mitte:array [1..100] of TMyPoint;
  Punkt:array [1..100] of TMyPoint;
  Ko_B:array  [1..100] of TPoint;
  poly:array [1..6] of TPoly;
implementation

{$R *.dfm}

{ Zeichen-Prozedur }

procedure TForm1.Button1Click(Sender: TObject);
var i,d,h,a:integer;
begin

  ListBox1.Items.Clear; { Löscht alle Elemente der Listbox, von evt. vorherigen Zeichnungen }
  a:=Image1.Width div 2; { Verschiebt den Ursprung des Koordinatensystems auf der Leinwand }
  d:=StrToInt(Edit1.Text); { Beschreibt den Abstand des Betrachters zur Bildebene }
  h:=Image1.Height div 2; { Verschiebt den Ursprung des Koordinatensystems auf der Leinwand }

{ Definition von Punkten für spätere Polygone }
  { SetPunkt(Index im Array, X-Koordinate, Y-Koordinate, Z-Koordinate) }

  SetPunkt(1,-200,100,100);
  SetPunkt(2,-200,100,200);
  SetPunkt(3,200,100,200);
  SetPunkt(4,200,100,100);
  SetPunkt(5,-200,200,100);
  SetPunkt(6,-200,200,200);
  SetPunkt(7,200,200,200);
  SetPunkt(8,200,200,100);

{ Umrechnen der gegebenen 3-dimensionalen Koordinaten
  in 2-dimensionale Koordinaten auf der Bildebene }

  for i:= 1 to 8 do
    begin
      Ko_B[i]:=Point
                ( round(a+(d/(d+Punkt[i].Z_Koordinate))*Punkt[i].X_Koordinate),
                  round(h+(d/(d+Punkt[i].Z_Koordinate))*Punkt[i].Y_Koordinate));
    end;

{ Definition von Polygonen }
  { SetPoly (Index im Array, 1.Punkt, 2.Punkt, 3.Punkt, 4.Punkt) }

  SetPoly(6,2,3,7,6);
  SetPoly(1,5,6,7,8);
  SetPoly(4,1,2,6,5);
  SetPoly(5,3,4,8,7);
  SetPoly(2,1,4,8,5);
  SetPoly(3,1,2,3,4);

{ Durchführung der Tiefensortierung }

  Tiefensortierung;

{ Zeichnen des Objektes }

with Image1.Canvas do
  begin

{ Einstellen der Farbe, in der gezeichnet wird }

    Brush.Color := clwhite;
    Pen.Color := clblack;

{ Zeichnen der Polygone in richtiger Reihenfolge }

    for i:= 1 to high(poly) do
    Polygon([poly[i].Punkt1,poly[i].Punkt2,poly[i].Punkt3,poly[i].Punkt4]);
 end;
end;


{ Definitions-Prozedur für einen Punkt im 3D-Raum }

procedure TForm1.SetPunkt(const Index:Integer; KoorX,KoorY,KoorZ:Real);
  begin
    with Punkt[index] do
      begin
        X_Koordinate:= (KoorX);
        Y_Koordinate:= (KoorY);
        Z_Koordinate:= (KoorZ);
      end;
end;

{ Definitions-Prozedur für ein Polygon }

procedure TForm1.SetPoly(const Index, index1, index2, index3, index4:Integer);
begin
  poly[index].h_0:=Index;
  poly[index].Punkt1:= Ko_B[index1];
  poly[index].h_1:= index1;
  poly[index].Punkt2:= Ko_B[index2];
  poly[index].h_2:= index2;
  poly[index].Punkt3:= Ko_B[index3];
  poly[index].h_3:= index3;
  poly[index].Punkt4:= Ko_B[index4];
  poly[index].h_4:= index4;
end;

{ Löschen der Bildebene }

procedure TForm1.Button2Click(Sender: TObject);
begin
  ListBox1.Items.Clear;
    with Image1.Canvas do
      begin
        Brush.Color := clwhite;
        Pen.Color := clwhite;
        rectangle(0,0,Image1.Width,Image1.Height);
      end;
end;

{ Tiefensortierungsprozedur }

procedure TForm1.Tiefensortierung;
var i,j: Integer;
    t: Real; { Speichervariable für Sortierung }
    t_1: TPoly; { Speicherobjekt der Klasse TPoly für Sortierung }

begin
  for i:= 1 to high(poly) do
    begin
      { Errechnen des Mittelpunktes einer Fläche }

      with poly_mitte[i] do
        begin
          X_Koordinate:= (Punkt[poly[i].h_1].X_Koordinate +
                          Punkt[poly[i].h_2].X_Koordinate +
                          Punkt[poly[i].h_3].X_Koordinate +
                          Punkt[poly[i].h_4].X_Koordinate) / 4;
          Y_Koordinate:= (Punkt[poly[i].h_1].Y_Koordinate +
                          Punkt[poly[i].h_2].Y_Koordinate +
                          Punkt[poly[i].h_3].Y_Koordinate +
                          Punkt[poly[i].h_4].Y_Koordinate) / 4;
          Z_Koordinate:= (Punkt[poly[i].h_1].Z_Koordinate +
                          Punkt[poly[i].h_2].Z_Koordinate +
                          Punkt[poly[i].h_3].Z_Koordinate +
                          Punkt[poly[i].h_4].Z_Koordinate) / 4;

         { Errechnen der Distanz vom Mittelpunkt einer Fläche zum Koordinatenursprung/Betrachter }

         Distanz[i]:= sqrt( sqr(Poly_Mitte[i].X_Koordinate)+
                            sqr(Poly_Mitte[i].Y_Koordinate)+
                            sqr(Poly_Mitte[i].Z_Koordinate)   ) ;

        end;
      end;

{ Ausgabe der unsortierten Eingabe in die ListBox }

  ListBox1.Items.Add('Unsortierte Eingabe:');
  ListBox1.Items.Add('');
  for i:=1 to high(Poly) do
    begin
      ListBox1.Items.Add('Polygon Nr.' + IntToStr(poly[i].h_0)+':');
      ListBox1.Items.Add('Distanz - ' + FloatToStr(Distanz[i])) ;
      ListBox1.Items.Add('Umlaufsinn - '+IntToStr(poly[i].h_1)+'-' + IntToStr(poly[i].h_2)+'-'+IntToStr(poly[i].h_3)+'-' + IntToStr(poly[i].h_4));
    end;

{ Sortierung der Polygone nach Distanz }

  for j:= 1 to high(Distanz) do
    begin
      for i:= 1 to high(Distanz)-1 do
        begin
          if Distanz[i]<Distanz[i+1] then
            begin
              t:= Distanz[i];
              t_1:= Poly[i];
              Distanz[i] := Distanz[i+1];
              Poly[i] := Poly [i+1];
              Distanz[i+1]:= t;
              Poly[i+1]:= t_1;
            end;
        end;
    end;

{ Ausgabe der tiefensortierten Eingabe in die ListBox }

  ListBox1.Items.Add('');
  ListBox1.Items.Add('Tiefensortierte Eingabe');
  ListBox1.Items.Add('');
  for i:=1 to high(Poly) do
    begin
      ListBox1.Items.Add('Polygon Nr.' + IntToStr(poly[i].h_0)+':');
      ListBox1.Items.Add('Distanz - ' + FloatToStr(Distanz[i])) ;
      ListBox1.Items.Add('Umlaufsinn - '+IntToStr(poly[i].h_1)+'-' + IntToStr(poly[i].h_2)+'-'+IntToStr(poly[i].h_3)+'-' + IntToStr(poly[i].h_4));
    end;
end;

end.

Ich kann die Polygone jetzt in einer beliebigen Reihenfolge eingeben und er sortiert sie mir nach der Distanz zum Betrachter und zeichnet sie dann so, dass Flächen die näher zum Betrachter liegen andere Flächen überlappen. Ich werde dann jetzt mit dem theoretischen Teil meiner Facharbeit fortfahren und dort alles ausführlich beschreiben. Danach werde ich evt. noch ein oder zwei andere Modelle einbinden, die etwas komplexer sind als ein Würfel, um neben der Listbox eine weitere Demonstration zu haben, dass das ganze wirklich klappt. Ich danke an alle die mir hier tatkräftig geholfen haben. Falls jemand immer noch Tipps hat, was ich am Code ändern könnte - nur raus damit!
MfG

[3_of_8]

Zitat:

Zitat von Kroko1999

(b)

Delphi-Quellcode:

Width shr 1;

ist noch schneller als div

Das ist nicht ganz richtig. Erstens ist ein shr hier verwirrend, ein div 2 und man weiß sofort, was gemeint ist. Außerdem übersetzt der Compiler ein div 2 sowieso mit shr. Derartige Optimierungen werden vom Compiler selbst durchgeführt, wenn der Programmierer sie macht, verschlechtern sie nur die Lesbarkeit des Codes.

[Kroko1999]

Laut meinem CPU fenster steht dort ein SAR!

[3_of_8]

Das ist abhängig davon, welchen Datentypen du verwendest. Wenn er ein Vorzeichen hast, sar, ansonsten shr. Kommt aber von der Geschwindigkeit her auf das gleiche raus.