Recomposed
Canvas

Polar para Cartesiano: O Que cos e sin Realmente Calculam

Oct 11, 2026 · 6 min read

Polar para Cartesiano: O Que cos e sin Realmente Calculam

A intuição

Uma fórmula como x = center.x + radius * cos(angle) parece estar fazendo algo ao próprio sistema de coordenadas, deslocando a origem, rotacionando os eixos, algo estrutural. Não está. Três coisas independentes, e muito mais simples, estão acontecendo, empilhadas na mesma expressão:

  • cos(angle) e sin(angle) respondem a uma única pergunta: em um círculo de raio 1 centrado na origem, onde angle cai, como um x e um y. É só isso que qualquer uma das duas funções calcula, um par de coordenadas para um ponto no círculo unitário.
  • radius * cos(angle) escala esse ponto do círculo unitário para fora, mesmo ângulo, círculo maior.
  • center.x + ... é uma translação simples, movendo todo o ponto escalado para que o círculo fique centrado onde você quiser, em vez de em (0, 0).

cos/sin só fazem a primeira parte. Elas não sabem nada sobre radius, não sabem nada sobre center, e nunca tocam no próprio sistema de coordenadas, os eixos, a origem, "cima" e "baixo" estão exatamente onde estavam antes de você chamá-las. A fórmula apenas executa rotação, depois escala, depois translação, uma após a outra, e é fácil interpretar erroneamente o resultado combinado como uma única operação em vez de três.

Exemplo concreto

Aqui está o padrão reduzido a só essa fórmula, adaptado de um helper real de DrawScope do Compose que posiciona pontos ao longo de um arco circular:

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)

Nada sobre center mudou nenhuma das duas respostas. Ele só é adicionado depois que o passo de rotação-e-escala já terminou.

Arraste os controles abaixo e observe a leitura: os valores de r·cos/r·sin são exatamente os dois cursos pontilhados do triângulo, e x/y são apenas center mais esses dois cursos.

pointAt

x: 186 y: 168.6

r·cos(40°) = 46 r·sin(40°) = 38.6 — angle 40 degrees, radius 60, point 186, 168.6

Mais casos: posicionando vários pontos de uma vez

A mesma fórmula responde "onde está o N-ésimo ponto" com a mesma facilidade que "onde está esse único ponto", percorrendo angle em passos uniformes em vez de chamá-la uma única vez:

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

Nada de novo está acontecendo matematicamente, é exatamente a mesma chamada de pointOnCircle de antes, só invocada count vezes com um angle diferente a cada vez. Essa é a forma geral por trás de ponteiros de relógio, menus radiais, partículas em um anel, e amostragem de pontos ao longo de um arco circular para conectar com curvas em vez de desenhar o arco diretamente.

O fundamental

Isso é conversão de polar para cartesiano: um ponto descrito como (radius, angle), distância e direção a partir de um centro, convertido no par (x, y) que uma tela realmente precisa. cos/sin são o passo de rotação da conversão; a multiplicação pelo raio e a soma do centro são passos separados que acompanham a mesma linha de código. Ir na direção contrária, de (x, y) de volta para (radius, angle), é um problema diferente com uma ferramenta diferente (atan2 para o ângulo, a fórmula da distância para o raio), não o inverso de chamar cos/sin de forma diferente.

Em outros lugares: mesmo fundamental, framework diferente

  • SVG: um <circle> ou o comando de path A de um arco é renderizado pelo motor de path do navegador percorrendo internamente exatamente essa fórmula center + radius * (cos, sin) para produzir a curva; d3.arc().centroid() chama a mesma conversão diretamente, usada constantemente para posicionar rótulos de gráficos de pizza e rosca no ponto médio de uma fatia.
  • HTML5 Canvas: CanvasRenderingContext2D.arc(x, y, radius, startAngle, endAngle) recebe o trio centro/raio/ângulo como argumentos separados e executa a conversão idêntica a cada frame para traçar a curva.
  • SwiftUI / Core Graphics: Path.addArc(center:radius:startAngle: endAngle:clockwise:) recebe exatamente o mesmo trio centro/raio/ângulo que o arc() do Canvas; posicionar um ponto manualmente com CGPoint(x: center.x + radius * cos(angle), y: center.y + radius * sin(angle)) é a forma padrão de desenhar qualquer coisa para a qual um Path não tem primitiva nativa, as marcas de um medidor, o mostrador de um relógio, um layout radial.
  • Motores de jogo (Unity, Godot, Unreal): new Vector2(Mathf.Cos(angle), Mathf.Sin(angle)) * radius + center é a forma padrão de fazer um objeto orbitar em torno de um ponto, os mesmos três passos, na mesma ordem, só escritos com um tipo de vetor em vez de campos x/y separados.
  • CSS: conic-gradient() e clip-path: circle() são invólucros declarativos em torno da mesma matemática; animar um elemento em torno de um caminho circular com offset-path: circle() é essa fórmula rodando a cada frame, só que calculada pelo navegador em vez do seu próprio código.

Casos extremos

Esquecer a multiplicação pelo raio. cos/sin retornam valores em [-1, 1], não pixels. x = center.x + cos(angle) compila sem problemas e parece plausível, já que tem a forma certa, center mais algo que depende do ângulo, mas traça um círculo de raio 1: visualmente, todo ponto colapsa para aproximadamente o mesmo lugar que center. Não há nenhum erro que aponte para o radius * faltante, só uma forma que silenciosamente se recusa a ser maior que um pixel.

Trocar qual eixo recebe cos e qual recebe sin. x = center.x + radius * sin(angle) combinado com y = center.y + radius * cos(angle) ainda traça um círculo perfeitamente correto, a forma nunca se quebra. O que se quebra é o significado de angle = 0: em vez de cair à direita do centro (a convenção deste post), ele cai abaixo dele, um deslocamento silencioso de 90° em relação ao que o resto do código assume que "ângulo zero" aponta.

Graus passados para uma função que só aceita radianos. kotlin.math.cos/sin (e seus equivalentes em praticamente qualquer linguagem) esperam , não graus. Passar 90 diretamente, querendo dizer "90 graus", na verdade pede cos/sin de 90 radianos, cerca de 14 voltas completas além do que você queria, e o resultado não cai nem perto do círculo que você esperava, sem nenhuma exceção para capturar o erro. Converta primeiro: Math.toRadians(90.0), ou a aritmética `degrees

  • PI / 180` que ele encapsula.

Para onde "cima" aponta se inverte, a fórmula não. Em um DrawScope/Canvas com y para baixo (o padrão do Android/Compose), aumentar angle percorre no sentido horário em vez do sentido anti-horário que a mesma fórmula produz em um plano de aula de matemática, com y para cima. cos/sin em si nunca mudam, só muda em que direção visual um ângulo positivo cai. O post sobre sistemas de coordenadas de tela cobre essa inversão em profundidade; a fórmula deste post é o caso x = cx + r·cos(angle) que a introdução daquele post já assume.

Quando recorrer a isso

Qualquer coisa em que a quantidade real que você está pensando é "a que distância, em que direção, a partir de um centro", e não um par x/y diretamente:

  • Mostradores de relógio e medidores. Ponteiros de hora/minuto, marcas de escala, agulhas de medidor: cada um é angle entrando, posição saindo, exatamente pointOnCircle.
  • Menus radiais e de pizza. Distribuir N itens de menu uniformemente em torno de um centro é pointsAroundCircle de antes, uma chamada por item.
  • Objetos orbitando ou circulando. Os pontos de um spinner de carregamento, um ícone de satélite circulando um planeta, uma partícula em um anel: atualize angle a cada frame e recalcule a posição, em vez de rastrear velocidade de x/y diretamente.
  • Posicionamento de rótulos e fatias de gráfico. O rótulo de um gráfico de pizza/rosca precisa ficar no ângulo médio de uma fatia, empurrado para fora até um certo raio a partir do centro, a mesma fórmula que este post vem usando o tempo todo.
  • Amostrar um arco circular para desenhá-lo com outra coisa. Percorrer angle em pequenos passos e conectar os pontos resultantes com quadraticTo/lineTo em vez de uma primitiva de arco nativa, útil quando o arco precisa oscilar, afinar, ou de alguma outra forma não ser um círculo perfeito.

O sinal de que você está no post errado: se o que você realmente tem é uma posição (x, y) (um toque, um arrasto) e você quer extrair um ângulo ou distância dela, essa é a conversão inversa, atan2 e a fórmula da distância, não uma forma diferente de chamar cos/sin.

cos/sin só respondem "onde está esse ângulo em um círculo unitário"; escalar por um raio e somar um centro são passos separados que por acaso vivem na mesma linha, não algo que sin e cos calculam por si mesmas.

Keep reading

Related reads

Receba novos posts no seu e-mail