Dynamische Bilder gehören in vielen Web-Projekten zum Alltag, vom Captcha über Open-Graph-Vorschaubilder bis zum Wasserzeichen auf hochgeladenen Fotos. Die GD-Bibliothek bringt dafür alles mit, was PHP von Haus aus braucht. Dieser Leitfaden zeigt Schritt für Schritt, wie ein Bild im Code entsteht, geladen und manipuliert und schließlich als Datei oder direkter Browser-Stream ausgegeben wird.
Was leistet die GD-Bibliothek bei der PHP Bildbearbeitung?
Die PHP Bildbearbeitung mit der GD-Bibliothek ist der Standardweg, um Bilder direkt im Code zu erzeugen, zu manipulieren und auszugeben. Mit GD entsteht aus wenigen Funktionsaufrufen ein PNG, JPEG oder WEBP, das entweder als Datei gespeichert oder direkt an den Browser gestreamt wird. Typische Anwendungen sind Captchas, Open-Graph-Bilder, dynamische Diagramme oder das Anbringen von Markierungen auf hochgeladenen Fotos.
Bevor das erste Bild auf den Browser zurückgestreamt wird, lohnt ein kurzer Vergleich zwischen GD und Imagick als Alternativen für die Bildverarbeitung.
GD ist in den meisten PHP-Distributionen bereits enthalten und benötigt keine externe Bibliothek. Im Vergleich zu schwergewichtigen Tools wie ImageMagick ist GD schlanker und übersichtlicher, deckt die wichtigsten Aufgaben aber zuverlässig ab. Wer komplexe Filter, viele Formate oder höchste Bildqualität braucht, schaut sich Imagick als Alternative an, doch für 90 Prozent aller Web-Anwendungsfälle ist GD vollkommen ausreichend.
GD aktivieren und im System prüfen
Bevor die eigentliche PHP Bildbearbeitung loslegen kann, sollte der Server die GD-Extension geladen haben. Zwei kurze Prüfungen helfen, das schnell festzustellen.
<?php
if (!extension_loaded('gd')) {
die('GD-Extension ist nicht aktiv. Bitte in der php.ini einschalten.');
}
print_r(gd_info());
/* Liefert ein Array mit unterstuetzten Formaten und Versionsangaben */
In der Ausgabe von gd_info() zeigen Einträge wie JPEG Support, PNG Support oder WebP Support, welche Formate verfügbar sind. Falls GD fehlt, hilft auf Linux-Systemen meist apt install php-gd oder das Aktivieren der entsprechenden Erweiterung in der php.ini. Auf Shared Hosting ist GD fast immer vorinstalliert.
Ein neues Bild erzeugen und an den Browser senden
Der einfachste Einstieg in die PHP Bildbearbeitung ist ein leeres Bild mit Hintergrundfarbe und einer kurzen Textzeile. Die Direktausgabe spart einen Umweg über die Festplatte und eignet sich für dynamische Inhalte wie Captchas oder Sharing-Bilder.
<?php
$bild = imagecreatetruecolor(200, 80);
$hg = imagecolorallocate($bild, 245, 241, 232);
$farbe = imagecolorallocate($bild, 26, 35, 50);
imagefilledrectangle($bild, 0, 0, 199, 79, $hg);
imagestring($bild, 5, 30, 30, 'Hallo GD!', $farbe);
header('Content-Type: image/png');
imagepng($bild);
imagedestroy($bild);
Drei Punkte sind wichtig. Erstens: imagecreatetruecolor() liefert ein 24-Bit-Bild mit voller Farbtiefe, im Gegensatz zum palette-basierten imagecreate(). Zweitens: imagecolorallocate() reserviert Farben im Bild und gibt einen Identifier in eine Variable zurück, die dann an Zeichen-Funktionen übergeben wird. Drittens: Vor imagepng() darf kein einziges Zeichen ausgegeben worden sein, sonst scheitert der Content-Type-Header und der Browser kann das Bild nicht korrekt anzeigen. Mit der eingebauten Funktion header() lässt sich der HTTP-Header sauber setzen, bevor die Binärdaten über die Leitung gehen.
Bestehende Bilder laden und verändern
Hat der Server bereits ein Bild auf der Platte, etwa nach einem Datei-Upload mit move_uploaded_file(), kann GD es einlesen, manipulieren und neu speichern. Je nach Format wird eine andere Lade-Funktion gebraucht.
<?php
$quelle = __DIR__ . '/foto.jpg';
$ziel = __DIR__ . '/foto_marker.jpg';
$bild = imagecreatefromjpeg($quelle);
$rot = imagecolorallocate($bild, 255, 50, 50);
/* roter Rahmen um einen Bildausschnitt */
imagerectangle($bild, 30, 30, 180, 130, $rot);
imagejpeg($bild, $ziel, 90);
imagedestroy($bild);
echo 'Datei gespeichert: ' . $ziel;
imagejpeg() erwartet als zweiten Parameter den Dateipfad und als dritten optional die Qualitätsstufe von 0 bis 100. Wer das Bild hingegen direkt an den Browser ausgeben möchte, ruft imagejpeg($bild) ohne zweiten Parameter auf und setzt vorher header('Content-Type: image/jpeg'). Für PNG, GIF und WEBP gibt es analoge Funktionen wie imagepng(), imagegif() und imagewebp(), dazu passende Lade-Funktionen wie imagecreatefrompng() und imagecreatefromwebp().
Text mit imagestring und imagettftext schreiben
Für einfache Beschriftungen reicht imagestring() mit Schriftgrößen von 1 bis 5. Sobald aber eine Marke, ein Logo oder ein gut lesbares Open-Graph-Bild entstehen soll, führt der Weg über imagettftext() mit einer eigenen TTF-Schriftart. Wichtigste Stolperfalle: der Pfad zur Schriftart muss absolut sein, sonst sucht GD im aktuellen Working-Directory des Servers und scheitert lautlos.
<?php
$bild = imagecreatetruecolor(400, 100);
$hg = imagecolorallocate($bild, 245, 241, 232);
$txt = imagecolorallocate($bild, 26, 35, 50);
imagefilledrectangle($bild, 0, 0, 399, 99, $hg);
/* Pfad MUSS absolut sein, sonst sucht GD im Server-Cwd */
$schrift = __DIR__ . '/fonts/OpenSans-Regular.ttf';
imagettftext($bild, 24, 0, 30, 60, $txt, $schrift, 'PHP Bildbearbeitung');
header('Content-Type: image/png');
imagepng($bild);
imagedestroy($bild);
Die Parameter von imagettftext() sind in dieser Reihenfolge: Bild, Schriftgröße in Punkten, Drehwinkel in Grad, x-Koordinate, y-Koordinate, Farbe, Pfad zur Schriftart, Text. Beachten ist, dass die y-Koordinate die Schriftbasislinie meint, nicht den oberen Rand des Buchstabens. Ein Wert von 60 bei Schriftgröße 24 platziert den Text gut sichtbar im oberen Drittel der 100-Pixel-Fläche.
Formen, Farben und Koordinatensystem verstehen
Wer Linien, Rechtecke oder Kreise zeichnet, muss das Koordinatensystem von GD im Kopf haben. Der Punkt (0,0) liegt oben links, die x-Achse zeigt nach rechts und die y-Achse nach unten. Das ist anders als in der Mathematik-Vorlesung, aber identisch zu den meisten Grafik-APIs.
<?php
$bild = imagecreatetruecolor(300, 200);
$hg = imagecolorallocate($bild, 26, 35, 50);
$blau = imagecolorallocate($bild, 0, 132, 255);
$ora = imagecolorallocate($bild, 255, 107, 0);
imagefilledrectangle($bild, 0, 0, 299, 199, $hg);
imageline($bild, 10, 10, 290, 190, $blau);
imagefilledellipse($bild, 150, 100, 80, 80, $ora);
header('Content-Type: image/png');
imagepng($bild);
imagedestroy($bild);
Mit imageline(), imagerectangle(), imagefilledrectangle(), imageellipse() und imagefilledellipse() ist schon viel möglich. Wer mehrere Bilder kombinieren möchte, also bspw. ein Logo in ein Foto einfügen will, nutzt imagecopy() oder imagecopymerge() für halbtransparente Overlays. So entsteht aus Hintergrundbild, Logo und Titeltext im Handumdrehen ein Open-Graph-Bild für Social Media.
Bilder als Datei speichern oder streamen
Jede Ausgabe-Funktion mit GD kennt zwei Modi. Mit Dateipfad als zweitem Parameter wird das Bild gespeichert, ohne Pfad geht es direkt an den Browser. Der Unterschied entscheidet, ob ein Bild dauerhaft auf der Platte landet oder für jeden Aufruf neu generiert wird.
<?php
/* Variante A: speichern */
imagepng($bild, __DIR__ . '/cache/foto.png');
/* Variante B: streamen */
header('Content-Type: image/png');
imagepng($bild);
Beim Streamen darf vor dem Aufruf keine Ausgabe stehen, auch keine BOM-Bytes oder Whitespace außerhalb von PHP-Tags. Andernfalls wird der Header verschluckt und der Browser interpretiert die Binärdaten als HTML. Wer dynamische Bilder für häufig aufgerufene Endpunkte erzeugt, sollte die Ausgabe einmal in eine Cache-Datei speichern und beim nächsten Request direkt mit file_get_contents() ausliefern, statt das Bild bei jedem Request neu zu rendern.
Bevor es an konkrete Anwendungen wie Wasserzeichen und Captcha geht, fasst das folgende Diagramm den typischen GD-Ablauf zusammen, von der Bilderzeugung bis zur Ausgabe als Browser-Stream oder Datei.
flowchart TD
A[GD-Bild erzeugen oder laden] --> B[Farben mit imagecolorallocate definieren]
B --> C[Zeichnen / Text / Filter]
C --> D{Ausgabe?}
D -->|Browser| E[header + imagepng ohne Pfad]
D -->|Datei| F[imagepng mit Dateipfad]
E --> G[imagedestroy zur Speicherfreigabe]
F --> G
Wasserzeichen mit imagecopy auf ein Foto setzen
Ein klassischer Use-Case der PHP Bildbearbeitung ist das Anbringen eines Logos oder Copyright-Hinweises auf ein Foto. Mit imagecopy() wird das Logo über das Foto gelegt, mit imagecopymerge() zusätzlich halbtransparent gemischt. Für ein PNG-Logo mit echter Alpha-Transparenz ist imagecopy() die korrekte Wahl, weil imagecopymerge() den Alpha-Kanal nicht respektiert.
<?php
$foto = imagecreatefromjpeg(__DIR__ . '/foto.jpg');
$logo = imagecreatefrompng(__DIR__ . '/logo.png');
[$fotoBreite, $fotoHoehe] = [imagesx($foto), imagesy($foto)];
[$logoBreite, $logoHoehe] = [imagesx($logo), imagesy($logo)];
/* unten rechts mit 20 Pixel Abstand */
$posX = $fotoBreite - $logoBreite - 20;
$posY = $fotoHoehe - $logoHoehe - 20;
imagecopy($foto, $logo, $posX, $posY, 0, 0, $logoBreite, $logoHoehe);
imagejpeg($foto, __DIR__ . '/foto_wasserzeichen.jpg', 90);
imagedestroy($foto);
imagedestroy($logo);
Wer das Logo halbtransparent über das Foto legen will, ohne ein eigenes Alpha-PNG vorzubereiten, nutzt imagecopymerge() mit einem Mischwert von 0 bis 100. Bei einem reinen PNG-Wasserzeichen mit eingebauter Transparenz reicht aber imagecopy() völlig, weil PNG den Alpha-Kanal selbst mitbringt. Für das automatisierte Anbringen auf vielen Bildern in einem Verzeichnis kombiniert man dieses Pattern mit glob('*.jpg') und einer Schleife.
Captcha mit zufälligen Linien und verzerrtem Text
Ein weiterer typischer Anwendungsfall ist ein einfaches Captcha. Mit GD entsteht ein Bild mit einem zufälligen Code, einigen Störlinien und Punkten in einer Schleife.
<?php
session_start();
$breite = 160;
$hoehe = 60;
$code = strtoupper(bin2hex(random_bytes(3))); /* 6 Hex-Zeichen */
$_SESSION['captcha'] = $code;
$bild = imagecreatetruecolor($breite, $hoehe);
$hg = imagecolorallocate($bild, 245, 241, 232);
$txt = imagecolorallocate($bild, 26, 35, 50);
$grau = imagecolorallocate($bild, 180, 180, 180);
imagefilledrectangle($bild, 0, 0, $breite, $hoehe, $hg);
/* zehn Stoerlinien */
for ($i = 0; $i < 10; $i++) {
imageline($bild, random_int(0, $breite), random_int(0, $hoehe),
random_int(0, $breite), random_int(0, $hoehe), $grau);
}
/* Code zeichen-fuer-zeichen mit leichter Drehung */
$schrift = __DIR__ . '/fonts/OpenSans-Bold.ttf';
for ($i = 0; $i < strlen($code); $i++) {
$winkel = random_int(-15, 15);
imagettftext($bild, 22, $winkel, 15 + $i * 22, 42, $txt, $schrift, $code[$i]);
}
header('Content-Type: image/png');
imagepng($bild);
imagedestroy($bild);
Der erzeugte Code landet in der Session und wird beim Formular-Submit gegen die Eingabe verglichen. Für echten Bot-Schutz reicht ein simples Captcha heute oft nicht mehr, dort sind Lib-Lösungen wie hCaptcha oder Cloudflare Turnstile besser aufgestellt. Für kleine Kontakt-Formulare oder als Lern-Beispiel ist das Pattern aber ein gut nachvollziehbarer Einstieg in dynamische PHP Bildbearbeitung.
Filter und Effekte mit imagefilter
Wer Bilder in Graustufen umwandeln, weichzeichnen oder die Helligkeit anpassen will, ruft imagefilter() mit einer der IMG_FILTER_*-Konstanten auf. Die Funktion verändert das Bild in-place und ist damit speicherschonender als ein Filter-Pipe mit mehreren Zwischenbildern.
<?php
$bild = imagecreatefromjpeg(__DIR__ . '/foto.jpg');
imagefilter($bild, IMG_FILTER_GRAYSCALE); /* Schwarzweiss */
imagefilter($bild, IMG_FILTER_BRIGHTNESS, -20); /* dunkler */
imagefilter($bild, IMG_FILTER_CONTRAST, -10); /* mehr Kontrast (negativ = mehr) */
imagefilter($bild, IMG_FILTER_GAUSSIAN_BLUR); /* leichter Weichzeichner */
imagejpeg($bild, __DIR__ . '/foto_bearbeitet.jpg', 85);
imagedestroy($bild);
Die wichtigsten Filter sind GRAYSCALE, BRIGHTNESS, CONTRAST, GAUSSIAN_BLUR, NEGATE und PIXELATE. Die erlaubten Argumente unterscheiden sich pro Filter und sind in der PHP-Dokumentation aufgelistet. Für anspruchsvolle Bildverarbeitung mit professionellen Filtern, etwa Schärfen mit Unsharp-Mask, ist Imagick weiterhin die stärkere Wahl. Für typische Web-Aufgaben wie Schwarzweiss-Vorschauen oder schnelle Effekte ist imagefilter() aber völlig ausreichend.
Transparenz erhalten mit imagealphablending und imagesavealpha
Beim Erzeugen oder Bearbeiten von PNG-Bildern mit transparentem Hintergrund gibt es eine Stolperfalle: imagecreatetruecolor() initialisiert das Bild standardmäßig mit deckendem Schwarz, und imagepng() schreibt den Alpha-Kanal nur, wenn er ausdrücklich aktiviert wurde. Wer das vergisst, bekommt ein PNG mit schwarzem Hintergrund statt Transparenz.
<?php
$bild = imagecreatetruecolor(200, 100);
/* Pflicht-Setup fuer echtes Alpha-PNG */
imagealphablending($bild, false);
imagesavealpha($bild, true);
$transparent = imagecolorallocatealpha($bild, 0, 0, 0, 127);
imagefilledrectangle($bild, 0, 0, 200, 100, $transparent);
/* jetzt darf gezeichnet werden */
$blau = imagecolorallocate($bild, 0, 132, 255);
imagefilledellipse($bild, 100, 50, 120, 60, $blau);
header('Content-Type: image/png');
imagepng($bild);
imagedestroy($bild);
Der Alpha-Wert reicht in GD von 0 (deckend) bis 127 (vollständig transparent). Wer das Setup einmal in eine Helper-Funktion pngTransparent(int $w, int $h): GdImage auslädt, vermeidet, dass die drei Aufrufe an verschiedenen Stellen vergessen werden. Für GIF mit Transparenz ist statt Alpha-Channel die Funktion imagecolortransparent() zuständig, die eine einzelne Farbe als transparent markiert. Mehr zum Thema Transparenz beim Skalieren steht im Tutorial Bilder verkleinern und Thumbnails erzeugen.
Sicherheit, GD vs Imagick und Speicherverbrauch
Bei User-Uploads ist Vorsicht geboten. Der Wert in $_FILES['upload']['type'] ist vom Browser gemeldet und lässt sich fälschen. Verlässlich ist getimagesize() oder eine MIME-Prüfung mit finfo, weil beide den echten Dateiinhalt analysieren. Erst wenn der Typ feststeht, sollte imagecreatefromjpeg() oder imagecreatefrompng() aufgerufen werden.
<?php
$datei = $_FILES['upload']['tmp_name'] ?? '';
$info = getimagesize($datei);
if ($info === false) {
die('Keine gueltige Bilddatei.');
}
$bild = match ($info[2]) {
IMAGETYPE_JPEG => imagecreatefromjpeg($datei),
IMAGETYPE_PNG => imagecreatefrompng($datei),
IMAGETYPE_GIF => imagecreatefromgif($datei),
IMAGETYPE_WEBP => imagecreatefromwebp($datei),
default => null,
};
if ($bild === null) {
die('Format wird nicht unterstuetzt.');
}
Speicher ist ein zweiter Aspekt. Ein Bild von 4000 mal 3000 Pixeln verbraucht in imagecreatetruecolor() ungefähr 48 Megabyte, weil jedes Pixel vier Byte beansprucht. Auf Servern mit knappem memory_limit lohnt es sich, die Bildgröße vor dem Laden zu prüfen und bei Bedarf vorher zu skalieren. Seit PHP 8.0 sind GD-Ressourcen vollwertige GdImage-Objekte, die der Garbage Collector am Ende des Skripts aufräumt. In langen Skripten oder Worker-Prozessen bleibt imagedestroy() trotzdem die saubere Wahl, weil der Speicher sofort freigegeben wird.
Wer häufig komplexe Filter, viele Formate oder besseres Anti-Aliasing braucht, schaut sich Imagick als Alternative an. Imagick liefert höhere Bildqualität und unterstützt mehr Formate, ist aber nicht überall vorinstalliert. Für typische Web-Aufgaben wie Captchas, Thumbnails oder Marker auf Fotos ist GD die richtige Wahl, weil es überall läuft und keine Composer-Abhängigkeit benötigt.
Fazit
Die PHP Bildbearbeitung mit der GD-Bibliothek ist ein verlässliches Werkzeug, um Bilder im Code zu erzeugen, zu laden und zu manipulieren. Mit wenigen Funktionsaufrufen entstehen Captchas, Open-Graph-Bilder oder Marker-Overlays, ohne dass eine externe Library installiert werden muss. Wichtig sind die Pflicht-Reihenfolge "Bild, Farben, Zeichnen, Ausgabe", das absolute Pfad-Setting bei TTF-Schriften und der Content-Type-Header vor jedem Stream-Output. Wer diese Punkte im Hinterkopf behält und bei sensiblen User-Uploads den echten MIME-Typ prüft, kann mit GD professionelle dynamische Bilder bauen und nur für komplexe Fälle auf Imagick umsteigen.
