• Name
• Übersicht
• Beschreibung
• Methodenaufrufe
  • Erzeugen und Sichern von Images
  • Kontrolle der Farben
  • Spezielle Farben
  • Zeichenbefehle
  • Befehle zum Kopieren von Images
  • Zeichnen von Zeichen und Strings
  • Verschiedene Image-Methoden
  • Polygon-Methoden
  • Font-Utilities
• Die C-Version von gd beschaffen
• Version
• Autor und Copyright
• Übersetzer

Name

Übersicht

use GD;
    
# Neues Image erzeugen.
$im = new GD::Image(100,100);

# Einige Farben bereitstellen.
$white = $im->colorAllocate(255,255,255);
$black = $im->colorAllocate(0,0,0);       
$red = $im->colorAllocate(255,0,0);      
$blue = $im->colorAllocate(0,0,255);

# Hintergrund wird transparent und "interlaced".
$im->transparent($white);
$im->interlaced('true');

# Einen schwarzen Rahmen um das Bild zeichnen.
$im->rectangle(0,0,99,99,$black);

# Blaues Oval zeichnen
$im->arc(50,50,95,75,0,360,$blue);

# und mit Rot füllen.
$im->fill(50,50,$red);

# Einen Binär-Stream sicherstellen.
binmode STDOUT;

# Image nach GIF umwandeln und über die Standardausgabe ausgeben.
print $im->gif;

Beschreibung

GD definiert die drei folgenden Klassen:

GD::Image

Eine Image-Klasse, die die grafischen Daten enthält und Aufrufe grafischer Primitiva erlaubt.

GD::Font

Eine Font-Klasse, die statische Informationen zu Fonts (Schriftarten) enthält und zur Textausgabe verwendet wird.

GD::Polygon

Ein einfaches Polygon-Objekt. Wird zur Speicherung von Vertex-Listen verwendet, bevor ein Polygon in ein Image übernommen wird.

#!/usr/local/bin/perl

use GD;

# Neues Image erzeugen.
$im = new GD::Image(100,100);

# Einige Farben bereitstellen.
$white = $im->colorAllocate(255,255,255);
$black = $im->colorAllocate(0,0,0);       
$red = $im->colorAllocate(255,0,0);      
$blue = $im->colorAllocate(0,0,255);

# Hintergrund wird transparent und "interlaced".
$im->transparent($white);
$im->interlaced('true');

# Einen schwarzen Rahmen um das Bild zeichnen.
$im->rectangle(0,0,99,99,$black);

# Blaues Oval zeichnen
$im->arc(50,50,95,75,0,360,$blue);

# und mit Rot füllen.
$im->fill(50,50,$red);

# Einen Binär-Stream sicherstellen.
binmode STDOUT;

# Image nach GIF umwandeln und über die Standardausgabe ausgeben.
print $im->gif;

Anmerkungen:

1. Um ein neues, leeres Image zu erzeugen, senden Sie eine new()-Nachricht an GD::Image. Dabei übergeben Sie die Breite und Höhe des gewünschten Images. Zurückgegeben wird ein Image-Objekt. Andere Klassenmethoden erlauben die Initialisierung eines Images aus einer vorhandenen GIF-, GD- oder XBM-Datei.
2. Als nächstes werden Sie üblicherweise Farben in die Farbtabelle des Images aufnehmen wollen. Farben werden über den Methodenaufruf colorAllocate() aufgenommen. Die drei bei jedem Aufruf übergebenen Parameter sind die Rot-, Grün- und Blau-Anteile (RGB) der gewünschten Farbe. Die Methode liefert den Index dieser Farbe in der Farbtabelle des Images zurück. Sie sollten diese Indizes zur späteren Verwendung speichern.
3. Nun können Sie etwas zeichnen! Die verschiedenen grafischen Primitiva werden nachfolgend beschrieben. Im obigen Beispiel haben wir etwas Text, ein Oval und ein Polygon erzeugt und gezeichnet.
4. Polygone werden erzeugt, indem man eine new()-Nachricht an GD::Polygon übergibt. Sie können das zurückgegebene Polygon mit der Methode addPt() um jeweils einen Punkt erweitern. Das Polygon kann dann zum Rendering an ein Image übergeben werden.
5. Wenn Sie mit dem Zeichnen fertig sind, können Sie das Image ins GIF-Format konvertieren, indem Sie ihm eine gif()-Nachricht schicken. Zurückgegeben wird ein (möglicherweise großer) Skalarwert, der die Binärdaten des Images enthält. An diesem Punkt werden Sie es ausgeben oder in einer Datei ablegen. Um die Portabilität mit den Plattformen zu gewährleisten, die zwischen Text- und Binärdateien unterscheiden, sollten Sie binmode() für die Datei aufrufen, in der Sie das Image abspeichern.

Methodenaufrufe

Erzeugen und Sichern von Images

new

GD::Image::new(width,height) Klassenmethode

Um ein neues, leeres Image zu erzeugen, senden Sie eine new()-Nachricht an die Klasse GD::Image. Ein Beispiel:

$myImage = new GD::Image(100,100) || die;

Dieser Aufruf erzeugt ein Image mit einer Größe von 100 x 100 Pixeln. Geben Sie keine Dimensionen an, wird ein Standardwert von 64 x 64 gewählt. Schlägt der Aufruf aus irgendeinem Grund fehl (z.B. aufgrund nicht ausreichenden Speicherplatzes), gibt er undef zurück.

newFromGif

GD::Image::newFromGif(FILEHANDLE) Klassenmethode

Erzeugt ein Image aus der GIF-Datei, die durch das Dateihandle angegeben wurde. Das Dateihandle muß vorher mit einer gültigen GIF-Datei oder Pipe geöffnet worden sein. Bei Erfolg gibt dieser Aufruf ein initialisiertes Image zurück, das dann nach Belieben verändert werden kann. Schlägt der Aufruf fehl - was üblicherweise der Fall ist, wenn das Dateihandle nicht auf eine gültige GIF-Datei verweist -, wird undef zurückgegeben. Beachten Sie, daß dieser Aufruf das Dateihandle nicht automatisch für Sie schließt. Allerdings wird binmode(FILEHANDLE) automatisch aufgerufen, wenn die Plattform das verlangt.

Um an Informationen über die Größe und Farbnutzung des Images zu gelangen, können Sie die nachfolgend erläuterten Image-Abfragemethoden (Query-Methoden) verwenden.

Beispielhafte Verwendung:

open (GIF,"barnswallow.gif") || die;
$myImage = newFromGif GD::Image(GIF) || die;
close GIF;

newFromXbm

GD::Image::newFromXbm(FILEHANDLE) Klassenmethode

Funktioniert auf genau die gleiche Weise wie newFromGif, liest aber den Inhalt einer X-Bitmap-Datei ein:

open (XBM,"coredump.xbm") || die;
$myImage = newFromXbm GD::Image(XBM) || die;
close XBM;

Beachten Sie, daß diese Funktion ebenfalls binmode(FILEHANDLE) aufruft, bevor aus dem Dateihandle gelesen wird.

newFromGd

GD::Image::newFromGd(FILEHANDLE) Klassenmethode

Funktioniert auf genau die gleiche Weise wie newFromGif, liest aber den Inhalt einer GD-Datei ein. GD ist Tom Boutells plattenbasiertes Speicherformat. Es ist für die seltenen Fälle gedacht, in denen Sie Images schnell von/auf Platte lesen/schreiben müssen. Es ist nicht zur regulären Nutzung gedacht, weil es im Gegensatz zu GIF oder JPEG keinerlei Komprimierung durchführt, d.h., die Dateien können sehr groß werden.

open (GDF,"godzilla.gd") || die;
$myImage = newFromGd GD::Image(GDF) || die;
close GDF;

Auch diese Methode ruft binmode(FILEHANDLE) auf, bevor Daten aus dem übergebenen Dateihandle eingelesen werden.

gif

GD::Image::gif Objektmethode

Liefert die Image-Daten im GIF-Format zurück. Diese können dann gedruckt, über eine Pipe an ein Ausgabeprogramm übergeben oder in einer Datei gespeichert werden. Beispiel:

$gif_data = $myImage->gif;
open (DISPLAY,"| display -") || die;
binmode DISPLAY;
print DISPLAY $gif_data;
close DISPLAY;

Beachten Sie die Verwendung von binmode(). Das ist für die Portabilität mit DOS-Plattformen von elementarer Bedeutung.

gd

GD::Image::gd Objektmethode

Liefert die Image-Daten im GD-Format zurück. Diese können dann gedruckt, über eine Pipe an ein Ausgabeprogramm übergeben oder in einer Datei gespeichert werden. Beispiel:

binmode MYOUTFILE;
print MYOUTFILE $myImage->gd;

Kontrolle der Farben

colorAllocate

GD::Image::colorAllocate(red,green,blue) Objektmethode

Alloziert eine Farbe mit den angegebenen Rot-, Grün- und Blau-Anteilen und gibt deren Index in der Farbtabelle zurück. Die erste auf diese Weise allozierte Farbe wird zur Hintergrundfarbe des Images. (255,255,255) steht für Weiß (alle Pixel an). (0,0,0) steht für Schwarz (alle Pixel aus). (255,0,0) ist ein sattes Rot. (127,127,127) steht für 50% Grau. Sie finden eine Vielzahl von Beispielen in /usr/X11/lib/X11/rgb.txt.

Werden keine Farben alloziert, gibt die Funktion -1 zurück.

Beispiel:

$white = $myImage->colorAllocate(0,0,0); # Hintergrundfarbe
$black = $myImage->colorAllocate(255,255,255);
$peachpuff = $myImage->colorAllocate(255,218,185);

colorDeallocate

GD::Image::colorDeallocate(colorIndex) Objektmethode

Markiert die Farbe mit dem angegebenen Index als freigegeben. Beim nächsten Aufruf von colorAllocate wird diese Farbe ersetzt. Sie können diese Methode wiederholt aufrufen, um mehrere Farben freizugeben. Dieser Funktionsaufruf gibt kein Ergebnis zurück.

Example:

$myImage->colorDeallocate($peachpuff);
$peachy = $myImage->colorAllocate(255,210,185);

colorClosest

GD::Image::colorClosest(red,green,blue) Objektmethode

Gibt den Index der Farbe zurück, deren Wert den übergebenen Rot-, Grün- und Blau-Komponenten am nächsten kommt. Wurden bislang keine Farben alloziert, wird -1 zurückgegeben.

Beispiel:

$apricot = $myImage->colorClosest(255,200,180);

colorExact

GD::Image::colorExact(red,green,blue) Objektmethode

Gibt den Index der Farbe zurück, deren Wert exakt den übergebenen Rot-, Grün- und Blau-Komponenten entspricht. Kommt eine solche Farbe in der Farbtabelle nicht vor, wird -1 zurückgegeben.

$rosey = $myImage->colorExact(255,100,80);
warn "Everything's coming up roses.\n" if $rosey >= 0;

colorsTotal

GD::Image::colorsTotal) Objektmethode

Gibt die Anzahl der für dieses Objekt insgesamt allozierten Farben zurück.

$maxColors = $myImage->colorsTotal;

getPixel

GD::Image::getPixel(x,y) Objektmethode

Liefert den Farbtabellen-Index zurück, der am angegebenen Punkt vorhanden ist. Kann zusammen mit rgb() verwendet werden, um die am angegebenen Pixel vorliegende RGB-Farbe zu bestimmen.

Beispiel:

$index = $myImage->getPixel(20,100);
($r,$g,$b) = $myImage->rgb($index);

rgb

GD::Image::rgb(colorIndex) Objektmethode

Gibt eine Liste mit den Rot-, Grün- und Blau-Komponenten des angegebenen Farbindex zurück.

Beispiel:

@RGB = $myImage->rgb($peachy);

transparent

GD::Image::transparent(colorIndex) Objektmethode

Markiert die Farbe mit dem angegebenen Index als transparent. Die Teile des Images, die in dieser Farbe gezeichnet werden, sind unsichtbar. Nützlich bei Mustern mit unregelmäßigen Formen und zur Erzeugung eines transparenten GIF-Hintergrunds für die Darstellung im Web. Nur eine Farbe kann jeweils transparent sein. Um die Transparenz zu deaktivieren, geben Sie -1 als Index an.

Rufen Sie diese Methode ohne Parameter auf, wird der Index der aktuellen transparenten Farbe zurückgegeben bzw. -1, falls es keine gibt.

Beispiel:

open(GIF,"test.gif");
$im = newFromGif GD::Image(GIF);
$white = $im->colorClosest(255,255,255); # Weiß finden.
$im->transparent($white);
binmode STDOUT;
print $im->gif;

Spezielle Farben

setBrush

gdBrushed

GD::Image::setBrush( ) und GD::gdBrushed

Sie können Linien und Formen (Shapes) mit einem sog. Brush-Pattern zeichnen. Brushes ("Pinsel") sind einfach Images, die Sie auf die übliche Art und Weise erzeugen und bearbeiten können. Wenn Sie mit ihnen zeichnen, wird ihr Inhalt für die Farbe und die Form der Linien verwendet.

Um eine gemusterte Linie zu zeichnen, müssen Sie zuerst eine Brush erzeugen oder laden und ihr dann mit setBrush ein Image zuweisen. Das Zeichnen mit diesem Muster wird dann über die spezielle Farbe gdBrushed festgelegt. Es ist häufig nützlich, den Hintergrund der Brush transparent zu halten, damit die nicht-farbigen Teile die anderen Teile Ihres Images nicht überschreiben.

Beispiel:

# Brush mit diagonalem Muster
$diagonal_brush = new GD::Image(5,5);
$white = $diagonal_brush->allocateColor(255,255,255);
$black = $diagonal_brush->allocateColor(0,0,0);
$diagonal_brush->transparent($white);
$diagonal_brush->line(0,4,4,0,$black); # Diagonal von Nord nach Ost

# Brush setzen.
$myImage->setBrush($diagonal_brush);

# Einen Kreis mit der Brush zeichnen.
$myImage->arc(50,50,25,25,0,360,gdBrushed);

setStyle

gdStyled

GD::Image::setStyle(@colors) und GD::gdStyled

"Gestylte" Linien bestehen aus einer willkürlichen Reihe sich wiederholender Farben und eignen sich zur Generierung gepunkteter und gestrichelter Linien. Um eine solche Linie zu erzeugen, nutzen Sie setStyle zur Angabe einer sich wiederholenden Reihe von Farben. Akzeptiert wird ein Array mit einem oder mehreren Farbindizes. Zum Zeichnen verwenden Sie die spezielle Farbe gdStyled. Eine weitere Spezialfarbe, gdTransparent, kann (wie im Beispiel gezeigt) verwendet werden, um "Löcher" in die Zeile einzubinden.

Beispiel:

# Definiert einen Stil mit je 4 Pixeln Gelb,
# 4 Pixeln Blau und einer Lücke von zwei Pixeln.
$myImage->setStyle($yellow,$yellow,$yellow,$yellow,
                   $blue,$blue,$blue,$blue,
                   gdTransparent,gdTransparent);
$myImage->arc(50,50,25,25,0,360,gdStyled);

Um das Verhalten von gdStyled und gdBrushed zu kombinieren, können Sie gdStyledBrushed angeben. In diesem Fall wird ein Pixel aus dem aktuellen Brush-Muster immer dann verwendet, wenn die in setStyle() definierte Farbe weder gdTransparent noch 0 ist.

gdTiled

Zeichnen gefüllter Umrisse und Flood-Fills mit Hilfe eines Musters. Das Muster ist einfach ein weiteres Image. Das Muster wird wiederholt ausgegeben ("gekachelt"), um den benötigten Platz zu füllen, womit ein "Tapeteneffekt" erzielt wird. Sie müssen setTile aufrufen, um das jeweilige Füllmuster zu definieren, das Sie zum Zeichnen verwenden wollen, während Sie die gdTiled-Farbdetails festlegen.

gdStyled

Die Farbe gdStyled wird zur Erzeugung gestrichelter und gepunkteter Linien verwendet. Eine solche Linie besteht aus einer Reihe von Farben und wird mit dem Befehl setStyled erzeugt.

Zeichenbefehle

setPixel

GD::Image::setPixel(x,y,color) Objektmethode

Setzt das Pixel an (x,y) auf den angegebenen Farbindex. Von dieser Methode wird kein Wert zurückgeliefert. Das Koordinatensystem beginnt in der oberen linken Ecke mit (0,0) und wird nach unten und nach rechts größer. Sie können eine reale Farbe oder eine der Spezialfarben gdBrushed, gdStyled und gdStyledBrushed angeben.

Beispiel:

# $peach muß bereits alloziert sein.
$myImage->setPixel(50,50,$peach);

line

GD::Image::line(x1,y1,x2,y2,color) Objektmethode

Zeichnet eine Linie in der angegebenen Farbe von (x1,y1) nach (x2,y2). Sie können eine reale Farbe oder eine der Spezialfarben gdBrushed, gdStyled und gdStyledBrushed angeben.

Beispiel:

# Zeichne eine diagonale Linie mit dem momentan
# definierten Brush-Muster.
$myImage->line(0,0,150,150,gdBrushed);

dashedLine

GD::Image::dashedLine(x1,y1,x2,y2,color) Objektmethode

Zeichnet eine gestrichelte Linie in der angegebenen Farbe von (x1,y1) nach (x2,y2). Eine leistungsfähigere Möglichkeit zur Generierung willkürlich gestrichelter und gepunkteter Linien ist die Verwendung der nachfolgend beschriebenen setStyle()-Methode und das Zeichnen mit der Spezialfarbe gdStyled.

Beispiel:

$myImage->dashedLine(0,0,150,150,$blue);

rectangle

GD::Image::rectangle(x1,y1,x2,y2,color) Objektmethode

Zeichnet ein Rechteck in der angegebenen Farbe. (x1,y1) und (x2,y2) sind die linke obere sowie die rechte untere Ecke. Sowohl reale Farbindizes als auch die Spezialfarben gdBrushed, gdStyled und gdStyledBrushed sind erlaubt.

Beispiel:

$myImage->rectangle(10,10,100,100,$rose);

filledRectangle

GD::Image::filledRectangle(x1,y1,x2,y2,color) Objektmethode

Zeichnet ein Rechteck, das mit der angegebenen Farbe gefüllt wird. Sie können eine reale Farbe oder die spezielle Füllfarbe gdTiled verwenden, um das Polygon mit einem Muster zu füllen.

Beispiel:

# Füllmuster einlesen und setzen.
open(GIF,"happyface.gif") || die;
$tile = newFromGif GD::Image(GIF);
$myImage->setTile($tile); 

# Rechteck zeichnen und mit Muster füllen.
$myImage->filledRectangle(10,10,150,200,gdTiled);

polygon

GD::Image::polygon(polygon,color) Objektmethode

Zeichnet ein Polygon in der angegebenen Farbe. Das Polygon muß zuerst angelegt werden (siehe unten). Das Polygon muß aus mindestens drei Vertices bestehen. Wird das Polygon durch den letzten Vertex nicht geschlossen, schließt die Methode es für Sie. Sowohl reale Farbindizes als auch die Spezialfarben gdBrushed, gdStyled und gdStyledBrushed können angegeben werden.

Beispiel:

$poly = new GD::Polygon;
$poly->addPt(50,0);
$poly->addPt(99,99);
$poly->addPt(0,99);
$myImage->polygon($poly,$blue);

filledPolygon

GD::Image::filledPolygon(poly,color) Objektmethode

Zeichnet ein Polygon und füllt es mit der angegebenen Farbe. Sie können eine reale Farbe oder die spezielle Füllfarbe gdTiled verwenden, um das Polygon mit einem Muster zu füllen.

Beispiel:

# Polygon erzeugen.
$poly = new GD::Polygon;
$poly->addPt(50,0);
$poly->addPt(99,99);
$poly->addPt(0,99);

# Polygon zeichnen und mit Farbe füllen.
$myImage->filledPolygon($poly,$peachpuff);

arc

GD::Image::arc(cx,cy,width,height,start,end,color) Objektmethode

Zeichnet Bögen und Ellipsen. (cx,cy) ist dabei der Mittelpunkt des Bogens, und (width,height) legt die Breite bzw. Höhe fest. Die Teile der durch den Bogen abgedeckten Ellipse werden durch start und end kontrolliert, die beide Werte von 0 bis 360 Grad angeben. Null ist dabei die Spitze der Ellipse, und die Grade erhöhen sich im Uhrzeigersinn. Um eine komplette Ellipse auszugeben, verwenden Sie 0 als Start- und 360 als Endwinkel. Um einen Kreis zu zeichnen, verwenden Sie den gleichen Wert für die Höhe und die Breite.

Sie können eine normale Farbe oder die Spezialfarben gdBrushed, gdStyled oder gdStyledBrushed angeben.

Beispiel:

# Zeichne einen Halbkreis an 100,100.
$myImage->arc(100,100,50,50,0,180,$blue);

fill

GD::Image::fill(x,y,color) Objektmethode

Diese Methode füllt (Flood-Fill) Bereiche mit der angegebenen Farbe. Die Farbe breitet sich dabei beginnend bei Punkt (x,y) aus, bis sie durch ein Pixel in einer vom Ausgangs-Pixel verschiedenen Farbe gestoppt wird (entspricht dem "Farbeimer", den man in vielen Zeichenprogrammen findet). Sie können eine normale Farbe oder die Spezialfarbe gdTiled zum Flood-Fill mit Mustern verwenden.

Beispiel:

# Rechteck zeichnen und mit Blau ausfüllen.
$myImage->rectangle(10,10,100,100,$black);
$myImage->fill(50,50,$blue);

GD::Image::fillToBorder(x,y,bordercolor,color) Objektmethode

Wie fill auch füllt diese Methode, beginnend an Position (x, y), Bereiche mit der angegebenen Farbe (Flood-Fill). Allerdings endet das Füllen nicht, wenn eine Farbe entdeckt wird, die sich von der Farbe des Start-Pixels unterscheidet, vielmehr endet das Füllen nur, wenn ein Pixel mit der angegebenen Grenzfarbe (bordercolor-Parameter) entdeckt wird. Sie müssen einen normalen Farbindex für die Grenzfarbe angeben. Sie können aber die Spezialfarbe gdTiled zum Füllen verwenden.

Beispiel:

# Der gleiche Effekt wie im vorigen Beispiel
$myImage->rectangle(10,10,100,100,$black);
$myImage->fillToBorder(50,50,$black,$blue);

Befehle zum Kopieren von Images

Es ist wichtig zu wissen, daß beide Methoden versuchen, die Farbtabelle des Ziel-Images auszuschlachten, um sie mit den Farben abzustimmen, die aus der Quelle kopiert werden. Ist die Farbtabelle des Zieles bereits voll, versuchen die Routinen (mit variierenden Ergebnissen) die am ehesten passenden Farben zu finden.

copy

GD::Image::copy(sourceImage,dstX,dstY,srcX,srcY,width,height) Objektmethode

Das ist die einfachere der beiden Kopieroperationen. Sie kopiert den angegebenen Bereich aus dem Quell-Image in das Ziel-Image (das die Methode aufgerufen hat). (srcX,srcY) legt die obere linke Ecke des Rechtecks im Quell-Image fest, und (width,height) gibt die Breite und Höhe des zu kopierenden Bereichs vor. (dstX,dstY) legt fest, an welcher Stelle im Ziel-Image die Kopie abzulegen ist. Sie können das gleiche Image für Quelle und Ziel festlegen, allerdings dürfen sich die Quell- und Zielregionen nicht überlappen, weil sonst seltsame Dinge passieren.

Beispiel:

$myImage = new GD::Image(100,100);
... verschiedene Zeichenoperationen ...
$srcImage = new GD::Image(50,50);
... noch mehr Zeichenoperationen ...
# Kopiere einen 25x25 Pixel großen Bereich von $srcImage in
# ein Rechteck, das in $myImage bei (10,10) beginnt.
$myImage->copy($srcImage,10,10,0,0,25,25);

copyResized

GD::Image::copyResized(sourceImage,dstX,dstY,srcX,srcY,destW,destH,srcW,srcH) Objektmethode

Diese Methode ähnelt copy(), ermöglicht es Ihnen aber, verschiedene Größen für die Quell- und Zielrechtecke festzulegen. Die Quell- und Zielrechtecke werden unabhängig voneinander mit (srcW,srcH) und (destW,destH) festgelegt. copyResized() vergrößert oder verkleinert das Image entsprechend den Größenanforderungen.

Beispiel:

$myImage = new GD::Image(100,100);
... verschiedene Zeichenoperationen ...
$srcImage = new GD::Image(50,50);
... noch mehr Zeichenoperationen ...
# Kopiere einen 25x25 Pixel großen Bereich von $srcImage in
# ein größeres Rechteck, das in $myImage bei (10,10) beginnt.
$myImage->copyResized($srcImage,10,10,0,0,50,50,25,25);

Zeichnen von Zeichen und Strings

string

GD::Image::string(font,x,y,string,color) Objektmethode

Diese Methode zeichnet einen String beginnend bei Position (x,y) in der festgelegten Schrift und Farbe. Die für Fonts erlaubten Werte sind gdSmallFont, gdMediumBoldFont, gdTinyFont, gdLargeFont und gdGiantFont.

Beispiel:

$myImage->string(gdSmallFont,2,10,"Peachy Keen",$peach);

stringUp

GD::Image::stringUp(font,x,y,string,color) Objektmethode

Genau wie der vorige Aufruf, gibt den Text aber um 90 Grad im Uhrzeigersinn gedreht aus.

char

charUp

GD::Image::char(font,x,y,char,color) Objektmethode GD::Image::charUp(font,x,y,char,color) Objektmethode

Diese Methoden zeichnen einzelne Zeichen in der angegebenen Schriftart und Farbe an der Position (x,y). Sie wurden von der C-Schnittstelle übernommen, bei der zwischen Zeichen und Strings unterschieden wird. Perl ist für solche subtilen Unterscheidungen unempfänglich.

Verschiedene Image-Methoden

interlaced

GD::Image::interlaced( ) GD::Image::interlaced(1) Objektmethode

Diese Methode setzt die Interlaced-Einstellung des Images bzw. fragt diese ab. Interlacing ruft bei einigen Betrachtern einen coolen Jalousieneffekt hervor. Übergeben Sie einen wahr-Wert, um das Interlacing zu aktivieren. Deaktivieren Sie es mit undef. Rufen Sie die Methode ohne Parameter auf, um die aktuelle Einstellung zu ermitteln.

c

GD::Image::getBounds( ) Objektmethode

Diese Methode liefert eine aus zwei Elementen bestehende Liste zurück, die die Breite und Höhe des Images enthält. Sie können die Größe eines Images nach dessen Erzeugung zwar ablegen, aber nicht ändern.

Polygon-Methoden

c

GD::Polygon::new Klassenmethode

Lege ein leeres Polygon ohne Vertices an.

$poly = new GD::Polygon;

addPt

GD::Polygon::addPt(x,y) Objektmethode

Füge den Punkt (x,y) zum Polygon hinzu.

$poly->addPt(0,0);
$poly->addPt(0,50);
$poly->addPt(25,25);
$myImage->fillPoly($poly,$blue);

getPt

GD::Polygon::getPt(index) Objektmethode

Ermittle den Punkt am angegebenen Vertex.

($x,$y) = $poly->getPt(2);

setPt

GD::Polygon::setPt(index,x,y) Objektmethode

Ändere den Wert eines bereits existierenden Vertex. Das Setzen eines noch nicht definierten Vertex ist ein Fehler.

$poly->setPt(2,100,100);

deletePt

GD::Polygon:deletePt(index) Objektmethode

Lösche den angegebenen Vertex und gib seinen Wert zurück.

($x,$y) = $poly->deletePt(1); 

toPt

GD::Polygon::toPt(dx,dy) Objektmethode

Zeichne vom aktuellen Vertex zu einem neuen Vertex, wobei die relativen Koordinaten (dx,dy) verwendet werden. Falls dies der erste Punkt ist, entspricht das Verhalten addPt().

$poly->addPt(0,0);
$poly->toPt(0,50);
$poly->toPt(25,-25);
$myImage->fillPoly($poly,$blue);

length

GD::Polygon::length Objektmethode

Gib die Anzahl der Vertices im Polygon zurück.

$points = $poly->length;

vertices

GD::Polygon::vertices Objektmethode

Gib eine Liste aller Vertices im Polygon-Objekt zurück. Jedes Mitglied der Liste ist eine Referenz auf ein (x,y)-Array.

@vertices = $poly->vertices;
foreach $v (@vertices)
   print join(",",@$v),"\n";
}

bounds

GD::Polygon::bounds Objektmethode

Liefere das kleinste Rechteck zurück, das das Polygon vollständig umschließt. Der Rückgabewert ist ein Array, das die linken, oberen, rechten und unteren Punkte des Rechtecks enthält.

($left,$top,$right,$bottom) = $poly->bounds;

offset

GD::Polygon::offset(dx,dy) Objektmethode

Verschiebe alle Vertices des Polygons um den angegebenen horizontalen (dh) und vertikalen (dy) Anteil. Positive Zahlen bewegen das Polygon nach unten und nach rechts.

$poly->offset(10,30);

map

GD::Polygon::map(srcL,srcT,srcR,srcB,destL,dstT,dstR,dstB) Objektmethode

Bilde das Polygon aus einem Quellrechteck in eine gleichwertige Position in einem Zielrechteck ab, wobei es nach Bedarf verschoben und in der Größe angepaßt wird. Ein Beispiel für die Funktionsweise finden Sie in polys.pl. Die Koordinaten der Quell- und Zielrechtecke werden in der Form (links, oben, rechts, unten) übergeben. Der Bequemlichkeit halber können Sie die polygoneigene Bounding-Box als Quellrechteck verwenden.

# Macht das Polygon sehr groß.
$poly->map($poly->bounds,0,0,50,200);

scale

GD::Polygon::scale(sx,sy) Objektmethode

Skaliere jedes Vertex des Polygons um die Faktoren sx und sy. Beispielsweise macht scale(2,2) das Polygon doppelt so groß. Um die besten Ergebnisse zu erzielen, verschieben Sie das Zentrum des Polygons an die Position (0,0), bevor Sie die Skalierung durchführen, und verschieben Sie es dann wieder an die vorherige Position.

transform

GD::Polygon::transform(sx,rx,sy,ry,tx,ty) Objektmethode

Lasse jedes Vertex des Polygons durch eine Transformationsmatrix laufen. Dabei sind sx und sy die X- und Y-Skalierungsfaktoren, rx und ry sind die X- und Y-Rotationsfaktoren, und tx und ty sind die X- und Y-Offsets. Eine vollständige Erläuterung finden Sie auf Seite 154 der Adobe-PostScript-Referenz (oder experimentieren Sie einfach).

Font-Utilities

Diese Distribution wird mit Jan Pazdzioras bdftogd-Programm geliefert, einem nicht unterstützten Utility, das Sie bei der Umwandlung von BDF-Fonts in das GD-Format unterstützt.

gdSmallFont

GD::Font::Small Konstante

Die grundlegende kleine Schrift, von einem wohlbekannten 6x12-PD-Font "geliehen".

gdLargeFont

GD::Font::Large Konstante

Die grundlegende große Schrift, von einem wohlbekannten 8x16-PD-Font "geliehen".

gdMediumBoldFont

GD::Font::MediumBold Konstante

Eine fette Schrift, deren Größe zwischen der kleinen und der großen Schrift liegt. Von einem 7x13-PD-Font geliehen.

gdTinyFont

GD::Font::Tiny Konstante

Eine sehr kleine, fast unleserliche Schrift. 5x8 Pixel groß.

gdGiantFont

GD::Font::Giant Konstante

Eine fette 9x15-Schrift, von Jan Pazdziora aus einer X11-Sans-Serif-Schrift konvertiert.

nchars

GD::Font::nchars Objektmethode

Gibt die Anzahl der in der Schrift enthaltenen Zeichen zurück.

print "Die große Schrift enthält ",gdLargeFont->nchars," Zeichen\n";

offset

GD::Font::offset Objektmethode

Liefert den ASCII-Wert des ersten Zeichens des Fonts zurück.

width

height

GD::Font::width GD::Font::height Objektmethode

Diese Methoden geben die Breite (width) und die Höhe (height) der Schrift zurück.

($w,$h) = (gdLargeFont->width,gdLargeFont->height);

Die C-Version von gd beschaffen

Version

Autor und Copyright

http://www.boutell.com/gd/gd.html

Die neuesten Versionen von GD.pm finden Sie auf:

http://www.genome.wi.mit.edu/ftp/pub/software/WWW/GD.html
ftp://ftp-genome.wi.mit.edu/pub/software/WWW/GD.pm.tar.gz

Übersetzer