Recomposed
Canvas

Les systèmes de coordonnées écran ne sont pas cartésiens : Y pointe vers le bas, pas vers le haut

Oct 8, 2026 · 6 min read

Les systèmes de coordonnées écran ne sont pas cartésiens : Y pointe vers le bas, pas vers le haut

L'intuition

Un plan cartésien de cours de maths a y qui augmente vers le haut et des angles qui balaient dans le sens antihoraire depuis le x positif. Chaque View, Canvas et DrawScope sur Android ressemble à ce même plan, avec les mêmes formules x = cx + r·cos(angle), mais ce n'en est pas un :

  • L'origine est le coin supérieur gauche, pas le centre.
  • y augmente vers le bas, pas vers le haut.
  • Un angle positif dans cos/sin balaie dans le sens horaire à l'écran, pas antihoraire, parce qu'inverser y inverse la direction dans laquelle la rotation se lit.

Rien ne change dans les maths. sin et cos ne savent pas, et ne se soucient pas, de la direction vers laquelle y pointe. Ce qui change, c'est la direction sur votre écran vers laquelle un angle ou une formule donnée vous mène, et c'est cette partie que la mémoire musculaire du cours de maths inverse.

(0, 0) — column 0, row 0

0
1
2
3
4
5
6
7
0
1
2
3
4
5
6
7

Exemple concret : faire tourner un point à la main

// Math-class Cartesian: rotating (10, 0) by +90° lands at (0, 10),
// "up and to the left" on paper, where y grows upward.
val angle = Math.toRadians(90.0)
val rotatedX = 10 * cos(angle)
val rotatedY = 10 * sin(angle)
// On screen (y grows downward instead), that same (0, 10) result
// is 10px *down* from center, not up. The formula didn't change —
// which way "up" points did.

Donnez exactement la même formule de rotation avec exactement les mêmes nombres à un Canvas de View, et le résultat atterrit dans l'image miroir de ce qu'il serait sur du papier millimétré. La formule est identique ; seule la signification d'un y positif s'est inversée dessous.

angle: 90° — rotated point at x 0, y 50

(x, y) = (0, 50)

Math

y increases ↑

Screen

y increases ↓

Direction de l'angle

Modifier.graphicsLayer { rotationZ = 90f } fait tourner un composable dans le sens horaire pour un angle positif, la même logique de y-vers-le-bas que dans tous les autres cas ici : le pivot de rotation de la couche se trouve dans un espace y-vers-le-bas, donc un angle positif s'y lit aussi dans le sens horaire. Ce n'est pas une règle spéciale pour graphicsLayer, c'est la même règle unique qui réapparaît.

rotationZ: 45° — layer rotated 45 degrees

Screen

y increases ↓

Balayage

drawArc(startAngle = 0f, sweepAngle = 90f) balaie dans le sens horaire de 3 heures à 6 heures. Le même balayage de 0° à 90° sur un plan cartésien va de 3 heures à midi, dans le sens antihoraire, la direction visuelle opposée pour des nombres identiques.

sweepAngle: 90° — arc swept 90 degrees from startAngle 0

Screen

y increases ↓

Le glissement

Un glissement ne vous donne qu'une position, plus précisément un décalage , pas un angle. Transformer cela en angle nécessite atan2(dy, dx).

Vous pourriez plutôt vous tourner vers arctan(dy/dx), « l'élévation sur la course ». Cela échoue à deux reprises : dx = 0 divise par zéro, et le ratio seul ne peut pas distinguer (1, 1) de (-1, -1), puisque -1/-1 donne aussi 1, même si ce sont des directions opposées. atan2 prend dx et dy séparément plutôt que de les diviser au préalable, il peut donc voir chaque signe et résoudre correctement les quatre directions.

C'est aussi le déclencheur le plus clair pour savoir quand y recourir : cos/sin fonctionnent angle en entrée, position en sortie (la formule polaire de l'introduction, x = cx + r·cos(angle)), et atan2 fonctionne dans l'autre sens, position en entrée, angle en sortie. Un glissement vous donne une position, pas un angle, donc il n'y a rien d'autre à calculer que atan2.

C'est le bon outil pour un bouton de rotation par glissement pour la même raison : le doigt n'a pas besoin de se poser exactement sur l'anneau, puisque atan2 ne lit que la direction du centre vers le doigt, pas la distance. Le même principe anime aussi toute logique de direction d'orientation, en faisant tourner un sprite pour correspondre à sa vélocité (dx, dy) par image plutôt qu'à une position de doigt.

Sur le papier, glisser vers le haut donne un angle positif (antihoraire depuis le x positif). À l'écran, glisser vers le haut diminue y, ce qui inverse le signe que atan2 retourne pour le même geste physique.

atan2(dy, dx): 0° — drag angle 0 degrees

Screen

drag the dot

Le défilement

Une vue défilable rend cela concret sans aucune trigonométrie : un enfant à la position de contenu y s'affiche à l'écran à y - scrollState.value, où scrollState est le ScrollState derrière Modifier.verticalScroll. Faites défiler vers le bas, scrollState.value augmente, et le contenu se déplace vers le haut à l'écran, vers des y plus petits, le même espace y-vers-le-bas que tout cet article utilise. Il n'y a aucune nouvelle convention ici, juste la convention habituelle plus une soustraction.

scrollState.value: 0px — scrolled 0 pixels

Screen

content y = 0
content y = 30
content y = 60
content y = 90
content y = 120
content y = 150

screen y = content y − scrollState.value

Les listes paresseuses

LazyColumn applique exactement la même soustraction, mais scrollState.value n'y existe pas, parce qu'une liste paresseuse ne mesure jamais les éléments qu'elle n'a pas encore dessinés. Il n'y a pas de hauteur de contenu totale unique à l'avance contre laquelle soustraire.

// ScrollState: every child is measured up front, so one cumulative
// pixel value is enough to place all of them.
val offsetPx = scrollState.value
 
// LazyListState: items off-screen are never measured, so there's no
// total content height to track. The offset is split into which item
// is first on screen, plus how far into that item you've scrolled.
val firstIndex = lazyListState.firstVisibleItemIndex
val firstItemOffsetPx = lazyListState.firstVisibleItemScrollOffset

La logique y - offset s'exécute toujours pendant la mise en page, simplement calculée par élément visible par rapport à firstVisibleItemIndex plutôt que contre une valeur globale unique : l'élément 0 se trouve à -firstItemOffsetPx, l'élément 1 à item0Height - firstItemOffsetPx, et ainsi de suite. Même espace y-vers-le-bas, même soustraction, simplement ancré à l'élément visible le plus proche plutôt qu'à un total précalculé.

Le fondamental

C'est un système de coordonnées 2D main gauche (de manière équivalente, un système de coordonnées y-vers-le-bas ou raster/écran), par opposition à la convention main droite, y-vers-le-haut des mathématiques. Inverser le signe d'un axe inverse la chiralité de tout le système, ce qui explique précisément pourquoi un angle positif qui se lit dans le sens antihoraire dans une convention se lit dans le sens horaire dans l'autre. Les identités trigonométriques n'ont jamais changé ; c'est l'axe contre lequel elles sont mesurées qui a changé.

Ailleurs : même fondamental, framework différent

  • HTML5 Canvas : origine en haut à gauche, y vers le bas, rotate() positif est dans le sens horaire, convention identique à View/Canvas d'Android, pour la raison identique (les deux ont hérité cela des coordonnées d'images raster, où la ligne 0 est la ligne du haut).
  • SwiftUI / Core Animation : l'espace de dessin de CGContext est en haut à gauche, y vers le bas, comme le DrawScope de Compose, mais les API CGPoint/CGRect propres d'UIKit supposent aussi y-vers-le-bas, ce qui rend SwiftUI et Compose plus proches l'un de l'autre ici que l'un ou l'autre ne l'est des mathématiques.
  • Core Graphics / PDF, en revanche : y augmente vers le haut, fidèle à la convention mathématique, parce que le système de coordonnées du PDF descend de la mise en page d'impression, pas du balayage raster. La même famille d'API CGContext chevauche les deux conventions selon celle dans laquelle vous dessinez, ce qui est la source la plus courante des bugs « mon export PDF est à l'envers ».
  • Coordonnées de périphérique normalisées OpenGL / Metal : y augmente vers le haut, main droite, convention mathématique à nouveau, ce qui explique précisément pourquoi chaque texture chargée depuis un fichier image y-vers-le-bas a besoin que sa coordonnée v soit inversée avant d'échantillonner correctement à l'écran.
  • Flutter : Offset/Canvas sont y-vers-le-bas, comme le système View d'Android, pour la même filiation de coordonnées raster, donc une rotation ou un atan2 porté d'un CustomPainter Flutter vers un DrawScope Compose ne nécessite aucun changement de signe, contrairement à en porter un depuis du code OpenGL dérivé des mathématiques.

atan2 apparaît bien au-delà de ce seul cas de glissement : boutons, menus circulaires, orientation de sprite, entrée de joystick, calculs de relèvement, phase DSP, et plus encore. L'analyse approfondie atan2/atan/atanh couvre la liste complète.

Modèle mental à utiliser réellement

Avant de faire confiance à une formule de rotation, d'angle ou de direction de glissement à l'écran, demandez-vous si elle a été dérivée pour un plan y-vers-le-haut ou y-vers-le-bas ; la formule est identique dans les deux cas, seule sa direction visuelle s'inverse.

Keep reading

Related reads

Recevez les nouveaux articles par e-mail