Recomposed
Canvas

Sistemas de Coordenadas de Tela Não São Cartesianos: Y Aponta para Baixo, Não para Cima

Oct 8, 2026 · 6 min read

Sistemas de Coordenadas de Tela Não São Cartesianos: Y Aponta para Baixo, Não para Cima

A intuição

Um plano cartesiano da aula de matemática tem y aumentando para cima e ângulos varrendo no sentido anti-horário a partir do x positivo. Toda View, Canvas e DrawScope no Android parece esse mesmo plano, com as mesmas fórmulas x = cx + r·cos(angle), mas não é:

  • A origem é o canto superior esquerdo, não o centro.
  • y aumenta para baixo, não para cima.
  • Um ângulo positivo em cos/sin varre no sentido horário na tela, não anti-horário, porque inverter y inverte a direção em que a rotação é lida.

Nada na matemática muda. sin e cos não sabem nem se importam para qual lado y aponta. O que muda é em qual direção na sua tela um determinado ângulo ou fórmula te leva, e é essa parte que a memória muscular da aula de matemática entende ao contrário.

(0, 0) — column 0, row 0

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

Exemplo concreto: girando um ponto manualmente

// Cartesiano da aula de matemática: girar (10, 0) em +90° cai em (0, 10),
// "para cima e para a esquerda" no papel, onde y cresce para cima.
val angle = Math.toRadians(90.0)
val rotatedX = 10 * cos(angle)
val rotatedY = 10 * sin(angle)
// Na tela (onde y cresce para baixo), esse mesmo resultado (0, 10)
// fica 10px *abaixo* do centro, não acima. A fórmula não mudou —
// o que mudou foi para qual lado "para cima" aponta.

Aplique exatamente a mesma fórmula de rotação com exatamente os mesmos números em um Canvas de uma View, e o resultado cai na imagem espelhada de onde cairia no papel quadriculado. A fórmula é idêntica; só o significado de um y positivo se inverteu por baixo dela.

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

(x, y) = (0, 50)

Math

y increases ↑

Screen

y increases ↓

Direção do ângulo

Modifier.graphicsLayer { rotationZ = 90f } gira um composable no sentido horário para um ângulo positivo, a mesma lógica de y para baixo de todos os outros casos aqui: o pivô de rotação da camada fica em um espaço com y para baixo, então um ângulo positivo também é lido como horário ali. Não é uma regra especial para graphicsLayer, é a mesma regra única aparecendo de novo.

rotationZ: 45° — layer rotated 45 degrees

Screen

y increases ↓

Varredura

drawArc(startAngle = 0f, sweepAngle = 90f) varre no sentido horário das 3 horas às 6 horas. A mesma varredura de 0° a 90° em um plano cartesiano vai das 3 horas às 12 horas, no sentido anti-horário, a direção visual oposta para os mesmos números idênticos.

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

Screen

y increases ↓

Arrastando

Um arrasto só te dá uma posição, especificamente um deslocamento , não um ângulo. Transformar isso em um ângulo requer atan2(dy, dx).

Você pode tentar usar arctan(dy/dx) em vez disso, "subida sobre avanço". Isso falha de duas formas: dx = 0 divide por zero, e a razão isolada não consegue distinguir (1, 1) de (-1, -1), já que -1/-1 também é 1, mesmo essas sendo direções opostas. atan2 recebe dx e dy separadamente em vez de dividi-los antecipadamente, então consegue ver cada sinal e resolver corretamente as quatro direções.

Esse é também o gatilho mais claro para quando recorrer a ele: cos/sin vão ângulo entra, posição sai (a fórmula polar da introdução, x = cx + r·cos(angle)), e atan2 vai no sentido contrário, posição entra, ângulo sai. Um arrasto te entrega uma posição, não um ângulo, então não há nada a calcular além de usar atan2.

É a ferramenta certa para um botão de arrastar-para-girar pela mesma razão: o dedo não precisa cair exatamente sobre o anel, já que atan2 só lê a direção do centro até o dedo, não a distância. O mesmo truque também guia qualquer lógica de direção de face, girando um sprite para coincidir com sua velocidade (dx, dy) por quadro, em vez de uma posição de dedo.

No papel, arrastar para cima dá um ângulo positivo (anti-horário a partir do x positivo). Na tela, arrastar para cima diminui y, o que inverte o sinal que atan2 retorna para o mesmo gesto físico.

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

Screen

drag the dot

Rolagem

Uma view rolável deixa isso concreto sem nenhuma trigonometria: um filho na posição de conteúdo y é renderizado na tela em y - scrollState.value, onde scrollState é o ScrollState por trás de Modifier.verticalScroll. Role para baixo, scrollState.value aumenta, e o conteúdo se move para cima na tela, em direção a y menores, o mesmo espaço com y para baixo que o post todo vem usando. Não há nenhuma convenção nova aqui, só a familiar mais uma subtração.

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

Listas lazy

LazyColumn aplica exatamente a mesma subtração, mas scrollState.value não existe lá, porque uma lista lazy nunca mede os itens que ainda não desenhou. Não há uma altura total de conteúdo previamente calculada para subtrair.

// ScrollState: todo filho é medido antecipadamente, então um único
// valor acumulado de pixels é suficiente para posicionar todos eles.
val offsetPx = scrollState.value
 
// LazyListState: itens fora da tela nunca são medidos, então não há
// uma altura total de conteúdo para rastrear. O offset é dividido em
// qual item é o primeiro na tela, mais o quanto você já rolou dentro
// dele.
val firstIndex = lazyListState.firstVisibleItemIndex
val firstItemOffsetPx = lazyListState.firstVisibleItemScrollOffset

A lógica de y - offset ainda ocorre durante o layout, só é calculada por item visível em relação a firstVisibleItemIndex em vez de contra um valor global único: o item 0 fica em -firstItemOffsetPx, o item 1 em item0Height - firstItemOffsetPx, e assim por diante. Mesmo espaço com y para baixo, mesma subtração, só ancorada no item visível mais próximo em vez de em um total pré-calculado.

O fundamento

Isso é um sistema de coordenadas 2D canhoto (equivalentemente, um sistema com y para baixo, ou de coordenadas raster/tela), em contraste com a convenção destro, com y para cima, da matemática. Inverter o sinal de um eixo inverte a quiralidade do sistema inteiro, e é exatamente por isso que um ângulo positivo que é lido como anti-horário em uma convenção é lido como horário na outra. As identidades trigonométricas nunca mudaram; o eixo contra o qual são medidas, sim.

Em outros lugares: mesmo fundamento, framework diferente

  • HTML5 Canvas: origem no canto superior esquerdo, y para baixo, rotate() positivo é horário, convenção idêntica à View/Canvas do Android, pela mesma razão (ambos herdaram isso das coordenadas de imagens raster, onde a linha 0 é a linha superior).
  • SwiftUI / Core Animation: o espaço de desenho do CGContext é superior esquerdo, y para baixo, assim como o DrawScope do Compose, mas as próprias APIs CGPoint/CGRect do UIKit também assumem y para baixo, deixando SwiftUI e Compose mais próximos entre si aqui do que qualquer um dos dois está da matemática.
  • Core Graphics / PDF, em contraste: y aumenta para cima, fiel à convenção matemática, porque o sistema de coordenadas do PDF descende do layout de impressão, não da varredura raster. A mesma família de APIs CGContext se divide entre as duas convenções dependendo de qual delas você está desenhando, o que é a fonte mais comum de bugs do tipo "minha exportação em PDF está de cabeça para baixo".
  • Coordenadas de dispositivo normalizadas do OpenGL / Metal: y aumenta para cima, destro, convenção matemática de novo, o que é exatamente por que toda textura carregada de um arquivo de imagem com y para baixo precisa ter sua coordenada v invertida antes de amostrar corretamente na tela.
  • Flutter: Offset/Canvas têm y para baixo, assim como o sistema View do Android, pela mesma linhagem de coordenadas raster, então uma rotação ou atan2 portado de um CustomPainter do Flutter para um DrawScope do Compose não precisa de nenhuma mudança de sinal, diferente de portar um de código OpenGL derivado da matemática.

atan2 aparece muito além deste único caso de arrasto: botões, menus circulares, direção de face de sprites, entrada de joystick, cálculos de rumo, fase de DSP, e mais. O mergulho profundo em atan2/atan/atanh cobre a lista completa.

Modelo mental para usar de fato

Antes de confiar em uma fórmula de rotação, ângulo ou direção de arrasto na tela, pergunte se ela foi derivada para um plano com y para cima ou com y para baixo; a fórmula é idêntica de qualquer forma, só sua direção visual se inverte.

Keep reading

Related reads

Receba novos posts no seu e-mail