Recomposed
Canvas

Von Polar- zu kartesischen Koordinaten: Was cos und sin wirklich berechnen

Oct 11, 2026 · 6 min read

Von Polar- zu kartesischen Koordinaten: Was cos und sin wirklich berechnen

Die Intuition

Eine Formel wie x = center.x + radius * cos(angle) liest sich, als würde sie etwas mit dem Koordinatensystem selbst anstellen, den Ursprung verschieben, die Achsen drehen, etwas Strukturelles. Das ist nicht der Fall. Drei unabhängige, viel unspektakulärere Dinge passieren, gestapelt im selben Ausdruck:

  • cos(angle) und sin(angle) beantworten genau eine Frage: Auf einem Kreis mit Radius 1, zentriert im Ursprung, wo landet angle, als x und als y. Das ist alles, was diese Funktionen jemals berechnen, ein Koordinatenpaar für einen Punkt auf dem Einheitskreis.
  • radius * cos(angle) skaliert diesen Punkt auf dem Einheitskreis nach außen, gleicher Winkel, größerer Kreis.
  • center.x + ... ist eine reine Verschiebung, die den gesamten skalierten Punkt bewegt, sodass der Kreis zentriert ist, wo immer man will, statt bei (0, 0).

cos/sin erledigen immer nur den ersten Teil. Sie wissen nichts von radius, sie wissen nichts von center, und sie fassen niemals das Koordinatensystem selbst an, die Achsen, der Ursprung, "oben" und "unten" sind genau dort, wo sie vor dem Aufruf waren. Die Formel führt einfach Rotation, dann Skalierung, dann Verschiebung hintereinander aus, und es ist leicht, das kombinierte Ergebnis als eine Operation statt als drei misszuverstehen.

Konkretes Beispiel

Hier ist das Muster auf genau diese Formel reduziert, abgeleitet von einem echten Compose-DrawScope-Helper, der Punkte entlang eines Kreisbogens platziert:

import androidx.compose.ui.geometry.Offset
import kotlin.math.cos
import kotlin.math.sin
 
// Where does `angleRadians` land on a circle of `radius`, centered at
// `center`? That's the whole question this function answers.
fun pointOnCircle(center: Offset, radius: Float, angleRadians: Float): Offset {
    return Offset(
        x = center.x + radius * cos(angleRadians),
        y = center.y + radius * sin(angleRadians),
    )
}
pointOnCircle(center, radius, angleRadians = 0f)
// cos(0) = 1, sin(0) = 0 → (center.x + radius, center.y)
// directly to the right of center
 
pointOnCircle(center, radius, angleRadians = (PI / 2).toFloat()) // 90°
// cos(90°) = 0, sin(90°) = 1 → (center.x, center.y + radius)
// straight down, on a y-down DrawScope (more on that flip below)

An center hat sich dabei nichts geändert, in keiner der beiden Antworten. Es wird erst addiert, nachdem der Rotations-und-Skalierungs- Schritt bereits abgeschlossen ist.

Zieh an den Reglern unten und beobachte die Anzeige: Die r·cos/r·sin-Werte sind genau die beiden gestrichelten Schenkel des Dreiecks, und x/y sind einfach center plus diese beiden Schenkel.

pointAt

x: 186 y: 168.6

r·cos(40°) = 46 r·sin(40°) = 38.6 — angle 40 degrees, radius 60, point 186, 168.6

Weitere Fälle: mehrere Punkte auf einmal platzieren

Dieselbe Formel beantwortet "wo ist der N-te Punkt" genauso leicht wie "wo ist dieser eine Punkt", indem man angle in gleichmäßigen Schritten durchläuft, statt ihn einmal aufzurufen:

// Evenly spaced points around a full circle, e.g. tick marks on a dial
// or dots arranged in a ring.
fun pointsAroundCircle(center: Offset, radius: Float, count: Int): List<Offset> {
    return List(count) { i ->
        val angle = (2 * Math.PI * i / count).toFloat()
        pointOnCircle(center, radius, angle)
    }
}

Mathematisch passiert hier nichts Neues, es ist genau derselbe pointOnCircle-Aufruf wie oben, nur count-mal aufgerufen, jedes Mal mit einem anderen angle. Das ist die allgemeine Form hinter Uhrzeigern, Radialmenüs, Partikeln auf einem Ring und dem Abtasten von Punkten entlang eines Kreisbogens, um sie mit Kurven zu verbinden, statt den Bogen direkt zu zeichnen.

Das Grundprinzip

Das ist Polar-zu-Kartesisch-Konvertierung: ein Punkt, beschrieben als (radius, angle), Distanz und Richtung von einem Zentrum aus, umgewandelt in das (x, y)-Paar, das ein Bildschirm tatsächlich braucht. cos/sin sind der Rotationsschritt der Konvertierung; die Radius-Multiplikation und die Zentrums-Addition sind separate Schritte, die in derselben Codezeile mitfahren. In die andere Richtung zu gehen, von (x, y) zurück zu (radius, angle), ist ein anderes Problem mit einem anderen Werkzeug (atan2 für den Winkel, die Distanzformel für den Radius), nicht die Umkehrung davon, cos/sin anders aufzurufen.

Anderswo: dasselbe Grundprinzip, anderes Framework

  • SVG: Ein <circle> oder der A-Pfadbefehl eines Bogens wird von der Pfad-Engine des Browsers gerendert, indem sie intern genau diese center + radius * (cos, sin)-Formel durchläuft, um die Kurve zu erzeugen; d3.arc().centroid() ruft dieselbe Konvertierung direkt auf, ständig verwendet, um Beschriftungen von Kuchen- und Donut-Diagrammen am Mittelpunkt eines Segments zu positionieren.
  • HTML5 Canvas: CanvasRenderingContext2D.arc(x, y, radius, startAngle, endAngle) nimmt das Tripel Zentrum/Radius/Winkel als separate Argumente entgegen und führt pro Frame dieselbe Konvertierung aus, um die Kurve zu zeichnen.
  • SwiftUI / Core Graphics: Path.addArc(center:radius:startAngle: endAngle:clockwise:) nimmt genau dasselbe Tripel Zentrum/Radius/Winkel wie Canvas' arc() entgegen; einen Punkt per Hand mit CGPoint(x: center.x + radius * cos(angle), y: center.y + radius * sin(angle)) zu platzieren, ist die Standardmethode, um alles zu zeichnen, wofür ein Path keine eingebaute Primitive hat, die Skalenstriche eines Messgeräts, ein Zifferblatt, ein radiales Layout.
  • Game-Engines (Unity, Godot, Unreal): new Vector2(Mathf.Cos(angle), Mathf.Sin(angle)) * radius + center ist die Standardmethode, um ein Objekt um einen Punkt kreisen zu lassen, dieselben drei Schritte, dieselbe Reihenfolge, nur mit einem Vektortyp statt separaten x/y-Feldern geschrieben.
  • CSS: conic-gradient() und clip-path: circle() sind deklarative Wrapper um dieselbe Mathematik; ein Element mit offset-path: circle() entlang eines Kreispfads zu animieren, ist diese Formel, die jeden Frame läuft, nur vom Browser statt vom eigenen Code berechnet.

Randfälle

Die Radius-Multiplikation vergessen. cos/sin geben Werte im Bereich [-1, 1] zurück, nicht Pixel. x = center.x + cos(angle) kompiliert einwandfrei und sieht plausibel aus, da es die richtige Form hat, center plus etwas Winkelabhängiges, aber es zeichnet einen Kreis mit Radius 1: visuell fällt jeder Punkt in etwa auf dieselbe Stelle wie center zusammen. Es gibt keinen Absturz, der auf das fehlende radius * hinweist, nur eine Form, die sich stillschweigend weigert, größer als ein Pixel zu sein.

Vertauschen, welche Achse cos und welche sin bekommt. x = center.x + radius * sin(angle) gepaart mit y = center.y + radius * cos(angle) zeichnet immer noch einen vollkommen guten Kreis, die Form geht nie kaputt. Was kaputtgeht, ist die Bedeutung von angle = 0: Statt rechts vom Zentrum zu landen (die Konvention dieses Beitrags), landet er darunter, ein stiller 90°-Versatz gegenüber dem, was der Rest des Codes annimmt, wohin "Winkel null" zeigt.

Grad an eine Radians-only-Funktion übergeben. kotlin.math.cos/sin (und ihre Entsprechungen in praktisch jeder Sprache) erwarten , nicht Grad. 90 direkt zu übergeben, in der Absicht "90 Grad" zu meinen, fragt tatsächlich nach cos/sin von 90 Radiant, also etwa 14 volle Umdrehungen von dem entfernt, was gemeint war, und das Ergebnis landet nirgends in der Nähe des erwarteten Kreises, ohne Exception, die den Fehler abfängt. Zuerst umrechnen: Math.toRadians(90.0), oder die Arithmetik degrees * PI / 180, die diese Funktion umschließt.

Welche Richtung "oben" zeigt, kippt um, die Formel nicht. Auf einem y-down DrawScope/Canvas (dem Android/Compose-Standard) sorgt ein zunehmender angle für eine Bewegung im Uhrzeigersinn statt der Gegenuhrzeigersinn-Bewegung, die dieselbe Formel auf einer Mathe-Unterrichts-Ebene mit y-up erzeugt. cos/sin selbst ändern sich nie, nur, in welche visuelle Richtung ein positiver Winkel landet. Der Beitrag zu Bildschirm-Koordinatensystemen behandelt diesen Umklapp-Effekt ausführlich; die Formel dieses Beitrags ist der Fall x = cx + r·cos(angle), den die Einleitung jenes Beitrags bereits voraussetzt.

Wann man darauf zurückgreift

Überall dort, wo die eigentliche Größe, in der man denkt, "wie weit, in welcher Richtung, von einem Zentrum aus" ist, nicht direkt ein x/y-Paar:

  • Uhr- und Zifferblätter. Stunden-/Minutenzeiger, Skalenstriche, Zeiger von Messgeräten: Jeder davon ist angle rein, Position raus, genau pointOnCircle.
  • Radial- und Kreismenüs. N Menüeinträge gleichmäßig um ein Zentrum anzuordnen, ist das pointsAroundCircle von oben, ein Aufruf pro Eintrag.
  • Kreisende oder umlaufende Objekte. Die Punkte eines Ladespinners, ein Satellitensymbol, das einen Planeten umkreist, ein Partikel auf einem Ring: angle jeden Frame aktualisieren und die Position neu berechnen, statt x/y-Geschwindigkeit direkt zu verfolgen.
  • Platzierung von Diagrammbeschriftungen und -segmenten. Die Beschriftung eines Kuchen-/Donut-Diagramms muss am Mittelwinkel eines Segments sitzen, nach außen auf einen bestimmten Radius vom Zentrum verschoben, dieselbe Formel, die dieser Beitrag die ganze Zeit verwendet hat.
  • Einen Kreisbogen abtasten, um ihn mit etwas anderem zu zeichnen. angle in kleinen Schritten durchlaufen und die entstehenden Punkte mit quadraticTo/lineTo statt einer nativen Bogen-Primitive verbinden, nützlich, wenn der Bogen wackeln, sich verjüngen oder sonst kein perfekter Kreis sein soll.

Das Signal, dass man im falschen Beitrag gelandet ist: Wenn man tatsächlich eine (x, y)-Position hat (einen Berührungspunkt, eine Ziehbewegung) und daraus einen Winkel oder eine Distanz zurückgewinnen will, ist das die umgekehrte Konvertierung, atan2 und die Distanzformel, keine andere Art, cos/sin aufzurufen.

cos/sin beantworten immer nur "wo liegt dieser Winkel auf einem Einheitskreis"; die Skalierung mit einem Radius und die Addition eines Zentrums sind separate Schritte, die zufällig in derselben Zeile landen, nicht etwas, das sin und cos selbst berechnen.

Keep reading

Related reads

Neue Beiträge direkt in dein Postfach