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)undsin(angle)beantworten genau eine Frage: Auf einem Kreis mit Radius 1, zentriert im Ursprung, wo landetangle, alsxund alsy. 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.
- →Screen Coordinate Systems Aren't CartesianWhy the same cos/sin formula sweeps clockwise on a y-down screen instead of counterclockwise, plus atan2 for turning a drag into an angle.
- →atan, atan2, and atanhThe reverse direction: going from an (x, y) position back to an angle, and why atan alone can't do it.
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.
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 derA-Pfadbefehl eines Bogens wird von der Pfad-Engine des Browsers gerendert, indem sie intern genau diesecenter + 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 mitCGPoint(x: center.x + radius * cos(angle), y: center.y + radius * sin(angle))zu platzieren, ist die Standardmethode, um alles zu zeichnen, wofür einPathkeine 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 + centerist die Standardmethode, um ein Objekt um einen Punkt kreisen zu lassen, dieselben drei Schritte, dieselbe Reihenfolge, nur mit einem Vektortyp statt separatenx/y-Feldern geschrieben. - CSS:
conic-gradient()undclip-path: circle()sind deklarative Wrapper um dieselbe Mathematik; ein Element mitoffset-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
anglerein, Position raus, genaupointOnCircle. - Radial- und Kreismenüs. N Menüeinträge gleichmäßig um ein Zentrum
anzuordnen, ist das
pointsAroundCirclevon oben, ein Aufruf pro Eintrag. - Kreisende oder umlaufende Objekte. Die Punkte eines
Ladespinners, ein Satellitensymbol, das einen Planeten umkreist, ein
Partikel auf einem Ring:
anglejeden Frame aktualisieren und die Position neu berechnen, stattx/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.
anglein kleinen Schritten durchlaufen und die entstehenden Punkte mitquadraticTo/lineTostatt 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.



