Recomposed
Canvas

Du polaire au cartésien : ce que cos et sin calculent réellement

Oct 11, 2026 · 7 min read

Du polaire au cartésien : ce que cos et sin calculent réellement

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) et sin(angle) répondent à une seule question : sur un cercle de rayon 1 centré à l'origine, où angle atterrit-il, en tant que x et y. 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.

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.

pointAt

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 chemin A d'un arc est rendu par le moteur de tracé du navigateur qui exécute en interne exactement cette formule center + 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 que arc() de Canvas ; placer un point à la main avec CGPoint(x: center.x + radius * cos(angle), y: center.y + radius * sin(angle)) est la méthode standard pour dessiner tout ce pour quoi un Path n'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 + center est 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 champs x/y séparés.
  • CSS : conic-gradient() et clip-path: circle() sont des enveloppes déclaratives autour de la même mathématique ; animer un élément autour d'un chemin circulaire avec offset-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 angle en entrée, position en sortie, exactement pointOnCircle.
  • Menus radiaux et circulaires. Disposer N éléments de menu régulièrement autour d'un centre, c'est pointsAroundCircle ci-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/y directement.
  • 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 angle par petits pas et relier les points obtenus avec quadraticTo/lineTo au 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.

Keep reading

Related reads

Recevez les nouveaux articles par e-mail