Recomposed
Canvas

Bildschirm-Koordinatensysteme sind nicht kartesisch: Y zeigt nach unten, nicht nach oben

Oct 8, 2026 · 5 min read

Bildschirm-Koordinatensysteme sind nicht kartesisch: Y zeigt nach unten, nicht nach oben

Die Intuition

Eine kartesische Ebene aus dem Matheunterricht hat y, das nach oben zunimmt, und Winkel, die gegen den Uhrzeigersinn von positivem x aus verlaufen. Jede View, jedes Canvas und jeder DrawScope auf Android sieht aus wie dieselbe Ebene, mit denselben Formeln x = cx + r·cos(angle), aber das ist es nicht:

  • Der Ursprung liegt in der oberen linken Ecke, nicht in der Mitte.
  • y nimmt nach unten zu, nicht nach oben.
  • Ein positiver Winkel in cos/sin verläuft auf dem Bildschirm im Uhrzeigersinn, nicht gegen den Uhrzeigersinn, weil das Umkehren von y auch die Richtung umkehrt, in der eine Rotation gelesen wird.

An der Mathematik selbst ändert sich nichts. sin und cos wissen oder kümmern sich nicht darum, in welche Richtung y zeigt. Was sich ändert, ist, in welche Richtung auf deinem Bildschirm ein gegebener Winkel oder eine Formel landet, und genau das ist der Teil, bei dem das Muskelgedächtnis aus dem Matheunterricht in die falsche Richtung zeigt.

(0, 0) — column 0, row 0

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

Konkretes Beispiel: einen Punkt per Hand rotieren

// 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.

Gib derselben Rotationsformel auf dem Canvas einer View exakt dieselben Zahlen, und das Ergebnis landet im Spiegelbild von dem, wo es auf Millimeterpapier landen würde. Die Formel ist identisch; nur die Bedeutung eines positiven y hat sich darunter umgekehrt.

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

(x, y) = (0, 50)

Math

y increases ↑

Screen

y increases ↓

Winkelrichtung

Modifier.graphicsLayer { rotationZ = 90f } dreht ein Composable bei einem positiven Winkel im Uhrzeigersinn, dieselbe y-nach-unten-Logik wie in jedem anderen Fall hier: Der Rotationspunkt des Layers befindet sich in einem y-nach-unten-Raum, also liest sich ein positiver Winkel auch dort im Uhrzeigersinn. Das ist keine Sonderregel für graphicsLayer, es ist dieselbe eine Regel, die hier erneut auftaucht.

rotationZ: 45° — layer rotated 45 degrees

Screen

y increases ↓

Sweep

drawArc(startAngle = 0f, sweepAngle = 90f) verläuft im Uhrzeigersinn von 3 Uhr bis 6 Uhr. Derselbe Sweep von 0° bis 90° auf einer kartesischen Ebene verläuft von 3 Uhr bis 12 Uhr, gegen den Uhrzeigersinn, die entgegengesetzte visuelle Richtung für identische Zahlen.

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

Screen

y increases ↓

Ziehen (Dragging)

Ein Drag gibt dir nur eine Position, genauer gesagt einen Offset, keinen Winkel. Um daraus einen Winkel zu machen, braucht man atan2(dy, dx).

Man könnte stattdessen zu arctan(dy/dx) greifen, "Steigung über Strecke" ("rise over run"). Das bricht an zwei Stellen: dx = 0 führt zu einer Division durch null, und das Verhältnis allein kann (1, 1) nicht von (-1, -1) unterscheiden, da -1/-1 ebenfalls 1 ist, obwohl das entgegengesetzte Richtungen sind. atan2 nimmt dx und dy getrennt entgegen, statt sie vorab zu dividieren, sodass es jedes Vorzeichen sehen und alle vier Richtungen korrekt auflösen kann.

Das ist auch der klarste Auslöser dafür, wann man dazu greift: cos/sin gehen Winkel rein, Position raus (die Polarformel aus der Einleitung, x = cx + r·cos(angle)), und atan2 geht den anderen Weg, Position rein, Winkel raus. Ein Drag liefert dir eine Position, keinen Winkel, also gibt es nichts anderes zu berechnen als mit atan2.

Aus demselben Grund ist es das richtige Werkzeug für einen Drag-zum-Rotieren-Regler: Der Finger muss nicht exakt auf dem Ring landen, da atan2 nur die Richtung vom Mittelpunkt zum Finger liest, nicht die Entfernung. Derselbe Trick treibt auch jede Blickrichtungs-Logik an, etwa das Drehen eines Sprites passend zu seiner (dx, dy)-Geschwindigkeit pro Frame statt zu einer Fingerposition.

Auf Papier ergibt ein Drag nach oben einen positiven Winkel (gegen den Uhrzeigersinn von positivem x aus). Auf dem Bildschirm verringert ein Drag nach oben y, was das Vorzeichen umkehrt, das atan2 für dieselbe physische Geste zurückgibt.

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

Screen

drag the dot

Scroll

Eine scrollbare View macht das ganz konkret, ganz ohne Trigonometrie: Ein Kind an der Inhaltsposition y wird auf dem Bildschirm bei y - scrollState.value gerendert, wobei scrollState der ScrollState hinter Modifier.verticalScroll ist. Scrollt man nach unten, nimmt scrollState.value zu, und der Inhalt bewegt sich auf dem Bildschirm nach oben, Richtung kleineres y, derselbe y-nach-unten-Raum, den der ganze Beitrag bisher verwendet hat. Es gibt hier keine neue Konvention, nur die bekannte plus eine Subtraktion.

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

Lazy-Listen

LazyColumn wendet exakt dieselbe Subtraktion an, aber scrollState.value existiert dort nicht, weil eine Lazy-Liste niemals die Elemente misst, die sie noch nicht gezeichnet hat. Es gibt keine einzelne, von vornherein bekannte Gesamt-Inhaltshöhe, von der man abziehen könnte.

// 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

Die y - offset-Logik läuft weiterhin während des Layouts, sie wird nur pro sichtbarem Element relativ zu firstVisibleItemIndex berechnet statt gegen einen einzigen globalen Wert: Element 0 sitzt bei -firstItemOffsetPx, Element 1 bei item0Height - firstItemOffsetPx, und so weiter. Derselbe y-nach-unten-Raum, dieselbe Subtraktion, nur verankert am nächstgelegenen sichtbaren Element statt an einer vorausberechneten Gesamtsumme.

Das Grundprinzip

Dies ist ein linkshändiges 2D-Koordinatensystem (gleichbedeutend ein y-nach-unten- oder Raster-/Bildschirm-Koordinatensystem), im Gegensatz zur rechtshändigen, y-nach-oben-Konvention der Mathematik. Das Umkehren des Vorzeichens einer Achse kehrt die Händigkeit des gesamten Systems um, und genau deshalb liest sich ein positiver Winkel, der in einer Konvention gegen den Uhrzeigersinn verläuft, in der anderen im Uhrzeigersinn. Die trigonometrischen Identitäten haben sich nie geändert; die Achse, gegen die sie gemessen werden, hat sich geändert.

Anderswo: dasselbe Grundprinzip, anderes Framework

  • HTML5 Canvas: Ursprung oben links, y nach unten, rotate() ist bei positiven Werten im Uhrzeigersinn, identische Konvention zu Androids View/Canvas, aus demselben Grund (beide haben es von Raster-Bildkoordinaten übernommen, wo Zeile 0 die oberste Zeile ist).
  • SwiftUI / Core Animation: Der Zeichenraum von CGContext liegt oben links, y nach unten, genau wie Composes DrawScope, aber auch UIKits eigene CGPoint/CGRect-APIs setzen y-nach-unten voraus, was SwiftUI und Compose hier näher zueinander bringt, als jedes der beiden zur Mathematik steht.
  • Core Graphics / PDF hingegen: y nimmt nach oben zu, treu zur mathematischen Konvention, weil das Koordinatensystem von PDF von Druck-Layout abstammt, nicht von Raster-Scanning. Dieselbe CGContext-API-Familie spannt sich über beide Konventionen, je danach, in welche man zeichnet, was die mit Abstand häufigste Ursache für "mein PDF-Export ist auf dem Kopf"-Bugs ist.
  • OpenGL / Metal normalisierte Gerätekoordinaten: y nimmt nach oben zu, rechtshändig, wieder mathematische Konvention, und genau deshalb muss bei jeder Textur, die aus einer y-nach-unten-Bilddatei geladen wird, die v-Koordinate umgedreht werden, bevor sie auf dem Bildschirm richtig herum abgetastet wird.
  • Flutter: Offset/Canvas sind y-nach-unten, genauso wie Androids View-System, aus derselben Raster-Koordinaten-Abstammung, sodass eine Rotation oder atan2, die von einem Flutter-CustomPainter in einen Compose-DrawScope portiert wird, überhaupt keine Vorzeichenänderungen braucht, anders als beim Portieren aus mathematisch abgeleitetem OpenGL-Code.

atan2 taucht weit über diesen einen Drag-Fall hinaus auf: Regler, Pie-Menüs, Sprite-Blickrichtung, Joystick-Eingabe, Peilungsberechnungen, DSP-Phase und mehr. Der atan2/atan/atanh-Deep-Dive deckt die vollständige Liste ab.

Mentales Modell für die Praxis

Bevor du einer Rotations-, Winkel- oder Drag-Richtungsformel auf dem Bildschirm vertraust, frage dich, ob sie für eine y-nach-oben- oder eine y-nach-unten-Ebene abgeleitet wurde; die Formel ist in beiden Fällen identisch, nur ihre visuelle Richtung kehrt sich um.

Keep reading

Related reads

Neue Beiträge direkt in dein Postfach