Autor Beitrag
Squall_Titus
Hält's aus hier
Beiträge: 13



BeitragVerfasst: Fr 11.05.07 09:49 
Hi

Ich schreibe gerade an einem primitiven Zeichenprogramm und möchte jetzt objekte erst mit Farbe füllen, nachdem ich es gezeichnet habe und wenn ich es dann nochmals anklicke.
Bisher kann ich auswählen, ob es schon beim Zeichnen gefüllt werden soll oder nicht.
Wie kann ich jetzt das erst beim Klick realisieren.

Hier mal das komplette Programm:

ausblenden volle Höhe Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
//zeichenflaeche.pas

unit zeichenflaeche;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  Menus, ExtCtrls,zeichenobjekte;

type
  TForm1 = class(TForm)
    Panel1: TPanel;
    MainMenu1: TMainMenu;
    Datei1: TMenuItem;
    Beende1: TMenuItem;
    Ansicht1: TMenuItem;
    Einstellungen1: TMenuItem;
    Zeichnen1: TMenuItem;
    Punkt1: TMenuItem;
    Linie1: TMenuItem;
    Rechteck1: TMenuItem;
    Kreis1: TMenuItem;
    Stiftfarbe1: TMenuItem;
    Fllfarbe1: TMenuItem;
    Fllen1: TMenuItem;
    ColorDialog1: TColorDialog;
    PaintBox1: TPaintBox;
    Zeichnunglschen1: TMenuItem;
    Zwiederherstellen1: TMenuItem;
    Endgltiglschen1: TMenuItem;

    procedure Beende1Click(Sender: TObject);
    procedure Stiftfarbe1Click(Sender: TObject);
    procedure Fllfarbe1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure Punkt1Click(Sender: TObject);
    procedure Linie1Click(Sender: TObject);
    procedure Fllen1Click(Sender: TObject);
    procedure PaintBox1MouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
    procedure PaintBox1MouseMove(Sender: TObject; Shift: TShiftState; X,
      Y: Integer);
    procedure PaintBox1MouseUp(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
    procedure Rechteck1Click(Sender: TObject);
    procedure Kreis1Click(Sender: TObject);
    procedure PaintBox1Paint(Sender: TObject);
    procedure Zeichnunglschen1Click(Sender: TObject);
    procedure Zwiederherstellen1Click(Sender: TObject);
    procedure Endgltiglschen1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;
  prListe:TList;      //Delphi-Liste zum Abspeichern der Grafikobjekte
  zPunkt:TPunkt;
  zLinie:TLinie;
  zRechteck:TRechteck;
  zKreis:TKreis;
  //Instanzen für grafische Primitive

implementation
type TPrimitive=(undefiniert,Punkt,Linie,Rechteck,Kreis);
var Primitive:TPrimitive;
    zeichenmodus,fuellen:boolean;
    StiftFarbe,FuellFarbe:TColor;

{$R *.DFM}

//Methoden des Formulars sind die Ereignisroutinen

procedure TForm1.FormCreate(Sender: TObject);
//Aufruf bei Erzeugen des Hauptfensters, Anfangsinitialisierung
begin
  Primitive:=undefiniert;
  zeichenmodus:=false;
  fuellen:=false;
  StiftFarbe:=clBlack;
  FuellFarbe:=clWhite;
  prListe:=TList.create;
end;

//Datei-Menü ; Menüpunkt Beenden
procedure TForm1.Beende1Click(Sender: TObject);
begin  close  end;

//Einstellungen-Menü
//Menüpunkt : Stiftfarbe wählen
procedure TForm1.Stiftfarbe1Click(Sender: TObject);
begin
  colorDialog1.execute;
  Stiftfarbe:=ColorDialog1.Color
end;
//Menüpunkt : Füllfarbe wählen
procedure TForm1.Fllfarbe1Click(Sender: TObject);
begin
  colorDialog1.execute;
  Fuellfarbe:=ColorDialog1.Color
end;
//Menüpunkt : Füllmodus ein/ausschalten
procedure TForm1.Fllen1Click(Sender: TObject);
begin
  fuellen:=not fuellen;
  Fllen1.checked:=not Fllen1.checked;
end;

//Zeichnen-Menü
//Menüpunkt allgemein : jeweils
//  Auswahl: Was wird gezeichnet ?
//  Kennzeichnen des gewählten Menüpunktes
procedure TForm1.Punkt1Click(Sender: TObject);  //Punkt
begin
  Primitive:=Punkt;
  Punkt1.checked:=true;
  Linie1.checked:=false;
  Rechteck1.checked:=false;
  Kreis1.checked:=false
end;
procedure TForm1.Linie1Click(Sender: TObject);   //Linie
begin
  Primitive:=Linie;
  Punkt1.checked:=false;
  Linie1.checked:=true;
  Rechteck1.checked:=false;
  Kreis1.checked:=false
end;
procedure TForm1.Rechteck1Click(Sender: TObject); //Rechteck
begin
  Primitive:=Rechteck;
  Punkt1.checked:=false;
  Linie1.checked:=false;
  Rechteck1.checked:=true;
  Kreis1.checked:=false
end;
procedure TForm1.Kreis1Click(Sender: TObject);    //Kreis
begin
  Primitive:=Kreis;
  Punkt1.checked:=false;
  Linie1.checked:=false;
  Rechteck1.checked:=false;
  Kreis1.checked:=true
end;

//Mausroutinen - als Parameter beim Zeichnen wird jeweils das TCanvas-Objekt
//               PaintBox1.Canvas übergeben
//MouseDown
procedure TForm1.PaintBox1MouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
  //x,y liefert Position der Maus
begin
  case Primitive of  //Unterschiedliche Aktionen in Abhängigkeit v. gezeichneten Objekt
    Punkt : begin
              zPunkt:=TPunkt.create(x,y,StiftFarbe);  //Punktobjekt wird erzeugt
              zPunkt.zeichnen(PaintBox1.Canvas);  //Punkt wird gleich gezeichnet,
              prListe.add(zPunkt)                 //der Liste hinzugefügt
            end;
    Linie : begin
              zLinie:=TLinie.create(x,y,x,y,StiftFarbe); //Objekterzeugung
              zeichenmodus:=true                  //Beginn des Zeichenmodus
            end;
    Rechteck : begin
               zRechteck:=TRechteck.create(x,y,x,y,StiftFarbe,FuellFarbe,fuellen);
               zeichenmodus:=true                  // s. Linie
             end;
    Kreis : begin
               zKreis:=TKreis.create(x,y,x,y,StiftFarbe,FuellFarbe,fuellen);
               zeichenmodus:=true                  //s. Linie
             end;
    end
end;
//MouseMove
procedure TForm1.PaintBox1MouseMove(Sender: TObject; Shift: TShiftState; X,
  Y: Integer);
begin
  if zeichenmodus then   //nur Reaktion im Zeichenmodus
    case Primitive of
      Linie : zLinie.ziehen(x,y,PaintBox1.Canvas);
      Rechteck : zRechteck.ziehen(x,y,PaintBox1.Canvas);
      Kreis : zKreis.ziehen(x,y,PaintBox1.Canvas);
    end;
end;
//MouseDown
procedure TForm1.PaintBox1MouseUp(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
  if zeichenmodus then    //Pen-Modus umschalten für endgültiges Zeichnen
    with PaintBox1.Canvas do
      begin Pen.Mode:=pmCopy;
        Pen.Style:=psSolid
      end;
    case Primitive of     //Objekt endgültig zeichnen, der Liste hinzufügen
      Linie : begin
                zLinie.zeichnen(PaintBox1.Canvas);
                prListe.add(zLinie)
              end;
      Rechteck: begin
                zRechteck.zeichnen(PaintBox1.Canvas);
                prListe.add(zRechteck)
              end;
      Kreis : begin
                zKreis.zeichnen(PaintBox1.Canvas);
                prListe.add(zKreis)
              end;          
    end;
    zeichenmodus:=false   //Zeichenmodus aus
end;

//Reaktion auf OnPaint-Ereignis
//wird aufgerufen, wenn PaintBox neu gezeichnet werden muss
procedure TForm1.PaintBox1Paint(Sender: TObject);
var i:integer;
begin
  for i:=0 to prListe.count-1 do
    TGrafikObjekt(prListe.Items[i]).zeichnen(PaintBox1.Canvas)
  //Alle Einträge aus Liste entnehmen und neu zeichnen.
  //Da Methode zeichnen virtual definiert, wird jeweils die eigene
  //Zeichenmethode des entsprechenden Objektes verwendet
end;

//Menü : Ansicht
//Menüpunkt Zeichnung löschen, Paintbox überschreiben
//Achtung : Liste wird nicht gelöscht, nachfolgende Zeichnungen werden dieser hinzugefügt
//Besser wäre Bezeichnung : BS löschen
procedure TForm1.Zeichnunglschen1Click(Sender: TObject);
begin
  with Form1 do
    begin with PaintBox1.Canvas do
      begin
        Pen.Color:=clWhite;
        Brush.Color:=clWhite;
        Brush.Style:=bsSolid
      end;
      PaintBox1.Canvas.Rectangle(0,0,PaintBox1.Width-1,PaintBox1.Height-1)
  end
end;
//Menüpunkt : Wiederherstellen  - Neuzeichnen der PaintBox
procedure TForm1.Zwiederherstellen1Click(Sender: TObject);
begin
  Form1.PaintBox1.Refresh
end;
//Menüpunkt : Endgültig löschen - BS löschen und Liste löschen
procedure TForm1.Endgltiglschen1Click(Sender: TObject);
begin
  Zeichnunglschen1Click(Sender);
  prListe.Clear
end;

end.



und noch die

ausblenden volle Höhe Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
zeichenobjekte.pas

unit zeichenobjekte;

interface
uses Graphics;    //TCanvas,TColor
//Erweiterung : Nutzung von parametrisierten Konstruktoren
//            : Nutzung von Modifiern private/public
//            : Übergabe eines Parameters cvs:TCanvas (Fläche, auf die gezeichnet wird )
//              an zeichnen-Methode der Grafikobjekte, damit entfällt Bezug auf
//              unit zeichenflaeche  (uses zeichenflaeche)
type TGrafikObjekt = class
     private
       x1,y1:integer;sFarbe:TColor;    //Bezugspunkt,Zeichenfarbe des Objekts
     public
       constructor create(p1_x,p1_y:integer;f:TColor);
       procedure zeichnen(cvs:TCanvas);virtual;abstract;
       //Abstrakte Methode zeichnen wird von nachfolgenden Klassen überschrieben
       //cvs : Canvas - Fläche auf die gezeichnet wird, wird als Parameter übergeben
     end;
     TPunkt = class (TGrafikObjekt)
       procedure zeichnen(cvs:TCanvas);override;
     end;
     TLinie = class (TPunkt)                 //auch möglich class(TGrafikObjekt)
     private
       x2,y2:integer;                        //EndPunkt der Linie
       procedure verstecken(cvs:TCanvas);    //Linie löschen, wird nur von eigener
     public                                  //Methode ziehen verwendet-> private
       constructor create(p1_x,p1_y,p2_x,p2_y:integer;f:TColor);
       procedure zeichnen(cvs:TCanvas);override;
       procedure ziehen(x,y:integer;cvs:TCanvas);
     end;
     TRechteck = class(TLinie)
     private
       fFarbe:TColor;
       fuellung:boolean;
     public
       constructor create(p1_x,p1_y,p2_x,p2_y:integer;f1,f2:TColor;fill:boolean);
       procedure zeichnen(cvs:TCanvas);override;
     end;
     TKreis = class(TRechteck)
       radius:integer;
       constructor create(p1_x,p1_y,p2_x,p2_y:integer;f1,f2:TColor;fill:boolean);
       procedure zeichnen(cvs:TCanvas);override;
     end;

implementation

//Hinweis : inherited create - jeweils Aufruf des geerbten Konstruktors

constructor TGrafikObjekt.create(p1_x,p1_y:integer;f:TColor);
begin
  x1:=p1_x;y1:=p1_y;sFarbe:=f
end;
procedure TPunkt.zeichnen(cvs:TCanvas);
begin
  cvs.Pixels[x1,y1]:=sFarbe
end;

constructor TLinie.create(p1_x,p1_y,p2_x,p2_y:integer;f:TColor);
begin inherited create(p1_x,p1_y,f);
  x2:=p2_x;y2:=p2_y
end;
procedure TLinie.zeichnen(cvs:TCanvas);
begin
  with cvs do
    begin Pen.Color:=sFarbe;
      moveTo(x1,y1);lineTo(x2,y2)
    end
end;
procedure TLinie.ziehen(x,y:integer;cvs:TCanvas);
begin
  verstecken(cvs);          //bisherige Linie löschen, überzeichnen mit pmNotXor
  x2:=x;y2:=y;              //neuer Endpunkt der Linie
  zeichnen(cvs)             //Linie neu zeichnen
end;
//Die Methode ziehen wird an die Klassen TRechteck und TKreis vererbt,
//es wird jeweils die richtige Zeichenmethode aufgerufen, da zeichnen virtual definiert ist
procedure TLinie.verstecken(cvs:TCanvas);
begin
  with cvs do
    begin Pen.Mode:=pmNotXor;
      Pen.Style:=psDot
    end;
  zeichnen(cvs)
end;

constructor TRechteck.create(p1_x,p1_y,p2_x,p2_y:integer;f1,f2:TColor;fill:boolean);
begin inherited create(p1_x,p1_y,p2_x,p2_y,f1);
  fuellung:=fill;fFarbe:=f2
end;
procedure TRechteck.zeichnen(cvs:TCanvas);
begin
  with cvs do
    begin Pen.Color:=sFarbe;Brush.Color:=fFarbe;
      if fuellung then Brush.Style:=bsSolid
                  else Brush.Style:=bsClear;
      RectAngle(x1,y1,x2,y2)
    end
end;

constructor TKreis.create(p1_x,p1_y,p2_x,p2_y:integer;f1,f2:TColor;fill:boolean);
var dx,dy:integer;
begin inherited create(p1_x,p1_y,p2_x,p2_y,f1,f2,fill);
  dx:=x2-x1;dy:=y2-y1;radius:=round(sqrt(dx*dx+dy*dy));
end;
procedure TKreis.zeichnen(cvs:TCanvas);
var dx,dy:integer;
begin
  with cvs do
    begin Pen.Color:=sFarbe;Brush.Color:=fFarbe;
      if fuellung then Brush.Style:=bsSolid
                  else Brush.Style:=bsClear;
      dx:=x2-x1;dy:=y2-y1;radius:=round(sqrt(dx*dx+dy*dy));
      Ellipse(x1-radius,y1-radius,x1+radius,y1+radius)
    end
end;

end.


Moderiert von user profile iconGausi: Delphi-Tags hinzugefügt
ene
ontopic starontopic starontopic starontopic starontopic starofftopic starofftopic starofftopic star
Beiträge: 779
Erhaltene Danke: 1

Vista, XP, W2K
Delphi, .Net, Deutsch und Englisch
BeitragVerfasst: Fr 11.05.07 09:57 
Hi,

ganz ehrlich, ich hab mir deinen Code nicht angesehen, aber was du suchst nennt sich wohl FloodFill.

_________________
Wir, die guten Willens sind, geführt von Ahnungslosen, Versuchen für die Undankbaren das Unmögliche zu vollbringen.
Wir haben soviel mit so wenig so lange versucht, daß wir jetzt qualifiziert sind, fast alles mit Nichts zu bewerkstelligen.
Squall_Titus Threadstarter
Hält's aus hier
Beiträge: 13



BeitragVerfasst: Fr 01.06.07 09:14 
Ist ja klar.

Den Algorihmus hab ich aber an welcher Stelle binde ich ihn ein?
Außerdem muß ich ja noch die Primitives auf undefiniert zetzen, damit er nicht weiterzeichnet.
Habe dazu einen neuen Menupunkt Fuellmodus eingeführt.
Und nun?

Ich steh irgendwie auf dem Schlauch.
Squall_Titus Threadstarter
Hält's aus hier
Beiträge: 13



BeitragVerfasst: Fr 01.06.07 09:16 
Der Algorithmus heist ja allgemein:

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
procedure fill(x,y:integer; color1,color2:Tcolor);
var act_color:Tcolor;
begin
act_color:=getpixel(x,y);
if (act_color <>color1) and (act_color<>color2)then
begin
putpixel(x,y,color1);
fill(x+1,y ,color1,color2);
fill(x ,y+1,color1,color2);
fill(x-1,y ,color1,color2);
fill(x ,y-1,color1,color2);
end;
end;


Moderiert von user profile iconraziel: Delphi-Tags hinzugefügt
Matthias
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 121



BeitragVerfasst: Sa 02.06.07 20:22 
Hallo,

du musst im OnMouseDown Ereignis entscheiden, ob gezeichnet werden soll oder die Auswahl eines Objekts
möglich ist.

- Statte die Zeichenonjekte mit einer weiteren Methode aus, die prüft ob sich die Maus innerhalb
des Objekts befindet (Ähnlich wie bei Zeichnen die Liste durchgehen, prüfen und ändern).

- Setzte die Füllfarbe des gezeichneten Objekts und zeichne es neu.

Noch ein Tip:
Lege eine Menge von Zuständen fest, die die Maus haben kann.

z.B. Markieren, Zeichnen, Verschieben, Blockauswahl, GleichesSeitenverhältnis, ...

Matthias
Squall_Titus Threadstarter
Hält's aus hier
Beiträge: 13



BeitragVerfasst: Fr 08.06.07 10:21 
Jo Danke.


Bin jetzt schon ein bischen weiter.
Mein Problem ist jetzt das füllen von Bereichen mit unterschiedlicher Randfarbe.
Das Problem liegt an folgender Formel:

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
procedure TForm1.fill(x,y:integer; color1:Tcolor;Farbfeld:farbtyp; n:integer);
var act_color:Tcolor; l:boolean;  i:integer;
begin
   act_color:=paintbox1.canvas.pixels[x,y];
   l:=false;
   for i:=1 to n do
   if act_color <> Farbfeld[i] then
      l:=true;
   if (act_color <>color1) and l then
      begin
        paintbox1.canvas.pixels[x,y]:=color1;
        fill(x+1,y ,color1,Farbfeld,n);
        fill(x ,y+1,color1,Farbfeld,n);
        fill(x-1,y ,color1,Farbfeld,n);
        fill(x ,y-1,color1,Farbfeld,n);
      end;
end;



irgendwie will er nicht Testen, bis zu welcher Farbe er Füllen darf.

Ich habe mal alles als Zip angehängt (natürlich Virenfrei) vielleicht weiß jemand eine Antwort.

Wie gesagt Ziel ist das Füllen von geschlossenen bereichen.

Danke schon mal

PS: Außerdem möchte ich, dass das Programm nicht abbricht, wenn ich auf eine freie Fläche klicke. (Man müßte irgendwie eine Zeichenflächenbegrenzung mit angeben (aber dynamisch, da die Zeichenfläche skalierbar ist.)
Wenn dazu jemand noch ne Lösung hat bitte schreiben.

Moderiert von user profile iconraziel: Delphi-Tags hinzugefügt
Einloggen, um Attachments anzusehen!
Squall_Titus Threadstarter
Hält's aus hier
Beiträge: 13



BeitragVerfasst: Fr 08.06.07 10:59 
Hab gerade was bemerkt.

Bitte wer sich das Prog runtergeladen hat, wenn man das prog ausführt als erstes eine Stiftfarbe wählen.
Die ist zwar standardmäßig schwarz, aber der standard steht nicht im Farbfeld, sodass das Bereichsfüllen nicht funktioniert.

Also zuerst eine stiftfarbe wählen!
Squall_Titus Threadstarter
Hält's aus hier
Beiträge: 13



BeitragVerfasst: Fr 08.06.07 19:49 
habs gefunden statt:

act_color <> Farbfeld[i]

muß da stehen:

Farbfeld[i]=act_color

dann macht er es.
bleibt nur noch das Problem, dass er abbricht, wenn ich außerhalb eines Bereiches füllen will. Kann ich dem Programm sagen "Bis zur Grenze und nicht weiter!"?