Mit der Funktion/Prozedur "Pixels"(oder Eigenschaft
) vom TCanvas kannst du dir entweder die Farbe eines Pixels im Canvas als TColor zurückgeben lassen, oder du veränderst die Farbe des Pixels mit derselben Prozedur.
Aufbau bei Pixelfarbe auslesen:
Farbe:=Canvas
.Pixels
[5,5];
Farbe:Variable vom Typ TColor in der die Farbe des angegebenen Pixels gespeichert wird
[5,5]: der erste grüne Wert gibt die Position des Pixels auf der X-Achse an, der zweite die Position auf der Y-Achse. Dabei ist ganz oben links die Koordinate [0,0], also:
Code:
--Y
X 0 1 2 3 4 5 ...
1 o o o o o ...
2 o o o o o ...
3 o o o o o ...
4 o o o o o ...
5 o o o o o ...
.
.
.
("o" stellt einfach einen Pixel dar)
Aufbau bei Pixelfarbe setzen:
Canvas
.Pixels
[5,5]:=Farbe;
Farbe: Nun wird Farbe als Variable benutzt, die die Farbe repräsentiert die letztendlich auf den Pixel gezeichnet wird.
[5,5]: Ist wieder die Koordinatenangabe des Pixels, [b]aber[/] nun wird auf ihn mit der angegebenen Farbe gemalt und
nicht sein Farbwert ausgelesen.
Beispiel:
Delphi-Quellcode:
var
Farbe: TColor;
begin
Farbe:= Canvas.Pixels[2,2]; {Liest die Farbe des Pixels auf den Koordinaten X:2 Y:2 aus und schreibt sie in die Variable "Farbe".}
Canvas.Pixels[3,3]:= Farbe; {Färbt den Pixel auf den Koordinaten X:3 Y:3 in der Farbe der Variable "Farbe"}
end;
Um deine Zuhörer noch ein bisschen zu "beeindrucken" kannst du die Prozedur
BitBlt(stellt Windows bereit), vorstellen, die Teilbereiche/den ganzen Bereich aus einem Canvas/Bitmap in ein anderes Canvas/Bitmap kopiert.
Eine ähnliche Methode hat TCanvas schon. Das schon besagt Canvas.Draw zeichnet einfach ein Bitmap an die angegebenen X und Y Koordinaten vom Zielbild. BitBlt ist allerdings wesentlich flexibler und
imho auch schneller.
Canvas
.Draw
(5,5,Grafik
);
Die ersten beiden Werte sind die X und Y Koordinaten, wohin das Bild gezeichnet werden soll.
Die Zweite Variable "Grafik" vom Typ TGraphic ist das Bild, welches an die X und Y Koordinaten gezeichnet wird.
BitBlt
Zitat von
MSDN Library:
Code:
BOOL BitBlt(
HDC hdcDest, //
handle to destination
DC
int nXDest, // x-coord of destination upper-left corner
int nYDest, // y-coord of destination upper-left corner
int nWidth, // width of destination rectangle
int nHeight, // height of destination rectangle
HDC hdcSrc, //
handle to source
DC
int nXSrc, // x-coordinate of source upper-left corner
int nYSrc, // y-coordinate of source upper-left corner
DWORD dwRop // raster operation code
);
Diese Funktion ist zwar schneller, aber auch ungemütlicher
(aber dafür auch flexibler wie gesagt).
Ich weiß nicht, ob du dich mit Handles auskennst. Handles sind so etwas wie Adressen von "Objekten".
Und da TCanvas auch ein
Handle hat
, kann man diese Methode auch damit benutzen.
Erklärung
Code:
BOOL BitBlt(
HDC hdcDest, //
Handle des Zielcanvas (also das Canvas, wo er draufzeichnen soll)
int nXDest, // X-Koordinate, wohin er zeichnen soll (wieder von oben links aus gesehen)
int nYDest, // Y-Koordinate, wo er zeichnen soll
int nWidth, // Breite des zu zeichnenden Bildausschnittes
int nHeight, // Höhe des zu zeichnenden Bildausschnittes
HDC hdcSrc, //
Handle des Quellcanvas (also das Canvas, dessen Ausschnitt er auf das Zielcanvas zeichnen soll)
int nXSrc, // X-Koordinate vom zu zeichnenden Ausschnitt auf dem Quellcanvas
int nYSrc, // Y-Koordinate vom zu zeichnenden Ausschnitt auf dem Quellcanvas
DWORD dwRop //
imho die Art wie er die Farben beim Draufzeichnen mischt
);
Beispiel:
sagen wir mal wir hätten zwei Images.
Auf Image1 soll ein Ausschnitt von Image2 gezeichnet werden
Delphi-Quellcode:
begin
BitBlt(Image1.Canvas.Handle,2,2,100,100,Image2.Canvas.Handle,0,0,SrcCopy);
end;
Also:
- Er zeichnet auf Image1.Canvas
- Er zeichnet von Image2.Canvas
- Der Ort auf Image1, wo der Ausschnitt hinkommt ist X:2 Y:2
- Die Breite und die Höhe des Ausschnittes beträgt 100
- Der Ausschnitt ist auf Image2 von den Koordinaten X:0 Y:0 abgegriffen
So, das wars erstmal
Korrigiert mich, wenn ich was falsch gemacht habe.
[Edit] Warscheinlich kann man alleine mit der Methode BitBlt 15min. füllen
[/Edit]