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.
arcTowirkt wie ein drittes Mitglied derselben Familie, dieselbePath-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.
- →Screen Coordinate Systems Aren't CartesianWhy arcTo's startAngleDegrees/sweepAngleDegrees sweep clockwise on screen instead of counterclockwise, the same y-down convention behind every cos/sin call in the arc section below.
- →Polar to Cartesian: What cos and sin Are Actually ComputingThe cos/sin circular geometry arcTo is built on, as opposed to the control-point interpolation quadraticTo and cubicTo use instead.
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:
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:
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:
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 beitransition-timing-functionundanimation-timing-function(einschließlich der benanntenease,ease-in-outusw.) 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 wiecubicTo, zwei Kontrollpunkte und einen Endpunkt. SVGsC-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:
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,5523von 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
quadraticTostattlineToverbinden. - Blob-Buttons, Wellenunterstreichungen, oder jede Ladeanzeige, deren Rand wabern soll, statt kreisförmig zu bleiben.
- Eigene Eckformen, die eine einfache
RoundedCornerShapenicht 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 voncubicTo-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.



