Warum klassische Verpixelung schnell ermüdet
Seit den ersten Punktmatrix-Displays der 1970er gehört Verpixelung zu den prägendsten Symbolen digitaler Bildsprache. Auf modernen hochauflösenden Bildschirmen stößt stumpfes Herunterrechnen auf scharfe Quadrate aber schnell an ästhetische Grenzen:
- Starre 90°-Treppeneffekte: Ob Gesichtskontur oder Horizont – schräge Linien zerfallen in harte Stufen und verlieren ihren natürlichen Fluss.
- Zerrissene ruhige Verläufe: Ein offener Himmel oder weicher Nebel bröckelt in unruhige Einzelkacheln auseinander, statt gezielt grafisch zu wirken.
- Tote Rasterfugen: Gleichmäßige schwarze Linien zwischen jeder Zelle zerschneiden das Bild mechanisch in ein lebloses Mosaik.
In der generativen Kunst zeigte der taiwanesische Künstler William Liang (@william77.fun) eine spannende Übersetzung von Fotografie: reale Bilder programmatisch in eine organische, abgerundete Rechteckwelt zu verwandeln. Ruhige Himmel fließen zu terrassierten Höhenflächen zusammen, harte Ecken runden sich zu weichen Bögen, und glitzerndes Wasser kristallisiert zu Leiterbahnen und Lötpads.
Um diese Bildsprache ins Textur-Studio zu bringen, haben wir die Kapsel-Pixel-Engine entwickelt – komplett in reinem Canvas 2D ohne GPU-Shader und ohne schwere Vektor-Bibliotheken.
Abbildung 1: Die vierstufige Kapsel-Pixel-Pipeline in Yan – von adaptiven Helligkeitsstufen über Grid-SDF-Eckenabrundung und Doppel-Relief bis zu konzentrischen Mikro-Kernen.
Bildvergleich: Klassische Verpixelung vs. Kapsel-Pixel
Vor der Mathematik lohnt sich ein Blick auf den direkten Unterschied bei einer kontrastreichen Landschaft:
![]()
Abbildung 2: Ausschnitt im Vergleich – (01) Originalfoto; (02) klassische Verpixelung mit harten 90°-Treppen und unruhigen Kacheln im Verlauf; (03) Yans Kapsel-Pixel-Engine, in der ruhige Flächen zu gerundeten Formen verschmelzen und Silhouetten ein klares Doppel-Relief erhalten.
In Panel // 02: NAIVE CARTESIAN PIXEL (STAIRCASE) fällt sofort auf:
- Die runden Hüte und Silhouetten verlieren ihre Form: Starre 90°-Stufen zersägen organische Kurven.
- Himmel und Hang zerfallen in Kleinzeug: Weiche Verläufe werden in Hunderte beliebige Quadrate zerlegt.
Ganz anders Panel // 03: CAPSULE PIXEL (FILLETED SDF + RELIEF):
- Ruhige Flächen lösen innere Trennlinien auf und verbinden sich zu klaren topografischen Terrassen.
- Jede rechtwinklige Ecke – ob außen oder innen – wird exakt mit dem Radius
R ≈ 0,28 · cellSizeabgerundet. - Eine feine weiße Glanzlinie direkt neben der dunklen Fuge verleiht der Fläche ein fühlbares Relief wie bei geätzten Leiterplatten.
So funktionieren die vier Stufen im Detail:
Stufe 1: Adaptive Helligkeitsstufen & Flächenverschmelzung
Zuerst müssen überflüssige Innengrenzen in ruhigen Bildbereichen verschwinden.
Wir teilen den Canvas in ein Raster der Zellgröße cellSize (Standard 14 px, dynamisch an die Bildgröße angepasst). Pro Zelle berechnen wir den mittleren RGB-Wert und die wahrgenommene Helligkeit:
L = 0.299R + 0.587G + 0.114B
Diese Helligkeit wird in diskrete Tonstufen Q quantisiert (typischerweise 8 bis 16 Stufen, gesteuert über den Kontrast-Regler):
Q = round((L / 255) × Levels)
Teilen zwei benachbarte Zellen dieselbe Stufe Q, gehören sie topologisch zur selben zusammenhängenden Form – und die Trennlinie zwischen ihnen wird gelöscht:
// 1. Grid cell color averages and luminance quantization
const gridR = new Float32Array(gw * gh)
const gridG = new Float32Array(gw * gh)
const gridB = new Float32Array(gw * gh)
const gridQ = new Int32Array(gw * gh)
for (let gy = 0; gy < gh; gy++) {
const y0 = gy * cellSize, y1 = Math.min(h, y0 + cellSize)
for (let gx = 0; gx < gw; gx++) {
const x0 = gx * cellSize, x1 = Math.min(w, x0 + cellSize)
let rSum = 0, gSum = 0, bSum = 0, count = 0
for (let y = y0; y < y1; y++) {
const row = y * w * 4
for (let x = x0; x < x1; x++) {
const idx = row + x * 4
rSum += data[idx] ?? 0
gSum += data[idx + 1] ?? 0
bSum += data[idx + 2] ?? 0
count++
}
}
const gIdx = gy * gw + gx
const r = rSum / count, g = gSum / count, b = bSum / count
gridR[gIdx] = r; gridG[gIdx] = g; gridB[gIdx] = b
const lum = 0.299 * r + 0.587 * g + 0.114 * b
gridQ[gIdx] = Math.round((lum / 255) * levels)
}
}
So verschmelzen weite Himmel, Wasserflächen und tiefe Schatten zu ruhigen Ebenen, während echte Kontrastsprünge klare Stufen behalten.
Stufe 2: Grid Signed Distance Field & Eckenabrundung
Reines Verschmelzen hinterlässt noch scharfe 90°-Ecken. Das Erkennungszeichen von Kapsel-Pixel ist die Rundung jeder Ecke mit sauberen Kreisbögen.
Klassische CAD-Pipelines vektorisieren dafür erst Polygone und schneiden Bögen aus – viel zu langsam für interaktives Rendering. Kapsel-Pixel löst das mit einem lokalen Grid Signed Distance Field (Grid SDF) pro Pixel in konstanter O(1)-Zeit.
Für einen Pixel (x, y) in Zelle (g_x, g_y) mit lokalen Koordinaten (u, v) ∈ [0, cellSize-1]^2 prüfen wir die Tonstufen der 8 Nachbarn: diffT, diffB, diffL, diffR sowie diagonal diffTL, diffTR, diffBL, diffBR.
1. Gerade Kante
Unterscheidet sich ein direkter Nachbar (z. B. oben, diffT == true), beträgt der Abstand zu dieser Kante schlicht u.
2. Konvexe Außenrundung
Treffen zwei orthogonale Grenzen aufeinander (z. B. oben und links, diffT && diffL), rundet im Eckquadranten (u < R und v < R) ein Kreisbogen mit Radius R = 0.28 · cellSize die Ecke ab:
d = R - sqrt((R - u)^2 + (R - v)^2)
3. Konkave Innenrundung
Gehören oberer und linker Nachbar zur selben Fläche (!diffT && !diffL), während der diagonale Nachbar oben links abweicht (diffTL == true), entsteht eine Innenecke mit Bogenzentrum in (0, 0):
d = min(d, sqrt(u^2 + v^2))
const R = cellSize * 0.28
let d = cellSize * 2 // Initialize to a large value
// Straight edge distance
if (diffT && u < d) d = u
if (diffB && (cellSize - 1 - u) < d) d = cellSize - 1 - u
if (diffL && v < d) d = v
if (diffR && (cellSize - 1 - v) < d) d = cellSize - 1 - v
// Convex filleting
if (diffT && diffL && u < R && v < R) d = R - Math.hypot(R - u, R - v)
if (diffT && diffR && u < R && (cellSize - 1 - v) < R) d = R - Math.hypot(R - u, R - (cellSize - 1 - v))
if (diffB && diffL && (cellSize - 1 - u) < R && v < R) d = R - Math.hypot(R - (cellSize - 1 - u), R - v)
if (diffB && diffR && (cellSize - 1 - u) < R && (cellSize - 1 - v) < R) d = R - Math.hypot(R - (cellSize - 1 - u), R - (cellSize - 1 - v))
// Concave filleting
if (!diffT && !diffL && diffTL) d = Math.min(d, Math.hypot(u, v))
if (!diffT && !diffR && diffTR) d = Math.min(d, Math.hypot(u, cellSize - 1 - v))
if (!diffB && !diffL && diffBL) d = Math.min(d, Math.hypot(cellSize - 1 - u, v))
if (!diffB && !diffR && diffBR) d = Math.min(d, Math.hypot(cellSize - 1 - u, cellSize - 1 - v))
Diese geschlossene Formel liefert weiche Kapsel-Konturen ohne Iteration und ohne Polygon-Clipping.
Stufe 3: Doppeltes Kontur-Relief
Bei physischen Gravuren oder geätzten Platinen ist eine Kante nie eine flache Linie – sie hat ein Profil.
Kapsel-Pixel bildet den Verlauf eines Laplacian-of-Gaussian (LoG)-Filters nach, indem es zwei Profile über den Randabstand d kombiniert:
- Äußere dunkle Fuge: Direkt an der Grenze (
d < 1.15 · kSize) wird die Grundfarbe um bis zu 85 % abgedunkelt – wie eine gefräste Nut. - Inneres weißes Glanzlicht: Etwa
1.3bis1.8Pixel weiter innen (d ≈ strokeW) legt eine Gauß-Kurve eine feine weiße Lichtkante auf. - Kontrastabhängige Stärke: Die Deckkraft skaliert mit dem Farbabstand
\ΔCzwischen Nachbarzellen. Harte Silhouetten bekommen knackige Konturen, sanfte Innenstufen bleiben dezent.
const kSize = cellSize / 14
const contrastK = Math.max(0.18, Math.min(1.0, (edgeDelta / 75.0) * contrastBoost))
// 1. Outer dark seam
const seamW = Math.max(0.75, 1.15 * kSize)
const seamAlpha = Math.max(0, Math.min(1, seamW - d)) * 0.85 * contrastK
r *= (1 - seamAlpha); g *= (1 - seamAlpha); b *= (1 - seamAlpha)
// 2. Inner white highlight stroke
const strokeW = Math.max(1.3, cellSize * 0.13)
const varStroke = Math.max(0.45, 0.75 * kSize * kSize)
const strokeAlpha = Math.exp(-Math.pow(d - strokeW, 2) / varStroke) * (0.28 + 0.68 * contrastK)
r = r * (1 - strokeAlpha) + 255 * strokeAlpha
g = g * (1 - strokeAlpha) + 255 * strokeAlpha
b = b * (1 - strokeAlpha) + 255 * strokeAlpha
Stufe 4: Konzentrische Ringe & Mikro-Kerne
In sehr detailreichen Zonen wie Wasseroberflächen oder Laub verschmelzen Zellen nicht, sondern bleiben als isolierte 1×1-Kacheln stehen. Als flache Farbblöcke würden sie stumpf wirken.
Zwei feine Binnenstrukturen erinnern hier an Mikrochips:
- Konzentrischer Innenring: Bei
d ≈ 0.28 · cellSizeerzeugt ein dunkler Ring eine eingelassene Kante. - Zentraler Mikro-Kern: Genau in der Zellmitte
((cellSize-1)/2, (cellSize-1)/2)sitzt ein feiner Gauß-Punkt – leuchtend weiß bei isolierten Kacheln, dezent dunkel in verschmolzenen Flächen, sodass das zugrunde liegende Raster subtil spürbar bleibt.
// Concentric inset ring
const ringW = Math.max(2.8, cellSize * 0.28)
const varRing = Math.max(0.55, 0.8 * kSize * kSize)
const ringAlpha = Math.exp(-Math.pow(d - ringW, 2) / varRing) * 0.35 * contrastK
r *= (1 - ringAlpha); g *= (1 - ringAlpha); b *= (1 - ringAlpha)
// Center micro-core nucleus
const distCenter = Math.hypot(u - (cellSize - 1) / 2, v - (cellSize - 1) / 2)
const isIsolated = diffT && diffB && diffL && diffR
const microWeight = isIsolated ? 0.55 : 0.22
const coreR = Math.max(1.0, 1.8 * kSize)
const microAlpha = Math.exp(-Math.pow(distCenter, 2) / (coreR * coreR)) * microWeight * contrastK
r = r * (1 - microAlpha) + (isIsolated ? 255 : 0) * microAlpha
g = g * (1 - microAlpha) + (isIsolated ? 255 : 0) * microAlpha
b = b * (1 - microAlpha) + (isIsolated ? 255 : 0) * microAlpha
Vergleich: Diskrete geometrische Rasterverfahren
| Merkmal | Klassische Pixel-Art | Voronoi-Mosaik | Halbtonraster | Kapsel-Pixel-Engine |
|---|---|---|---|---|
| Raumaufteilung | Starres Schachbrett | Unregelmäßige Delaunay-Zellen | Gedrehtes CMYK-Punktraster | Adaptive orthogonale Polyominos |
| Eckengeometrie | Scharfe 90°-Stufen | Beliebige Polygon-Ecken | Runde/elliptische Punkte | Konvexe & konkave SDF-Bögen (R=0.28s) |
| Tonwerte | Lokaler Farb-Mittelwert | Flache Zellfüllung | Punktflächen-Modulation | Adaptive Tonstufen ohne Innennähte |
| Relief-Profil | Keins oder flache 1px-Linie | Fuge zwischen Facetten | Keins | Doppel-Relief (dunkle Fuge + weißer Glanz) |
| Mikrostruktur | Flaches Quadrat | Flache Facette | Einzelner Farbpunkt | Innenring + Mikro-Kern |
| Rechenaufwand | Interpolation (<5ms) | O(N log N) Triangulation | Ein-Pass-Kosinusraster (~20ms) | Lokale SDF-Abfrage (O(1), ~38ms) |
Direkt ausprobieren
Kapsel-Pixel wartet im Textur-Studio auf deine eigenen Fotos:
- Mit Detail wechselst du zwischen groben Retro-Kacheln und feinen Mikrochip-Bahnen.
- Mit Kontrast steuerst du, wie eng die Helligkeitsstufen in Verläufen gezogen werden.
- Mit Stärke mischst du das Relief sauber über dein Originalfoto.
Das Browser-Tool läuft zu 100 % lokal ohne Upload, ohne Konto und ohne Wasserzeichen (PNG bis 1400 px). In der Yan-App für iOS und Android sorgt die optimierte Engine sogar für flüssige 60-FPS-Vorschau in der Live-Kamera.