std.image — Bildverarbeitung

Das std.image-Paket stellt eine einheitliche API zum Laden und Verarbeiten von Rasterbildern bereit. Alle Formate werden auf ein gemeinsames internes Format normalisiert: RGBA, 4 Kanäle, 8 Bit pro Kanal, zeilenweise top-down.

→ Units-Übersicht · Lyx-Sprache

Für die meisten Anwendungsfälle genügt der Import von std.image.image:

import std.image.image;
import std.alloc;
import std.io;

fn main(): int64 {
    var img: int64 := GrfImageAlloc(0, 0);   // nur Struct, noch keine Pixel
    var ok: int64 := ImageDecode("foto.jpg"c as int64, 0, img);
    if (ok == 0) { PrintLn("Fehler beim Laden"); return 1; }

    var w: int64 := ImageGetWidth(img);
    var h: int64 := ImageGetHeight(img);
    PrintLn("Breite: " + IntToStr(w) + "  Höhe: " + IntToStr(h));

    // Pixel an (100, 50) lesen — Format: 0xRRGGBBAA
    var px: int64 := ImagePixelAt(img, 100, 50);
    PrintLn("Rot: " + IntToStr((px >> 24) & 255));

    ImageFree(img);
    return 0;
}

GrfImage ist ein 56-Byte-Kontroll-Struct im Heap. Alle Felder sind int64 (8 Bytes):

Das Pixel-Format ist RGBA row-major top-down: Byte 0 = R, Byte 1 = G, Byte 2 = B, Byte 3 = A.
Als gepackter int64: 0xRRGGBBAA.

GrfDetectFormat() erkennt das Format anhand der Magic-Bytes am Anfang des Puffers:

// Aus Speicher-Puffer laden (Format wird automatisch erkannt)
// img muss vorher mit GrfImageAlloc alloziert werden.
// Gibt 1 bei Erfolg zurück, 0 bei Fehler.
var ok: int64 := ImageDecodeFromMem(buf, len, img);

// Aus Datei laden (liest Datei intern, ruft ImageDecodeFromMem auf)
// plen: Zeiger auf int64, erhält Dateigröße; oder 0 wenn nicht benötigt.
var ok: int64 := ImageDecode(path, plen, img);

ImageFree(img);    // gibt Pixel-Buffer + Struct frei

var w:  int64 := ImageGetWidth(img);       // Breite in Pixeln
var h:  int64 := ImageGetHeight(img);      // Höhe in Pixeln
var ch: int64 := ImageGetChannels(img);    // immer 4

// Pixel-Wert als 0xRRGGBBAA
var px: int64 := ImagePixelAt(img, x, y);
var r:  int64 := (px >> 24) & 255;
var g:  int64 := (px >> 16) & 255;
var b:  int64 := (px >>  8) & 255;
var a:  int64 :=  px        & 255;

Für direkten Zugriff auf das Struct oder wenn ein Bild programmatisch erzeugt werden soll:

// Alloziert GrfImage-Struct + RGBA-Pixel-Buffer (w*h*4 Bytes).
// Gibt 0 bei ungültigen Dimensionen oder OOM zurück.
var img: int64 := GrfImageAlloc(w, h);

// Freigabe
GrfImageFree(img);

// Lesen: gibt 0xRRGGBBAA zurück
var px: int64 := GrfImageGetPixel(img, x, y);

// Schreiben: rgba = 0xRRGGBBAA
GrfImageSetPixel(img, x, y, rgba);

// Alle Pixel mit einer Farbe füllen
GrfImageClear(img, 0xFF0000FF);   // vollständig rot, volle Deckkraft

// Mindestens 4 Bytes (WebP/AVIF brauchen 12).
// Gibt GRF_FMT_* zurück.
var fmt: int64 := GrfDetectFormat(buf, len);
if (fmt == GRF_FMT_PNG) {
    PngDecode(buf, len, img);
}

Alle Decoder haben dieselbe Signatur:

// buf: Pointer auf Bildaten im Speicher
// len: Länge des Puffers in Bytes
// img: vorher alloziertes GrfImage (GrfImageAlloc oder leer via alloc(GRF_SIZE))
// Rückgabe: 1 = Erfolg, 0 = Fehler
fn XxxDecode(buf: int64, len: int64, img: int64): int64;

std.image.image importiert alle Format-Units automatisch; wer nur einen bestimmten Decoder benötigt, kann die jeweilige Unit direkt importieren.

Letzte Aktualisierung: 2026-06-15