Kapsel-Pixel: Wie wir eine organische Manhattan-Raster-Engine gebaut haben

Eine generative Canvas-2D-Engine: adaptive orthogonale Flächen, SDF-Eckenabrundung, doppeltes Kontur-Relief und konzentrische Mikro-Kerne.

> Kurz gesagt

Klassische Verpixelung zerlegt Fotos in starre 90-Grad-Quadrate, zerstört schräge Konturen durch Treppeneffekte und reißt ruhige Verläufe auseinander. Kapsel-Pixel in Yans Textur-Studio denkt das Raster über vier gekoppelte Schritte neu: (1) adaptive Helligkeits-Tonstufen verschmelzen benachbarte Zellen zu zusammenhängenden Polyominos ohne innere Nähte; (2) ein lokales Grid Signed Distance Field (Grid SDF) rundet Außen- und Innenecken in konstanter O(1)-Zeit mit Kreisbögen (R ≈ 0,28 · cellSize) ab; (3) ein kontrastabhängiges Doppel-Relief aus dunkler Fuge und weißem Glanzlicht prägt die Kanten; und (4) konzentrische Ringe plus Mikro-Kerne beleben isolierte Zellen. Alles läuft rein auf der CPU in Canvas 2D in rund 38 ms bei 1080p.

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:

  1. Starre 90°-Treppeneffekte: Ob Gesichtskontur oder Horizont – schräge Linien zerfallen in harte Stufen und verlieren ihren natürlichen Fluss.
  2. Zerrissene ruhige Verläufe: Ein offener Himmel oder weicher Nebel bröckelt in unruhige Einzelkacheln auseinander, statt gezielt grafisch zu wirken.
  3. 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.

Kapsel-Pixel-Pipeline-Diagramm
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:

Bildvergleich: Original vs. klassische Verpixelung vs. Kapsel-Pixel
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 · cellSize abgerundet.
  • 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:

  1. Ä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.
  2. Inneres weißes Glanzlicht: Etwa 1.3 bis 1.8 Pixel weiter innen (d ≈ strokeW) legt eine Gauß-Kurve eine feine weiße Lichtkante auf.
  3. Kontrastabhängige Stärke: Die Deckkraft skaliert mit dem Farbabstand \ΔC zwischen 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 · cellSize erzeugt 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

MerkmalKlassische Pixel-ArtVoronoi-MosaikHalbtonrasterKapsel-Pixel-Engine
RaumaufteilungStarres SchachbrettUnregelmäßige Delaunay-ZellenGedrehtes CMYK-PunktrasterAdaptive orthogonale Polyominos
EckengeometrieScharfe 90°-StufenBeliebige Polygon-EckenRunde/elliptische PunkteKonvexe & konkave SDF-Bögen (R=0.28s)
TonwerteLokaler Farb-MittelwertFlache ZellfüllungPunktflächen-ModulationAdaptive Tonstufen ohne Innennähte
Relief-ProfilKeins oder flache 1px-LinieFuge zwischen FacettenKeinsDoppel-Relief (dunkle Fuge + weißer Glanz)
MikrostrukturFlaches QuadratFlache FacetteEinzelner FarbpunktInnenring + Mikro-Kern
RechenaufwandInterpolation (<5ms)O(N log N) TriangulationEin-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.

> Häufige Fragen

Was ist der Kapsel-Pixel-Effekt und wie unterscheidet er sich von normaler Pixel-Art?
Klassische Pixel-Art zeichnet jede Rasterzelle als scharfkantiges Einzelquadrat. Kapsel-Pixel verbindet Zellen ähnlicher Helligkeit zu zusammenhängenden orthogonalen Formen – inspiriert von Leiterplatten, Höhenlinienkarten und moderner Druckgrafik –, rundet Innen- und Außenecken weich ab und hebt Übergänge mit einem doppelten Hell-Dunkel-Relief hervor.
Wie funktioniert die Eckenabrundung ohne teure Polygon-Vektorisierung?
Die Engine nutzt ein lokales Grid Signed Distance Field (Grid SDF). Für jeden Pixel fragt sie nur die eigene Zelle und ihre 8 Nachbarn ab. Daraus lässt sich der exakte euklidische Abstand zur gerundeten Grenzkurve geschlossen in O(1)-Zeit berechnen – ganz ohne Konturverfolgung, Triangulation oder Spline-Clipping.
Was steuern die Regler Detail und Kontrast?
Detail bestimmt die Rastergröße (cellSize) von groben Retro-Blöcken bis zu feinen Mikro-Schaltkreisen. Kontrast steuert die Zahl der Helligkeits-Tonstufen sowie die Stärke des Kanten-Reliefs: Höhere Werte erzeugen dichtere Höhenlinien und kräftigere weiße Glanzkanten.
Läuft der Algorithmus auf einem GPU-Shader oder in reinem CPU-Canvas-2D?
Die Web-Engine läuft zu 100 % auf der CPU in einem einzelnen Canvas-2D-ImageData-Puffer ohne WebGL oder externe Bibliotheken. Durch geschlossene Abstandsformeln und Tabellen dauert ein 1080p-Bild auf moderner Hardware etwa 35–45 ms – schnell genug für sofortige Browser-Exporte und einen flüssigen Live-Sucher in der App.
Kann ich Kapsel-Pixel kostenlos online ausprobieren?
Ja. Kapsel-Pixel ist direkt in Yans Textur-Studio unter yan.yichenlab.com/de/textures/ in der Kategorie GRID verfügbar – komplett lokal ohne Upload, ohne Anmeldung und mit wasserzeichenfreiem PNG-Export bis 1400 px lange Kante.