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.
yaugmente vers le bas, pas vers le haut.- Un angle positif dans
cos/sinbalaie dans le sens horaire à l'écran, pas antihoraire, parce qu'inverseryinverse 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
- →Polar to Cartesian: What cos and sin Are Actually ComputingThe x = cx + r·cos(angle) formula this post's rotation and sweep examples build on, and why the same formula sweeps clockwise instead of counterclockwise once y points down.
- →atan, atan2, and atanhThe reverse direction of the drag case below: turning a (dx, dy) position back into an angle, and why atan alone can't do it.
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
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.firstVisibleItemScrollOffsetLa 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,
yvers le bas,rotate()positif est dans le sens horaire, convention identique àView/Canvasd'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
CGContextest en haut à gauche,yvers le bas, comme leDrawScopede Compose, mais les APICGPoint/CGRectpropres d'UIKitsupposent 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 :
yaugmente 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'APICGContextchevauche 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 :
yaugmente 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éevsoit inversée avant d'échantillonner correctement à l'écran. - Flutter :
Offset/Canvassont y-vers-le-bas, comme le systèmeViewd'Android, pour la même filiation de coordonnées raster, donc une rotation ou unatan2porté d'unCustomPainterFlutter vers unDrawScopeCompose 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.



