L'intuition
Une formule comme x = center.x + radius * cos(angle) se lit comme si
elle faisait quelque chose au système de coordonnées lui-même, déplaçant
l'origine, faisant tourner les axes, quelque chose de structurel. Ce
n'est pas le cas. Trois choses indépendantes, bien plus banales, se
produisent, empilées dans la même expression :
cos(angle)etsin(angle)répondent à une seule question : sur un cercle de rayon 1 centré à l'origine, oùangleatterrit-il, en tant quexety. C'est tout ce que ces fonctions calculent, jamais plus, une paire de coordonnées pour un point sur le cercle unité.radius * cos(angle)fait grandir ce point du cercle unité vers l'extérieur, même angle, cercle plus grand.center.x + ...est une simple translation, qui déplace tout le point mis à l'échelle pour que le cercle soit centré où vous voulez, plutôt qu'en(0, 0).
cos/sin ne font jamais que la première partie. Elles ne connaissent
ni radius, ni center, et ne touchent jamais au système de
coordonnées lui-même : les axes, l'origine, « haut » et « bas » sont
exactement là où ils étaient avant que vous les appeliez. La formule
exécute simplement une rotation, puis une mise à l'échelle, puis une
translation, l'une après l'autre, et il est facile de mal lire le
résultat combiné comme une seule opération au lieu de trois.
- →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.
Exemple concret
Voici le schéma réduit à cette seule formule, adapté d'un vrai helper
Compose DrawScope qui place des points le long d'un arc circulaire :
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)Rien dans center ne change l'une ou l'autre réponse. Il n'est ajouté
qu'une fois l'étape de rotation-et-mise-à-l'échelle déjà terminée.
Faites glisser les curseurs ci-dessous et observez l'affichage : les
valeurs r·cos/r·sin sont exactement les deux côtés en pointillés du
triangle, et x/y ne sont que center plus ces deux côtés.
x: 186 y: 168.6
r·cos(40°) = 46 r·sin(40°) = 38.6 — angle 40 degrees, radius 60, point 186, 168.6
Plus de cas : placer plusieurs points à la fois
La même formule répond à « où est le Nième point » tout aussi facilement
qu'à « où est ce point-ci », en balayant angle par pas réguliers au
lieu de l'appeler une seule fois :
// 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)
}
}Rien de nouveau ne se produit mathématiquement : c'est exactement le
même appel à pointOnCircle que ci-dessus, simplement invoqué count
fois avec un angle différent chaque fois. C'est la forme générale
derrière les aiguilles d'une horloge, les menus radiaux, les particules
sur un anneau, et l'échantillonnage de points le long d'un arc circulaire
pour les relier avec des courbes plutôt que de dessiner l'arc
directement.
Le fondamental
C'est la conversion polaire-vers-cartésien : un point décrit comme
(radius, angle), distance et direction depuis un centre, converti en
la paire (x, y) dont un écran a réellement besoin. cos/sin sont
l'étape de rotation de la conversion ; la multiplication par le rayon et
l'addition du centre sont des étapes séparées qui voyagent sur la même
ligne de code. Aller dans l'autre direction, de (x, y) vers (radius, angle), est un problème différent avec un outil différent (atan2 pour
l'angle, la formule de distance pour le rayon), pas l'inverse d'un appel
différent à cos/sin.
Ailleurs : même fondamental, framework différent
- SVG : un
<circle>ou la commande de cheminAd'un arc est rendu par le moteur de tracé du navigateur qui exécute en interne exactement cette formulecenter + radius * (cos, sin)pour produire la courbe ;d3.arc().centroid()appelle directement la même conversion, utilisée constamment pour positionner les étiquettes de graphiques en secteurs et en anneau au milieu d'une tranche. - HTML5 Canvas :
CanvasRenderingContext2D.arc(x, y, radius, startAngle, endAngle)prend le triplet centre/rayon/angle en arguments séparés et exécute la conversion identique à chaque image pour tracer la courbe. - SwiftUI / Core Graphics :
Path.addArc(center:radius:startAngle: endAngle:clockwise:)prend exactement le même triplet centre/rayon/ angle quearc()de Canvas ; placer un point à la main avecCGPoint(x: center.x + radius * cos(angle), y: center.y + radius * sin(angle))est la méthode standard pour dessiner tout ce pour quoi unPathn'a pas de primitive intégrée, les repères d'une jauge, un cadran d'horloge, une disposition radiale. - Moteurs de jeu (Unity, Godot, Unreal) :
new Vector2(Mathf.Cos(angle), Mathf.Sin(angle)) * radius + centerest la méthode standard pour faire orbiter un objet autour d'un point, mêmes trois étapes, même ordre, simplement écrit avec un type vecteur au lieu de champsx/yséparés. - CSS :
conic-gradient()etclip-path: circle()sont des enveloppes déclaratives autour de la même mathématique ; animer un élément autour d'un chemin circulaire avecoffset-path: circle()est cette formule exécutée à chaque image, simplement calculée par le navigateur au lieu de votre propre code.
Cas limites
Oublier la multiplication par le rayon. cos/sin renvoient des
valeurs dans [-1, 1], pas des pixels. x = center.x + cos(angle)
compile sans problème et paraît plausible, car la forme est correcte,
center plus quelque chose qui dépend de l'angle, mais cela trace un
cercle de rayon 1 : visuellement, chaque point s'effondre à peu près au
même endroit que center. Il n'y a aucun crash pour signaler le radius * manquant, juste une forme qui refuse silencieusement d'être plus
grande qu'un pixel.
Échanger quel axe reçoit cos et quel axe reçoit sin. x = center.x + radius * sin(angle) associé à y = center.y + radius * cos(angle) trace toujours un cercle parfaitement correct, la forme ne se
casse jamais. Ce qui se casse, c'est le sens de angle = 0 : au lieu
d'atterrir à droite du centre (la convention de cet article), il
atterrit en dessous, un décalage silencieux de 90° par rapport à ce que
le reste du code suppose que « l'angle zéro » désigne.
Des degrés fournis à une fonction qui n'accepte que des radians.
kotlin.math.cos/sin (et leurs équivalents dans pratiquement tous les
langages) attendent des , pas des degrés. Passer directement 90,
en voulant dire « 90 degrés », demande en réalité cos/sin de 90
radians, soit environ 14 tours complets au-delà de ce que vous vouliez,
et le résultat n'atterrit nulle part près du cercle attendu, sans
exception pour signaler l'erreur. Convertissez d'abord :
Math.toRadians(90.0), ou l'arithmétique degrees * PI / 180 qu'elle
enveloppe.
Le sens dans lequel « haut » pointe s'inverse, pas la formule. Sur un
DrawScope/Canvas avec y vers le bas (le défaut Android/Compose),
augmenter angle balaye dans le sens horaire au lieu du balayage
antihoraire que la même formule produit sur un plan de cours de maths
avec y vers le haut. cos/sin elles-mêmes ne changent jamais, seule la
direction visuelle dans laquelle un angle positif atterrit change.
L'article sur les systèmes de coordonnées écran
couvre cette inversion en détail ; la formule de cet article est le cas
x = cx + r·cos(angle) que l'introduction de cet autre article suppose
déjà.
Quand y recourir
Partout où la quantité réelle à laquelle vous pensez est « à quelle
distance, dans quelle direction, depuis un centre », pas directement une
paire x/y :
- Cadrans d'horloge et de jauge. Aiguilles des heures/minutes,
repères, aiguilles de jauge : chacun est
angleen entrée, position en sortie, exactementpointOnCircle. - Menus radiaux et circulaires. Disposer N éléments de menu
régulièrement autour d'un centre, c'est
pointsAroundCircleci-dessus, un appel par élément. - Objets en orbite ou en rotation. Les points d'un indicateur de
chargement, une icône de satellite tournant autour d'une planète, une
particule sur un anneau : mettez à jour
angleà chaque image et recalculez la position, au lieu de suivre une vélocitéx/ydirectement. - Placement des étiquettes et des tranches d'un graphique. L'étiquette d'un graphique en secteurs ou en anneau doit se situer à l'angle médian d'une tranche, poussée vers l'extérieur jusqu'à un certain rayon depuis le centre, la même formule que cet article utilise depuis le début.
- Échantillonner un arc circulaire pour le dessiner avec autre chose.
Parcourir
anglepar petits pas et relier les points obtenus avecquadraticTo/lineToau lieu d'une primitive d'arc native, utile quand l'arc doit vaciller, s'amincir, ou autrement ne pas être un cercle parfait.
Le signal que vous êtes dans le mauvais article : si ce que vous avez
réellement est une position (x, y) (un point de contact, un glissement)
et que vous voulez en extraire un angle ou une distance, c'est la
conversion inverse, atan2 et la formule de distance, pas une autre
façon d'appeler cos/sin.
cos/sin ne répondent jamais qu'à « où est cet angle sur un cercle
unité » ; mettre à l'échelle par un rayon et ajouter un centre sont des
étapes séparées qui se trouvent vivre sur la même ligne, pas quelque
chose que sin et cos calculent eux-mêmes.



