Recomposed
Canvas

Quadratisch vs. kubisch vs. Bogen: die richtige Pfadkurve wählen

Oct 9, 2026 · 8 min read

Quadratisch vs. kubisch vs. Bogen: die richtige Pfadkurve wählen

Was eine Bezierkurve eigentlich ist

Eine Bezierkurve ist eine glatte Kurve zwischen einem Startpunkt und einem Endpunkt. Ihre Form wird von einem oder mehreren bestimmt, die abseits der Kurve selbst liegen, nicht auf ihr.

  • Quadratische Bezierkurve: 3 Punkte insgesamt, Start, ein Kontrollpunkt, Ende. Das zeichnet quadraticTo.
  • Kubische Bezierkurve: 4 Punkte insgesamt, Start, zwei Kontrollpunkte, Ende. Das zeichnet cubicTo.

Der zusätzliche Kontrollpunkt einer kubischen Kurve macht den ganzen Unterschied: ein weiterer unabhängiger Zug an der Form. Die nächsten Abschnitte zeigen genau, was dieser Zug bewirkt, und warum es so naheliegt anzunehmen, ein Kontrollpunkt liege auf der Kurve, obwohl das nie der Fall ist.

Die Intuition

Path.quadraticTo(x1, y1, x2, y2) und cubicTo(x1, y1, x2, y2, x3, y3) nehmen beide Koordinaten entgegen, die wie Punkte auf der Kurve aussehen. Sind sie aber nicht.

  • Ein Kontrollpunkt ist nie ein Punkt, den die Kurve durchläuft, sondern ein Punkt, zu dem hin sie sich biegt. Die Kurve berührt nur ihren Start- und Endpunkt.
  • Rückt man einen Kontrollpunkt näher an die gerade Linie zwischen Start und Ende, ändert sich die Kurve kaum; rückt man ihn weit weg, biegt sich die Kurve stark, erreicht ihn aber trotzdem nie.
  • arcTo wirkt wie ein drittes Mitglied derselben Familie, dieselbe Path-Methodenform, dieselbe "gib ihr ein paar Koordinaten"-Signatur. Ist es aber nicht: Da zieht kein Kontrollpunkt an irgendetwas, es ist Kreisgeometrie (Radius, Startwinkel, Schwenkwinkel), eine völlig andere Art von Mathematik in derselben API-Form.

Quadratisch: ein Kontrollpunkt biegt eine Linie

val path = Path()
path.moveTo(20f, 80f)
 
// ❌ Kontrollpunkt sitzt fast auf der geraden Linie → kaum eine Kurve
path.quadraticTo(
    x1 = 140f,
    y1 = 70f,
    x2 = 260f,
    y2 = 80f,
)
 
// ✅ Kontrollpunkt weit von der Linie weggezogen → starke Wölbung, gleiche Endpunkte
path.quadraticTo(
    x1 = 140f,
    y1 = 20f,
    x2 = 260f,
    y2 = 80f,
)

Beide Aufrufe starten bei (20, 80) und enden bei (260, 80), jedes Mal dieselben beiden Endpunkte. Das Einzige, was sich geändert hat, ist die Position des Kontrollpunkts, und das ist auch das Einzige, was die Form verändert hat.

quadraticTo(x1, y1, x2, y2) zeichnet eine quadratische Bezierkurve, indem ein von 0 bis 1 durchlaufen wird: bei jedem Schritt entlang dieses Durchlaufs interpoliert sie linear vom Startpunkt zum Kontrollpunkt und, getrennt davon, vom Kontrollpunkt zum Endpunkt, und interpoliert dann noch einmal zwischen diesen beiden Ergebnissen. Das ist ein verschachtelter Durchlauf von -vom-lerp. Der Kontrollpunkt erscheint nie auf der fertigen Kurve, er steuert nur, in welche Richtung die Mischung tendiert.

Zieh den Kontrollpunkt unten und beobachte, wie beide Enden fixiert bleiben, während sich die Kurve um ihn herum neu formt, egal wohin er wandert:

quadraticTo
0408012016020024028004080120160200240StartEndControl 1

drag any point — Start at 20, 130, End at 260, 130, Control 1 at 140, 30

Quadratische Kurven verketten: eine einzelne Welle

Eine Welle mit einem Auf und einem Ab, ein einzelner sinusartiger Zyklus, ist keine Path-Primitive, muss es aber auch nicht sein. Es sind einfach zwei quadraticTo-Aufrufe hintereinander, einer zieht hoch zu einem Gipfel, einer zieht runter zu einem Tal, und beide teilen sich den Mittelpunkt dazwischen als Scharnier, an dem die Kurve zur Mittellinie zurückkehrt.

Die Falle besteht darin, dieselbe Annahme zu wiederholen, vor der der frühere Abschnitt gewarnt hat: die Höhe des Kontrollpunkts mit der Höhe des Gipfels zu verwechseln.

// ❌ Kontrollpunkt auf die gewünschte Gipfelhöhe gesetzt (Amplitude 40
// über der Mittellinie) → die Kurve erreicht nur die Hälfte davon, Amplitude 20
val path = Path()
path.moveTo(20f, 130f) // Mittellinie
path.quadraticTo(
    x1 = 80f,
    y1 = 90f,
    x2 = 140f,
    y2 = 130f,
)
// ✅ Kontrollpunkte auf das 2-Fache der gewünschten Amplitude gezogen →
// die Kurve erreicht tatsächlich Amplitude 40, auf beiden Hälften der Welle
val path = Path()
path.moveTo(20f, 130f) // Mittellinie
path.quadraticTo(
    x1 = 80f,
    y1 = 50f,
    x2 = 140f,
    y2 = 130f,
)
path.quadraticTo(
    x1 = 200f,
    y1 = 210f, // 2x die Amplitude, dieses Mal unterhalb der Mittellinie
    x2 = 260f,
    y2 = 130f,
)

Der Grund ist derselbe verschachtelte Lerp aus dem Intuitionsabschnitt, nur an einem bestimmten Punkt ausgewertet: bei t = 0,5 liegt eine quadratische Bezierkurve bei 0,25 × Start + 0,5 × Kontrolle + 0,25 × Ende. Da Start und Ende beide auf der Mittellinie fixiert sind, reduziert sich das auf (Mittellinie + Kontrolle) / 2, den schlichten Mittelpunkt zwischen Mittellinie und Kontrollpunkt. Löst man das nach "Kontrolle liegt beim Doppelten der Amplitude" auf, ist das 2-Fache keine magische Konstante, sondern folgt direkt aus den Gewichten der Interpolation.

Zieh einen der beiden Kontrollpunkte unten und beobachte, wie sich der tatsächliche Gipfel (der kleine rote Punkt) nur halb so weit bewegt wie der Griff:

quadraticTo ×2
0408012016020024028004080120160200240peak 40peak 40Control 1Control 2

drag either control point — the peak only moves half as far as the handle — Control 1 pulled to 50, peak amplitude 40 up. Control 2 pulled to 210, peak amplitude 40 down.

Dieselbe Idee von Scharnier und Wiederholung lässt sich über einen einzelnen Zyklus hinaus fortsetzen: Verkette weitere quadraticTo-Paare, wobei abwechselnd zu welcher Seite der Mittellinie jeder Kontrollpunkt zieht, und dasselbe Zwei-Aufruf-Muster kachelt sich zu einer längeren Welle.

Kubisch: ein zweiter Kontrollpunkt fügt eine S-Kurve hinzu

val path = Path()
path.moveTo(20f, 80f)
 
// ❌ beide Kontrollpunkte auf derselben Seite → eine einzelne Wölbung,
// dieselbe Form, die eine quadratische Kurve mit einem Punkt schon erreichen könnte
path.cubicTo(
    x1 = 80f,
    y1 = 20f,
    x2 = 200f,
    y2 = 20f,
    x3 = 260f,
    y3 = 80f,
)
 
// ✅ Kontrollpunkte auf entgegengesetzten Seiten → eine S-Kurve, die eine
// quadratische Kurve nie erzeugen kann, egal wohin ihr einer Punkt wandert
path.cubicTo(
    x1 = 80f,
    y1 = 20f,
    x2 = 200f,
    y2 = 140f,
    x3 = 260f,
    y3 = 80f,
)

cubicTo(x1, y1, x2, y2, x3, y3) führt dieselbe Idee der verschachtelten Interpolation eine Ebene tiefer aus: drei Lerps statt einem, gemischt durch zwei Kontrollpunkte statt einem. Dieser zusätzliche Kontrollpunkt ist der ganze Unterschied zwischen quadratisch und kubisch, es ist kein zweiter Regler für dieselbe Wölbung, sondern eine zweite, unabhängige Richtung, in die sich die Kurve lehnen kann, und genau das macht die S-Kurve möglich und für jede quadratische Kurve mit nur einem Kontrollpunkt unmöglich, sie nachzubilden.

Zieh einen der beiden Kontrollpunkte unten und beobachte, wie beide Enden fixiert bleiben, während sich die Kurve um den gezogenen Punkt herum neu formt:

cubicTo
0408012016020024028004080120160200240StartEndControl 1Control 2

drag any point — Start at 20, 130, End at 260, 130, Control 1 at 80, 30, Control 2 at 200, 230

Das Grundprinzip

Beides sind Bezierkurven: Ein Punkt beim Parameter t wird durch rekursive lineare Interpolation zwischen Kontrollpunkten berechnet, eine Technik namens De Casteljau-Algorithmus. Eine quadratische Kurve (3 Punkte: Start, ein Kontrollpunkt, Ende) führt eine Ebene verschachtelten Lerps aus; eine kubische Kurve (4 Punkte) führt zwei aus. Der Grad ist immer "Punktzahl minus eins", und die Kontrollpunkte sind Gewichte in dieser Interpolation, niemals Haltepunkte auf der Kurve selbst.

Anderswo: dasselbe Grundprinzip, anderes Framework

  • SVG-Pfaddaten: Der Q-Befehl (Q x1,y1 x,y) ist eine quadratische Bezierkurve, C (C x1,y1 x2,y2 x,y) ist kubisch, identische Mathematik, nur als String statt als Methodenaufruf geschrieben.
  • CSS cubic-bezier(): Jede Kurve bei transition-timing-function und animation-timing-function (einschließlich der benannten ease, ease-in-out usw.) ist eine kubische Bezierkurve über die Zeit statt über den Raum, zwei Kontrollpunkte, derselbe Verschachtelungsinterpolationsmechanismus, nur mit einem animierten Fortschrittswert statt einer Pixelposition.
  • PostScript / PDF: Der curveto-Operator nimmt genau dieselben sechs Zahlen wie cubicTo, zwei Kontrollpunkte und einen Endpunkt. SVGs C-Befehl wurde direkt davon abgeleitet.
  • Das Zeichenstift-Werkzeug, praktisch in jedem Vektoreditor: Illustrator, Photoshops Vektorpfade, Figma, Penpot, Sketch, Affinity Designer, Inkscape. Einen Kurvengriff aus einem Ankerpunkt zu ziehen ist das Platzieren eines kubischen Kontrollpunkts per Hand, die Richtung und Länge des Griffs sind die Richtung und Distanz vom Anker zum unsichtbaren Kontrollpunkt, der die Kurve steuert. Das ist keine Adobe-spezifische Konvention, jedes dieser Werkzeuge zieht genau dieselben beiden Kontrollpunkte, die dieser Beitrag die ganze Zeit gezogen hat, nur mit einer Maus statt einem Schieberegler. Hält man Alt/Option gedrückt, während man einen Griff zieht, löst er sich von seinem Zwilling, bewegt einen Kontrollpunkt unabhängig, derselbe asymmetrische Zug, der die S-Kurve dieses Beitrags erzeugt.

Vom Design zum Code: nicht nach Augenmaß schätzen

Der Abschnitt zum Zeichenstift-Werkzeug oben hat es schon gesagt: Einen Griff in Figma oder Penpot zu ziehen ist das Platzieren eines kubischen Kontrollpunkts per Hand. Das bedeutet, ein Pfad, den eine Designerin oder ein Designer zeichnet, ist keine Referenz zum Annähern, sondern die tatsächlichen Kontrollpunktdaten, bereits berechnet. Behandle ihn so.

Schätze die Kurve nicht nach Augenmaß. Ein Design-Mock anzusehen und zu raten, wo die Kontrollpunkte "wahrscheinlich" liegen, erzeugt eine Kurve, die isoliert nah dran wirkt, aber abweicht, sobald jemand einen Griff verschiebt, weil deine Schätzung und die exakten Zahlen von Anfang an nie dieselbe Kurve waren. Hol dir stattdessen die echten Koordinaten, statt sie zu schätzen:

  • Figma: Pfad auswählen, Rechtsklick, Kopieren/Einfügen als → Als SVG kopieren. Das d-Attribut sind deine Kontrollpunkte, wortwörtlich.
  • Penpot: Form auswählen, Exportieren → SVG. Dasselbe d-Attribut.

In beiden Fällen bekommst du Standard-SVG-Pfadbefehle, und die werden Argument für Argument, in derselben Reihenfolge, auf cubicTo/quadraticTo abgebildet:

SVG:    C x1,y1 x2,y2 x,y
Kotlin: cubicTo(x1, y1, x2, y2, x, y)

SVG:    Q x1,y1 x,y
Kotlin: quadraticTo(x1, y1, x, y)

Hier ist die exakte S-Kurve aus dem Kubisch-Abschnitt oben, so wie ein Export sie dir tatsächlich liefern würde:

M20,80 C80,20 200,140 260,80
val path = Path()
path.moveTo(20f, 80f)
path.cubicTo(
    x1 = 80f,
    y1 = 20f,
    x2 = 200f,
    y2 = 140f,
    x3 = 260f,
    y3 = 80f,
)

Das ist keine Umwandlung, es ist eine Transkription. Dieselben sechs Zahlen, dieselbe Reihenfolge, keine Ermessensentscheidung dazwischen.

Eine Falle, die man zuerst prüfen sollte. SVG erlaubt ein kleingeschriebenes c/q, denselben Befehl, aber relativ zum aktuellen Punkt statt absolut. Composes cubicTo/quadraticTo akzeptieren nur absolute Koordinaten, also muss bei einem relativen Befehl der aktuelle Punkt zu jedem Zahlenpaar addiert werden, bevor es verwendbar ist (x1Abs = currentX + x1Rel, und so weiter). Transkribiert man einen relativen Befehl unverändert, landet der Kontrollpunkt völlig neben dem falschen Anker, ohne dass ein Fehler verrät, warum die Kurve seltsam aussieht.

Grenzfälle

arcTo ist überhaupt keine Bezierkurve. arcTo(rect, startAngleDegrees, sweepAngleDegrees, forceMoveTo) wird durch eine Begrenzungsbox und einen Start-/Schwenkwinkel definiert, echte Kreisgeometrie, berechnet mit cos/sin, keine Interpolation zwischen Punkten. Es gibt keinen Kontrollpunkt, den man falsch platzieren könnte, weshalb es auch etwas kann, was keine Bezierkurve kann: einen perfekten Kreisbogen nachzeichnen. Greif gezielt zu arcTo, wenn du einen exakten Kreis oder Ring brauchst (eine Fortschrittsanzeige, ein Zifferblatt), und zu quadraticTo/cubicTo, wenn du eine organische Biegung willst, die nicht geometrisch perfekt sein muss.

val path = Path()
path.arcTo(
    rect = Rect(center = Offset(140f, 130f), radius = 80f),
    startAngleDegrees = 0f,
    sweepAngleDegrees = 270f,
    forceMoveTo = false,
)

Zieh die Schieberegler unten. Egal wie weit du Radius, Start oder Schwenk veränderst, das Ergebnis ist immer ein perfekter Bogen, weil kein Kontrollpunkt etwas aus der Form zieht:

arcTo

drag the sliders, the arc is always a perfect circle — radius 80, startAngleDegrees 0, sweepAngleDegrees 270

Mit einer einzelnen kubischen Bezierkurve lässt sich niemals ein perfekter Kreis zeichnen. Keine Platzierung von zwei Kontrollpunkten lässt eine kubische Kurve einen echten Kreisbogen nachzeichnen. Die beiden Arten von Mathematik treffen sich exakt nur an den vier Himmelsrichtungspunkten.

Jedes Vektorwerkzeug, das so aussieht, als würde es Kreise aus Bezierkurven zeichnen (SVG, Illustrator, Figma, Skia selbst), täuscht das auf dieselbe Weise vor:

  • Vier kubische Kurven zusammennähen, eine pro Quadrant.
  • Jeden Kontrollpunkt Radius × 0,5523 von seinem nächsten Anker entfernt platzieren, die Konstante, die die Tangente und Krümmung einer Kubik am besten an einen Kreis anpasst.
  • Genug davon bei einem ausreichend kleinen Radius rendern, und der Fehler verschwindet optisch. Er ist noch da, nur unterhalb des Pixels.

Gekreuzte kubische Kontrollpunkte erzeugen eine selbstüberschneidende Schlaufe, nicht nur eine weiter getriebene S-Kurve. Zieh die beiden Kontrollpunkte in der Demo oben in entgegengesetzte Ecken und weit genug übereinander hinaus, und die Kurve überschneidet sich selbst, ein echter Pfad, kein Rendering-Fehler, weil nichts in der Interpolationsmathematik die beiden verschachtelten Lerps davon abhält, sich übereinander zurückzuschlingen.

Wann man zu einer Bezierkurve greift

Immer wenn eine Kurve sich organisch, von Hand abgestimmt biegen muss statt präzise kreisförmig, ist quadraticTo/cubicTo das richtige Werkzeug. Ein paar Stellen, an denen dieses Muster in der Praxis auftaucht:

Eigene Zeichnungen und Formen

  • Eine grobe Polylinie (Touch-Samples, Aktienchart-Daten, ein Unterschriftenfeld) in einen visuell glatten Strich zu verwandeln, ohne Hunderte von Punkten abzutasten. Das ist der Trick hinter dem Bau eines wellenförmigen kreisförmigen Ladebalkens: Punkte rund um den Kreis abtasten und sie dann mit quadraticTo statt lineTo verbinden.
  • Blob-Buttons, Wellenunterstreichungen, oder jede Ladeanzeige, deren Rand wabern soll, statt kreisförmig zu bleiben.
  • Eigene Eckformen, die eine einfache RoundedCornerShape nicht ausdrücken kann, da sie nur kreisförmige Ecken kennt.

Animation und Bewegung

  • Easing-Kurven: dieselbe kubische Mathematik aus dem Abschnitt "Anderswo" oben, nur dass Fortschritt auf Fortschritt abgebildet wird statt Pixel auf Pixel.
  • Ein Icon oder eine Form in eine andere morphen, indem man die Kontrollpunkte jeder Form über die Zeit interpoliert.

Illustration und Vektorgrafik

  • Alles, was mit einem Zeichenstift-Werkzeug (Illustrator, Figma) handgezeichnet und als Path-Daten exportiert wird, kommt bereits als eine Folge von cubicTo-Aufrufen an. Das Muster zu erkennen bedeutet zu erkennen, was das Werkzeug bereits für dich generiert hat.

Das Denkmodell, das man tatsächlich nutzen sollte

Kontrollpunkte sind Gewichte in einer Interpolation, keine Wegpunkte auf einer Kurve. Wähle eine Bezierkurve (quadraticTo/cubicTo), wenn du eine Biegung willst, die nur organisch glatt aussehen muss; wähle arcTo, wenn die Geometrie tatsächlich ein Kreis sein muss.

Keep reading

Related reads

Neue Beiträge direkt in dein Postfach