Hidden-Lines-Algorithmus

[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.