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)esin(angle)respondem a uma única pergunta: em um círculo de raio 1 centrado na origem, ondeanglecai, como umxe umy. É 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.
- →Screen Coordinate Systems Aren't CartesianWhy the same cos/sin formula sweeps clockwise on a y-down screen instead of counterclockwise, plus atan2 for turning a drag into an angle.
- →atan, atan2, and atanhThe reverse direction: going from an (x, y) position back to an angle, and why atan alone can't do it.
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.
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 pathAde um arco é renderizado pelo motor de path do navegador percorrendo internamente exatamente essa fórmulacenter + 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 oarc()do Canvas; posicionar um ponto manualmente comCGPoint(x: center.x + radius * cos(angle), y: center.y + radius * sin(angle))é a forma padrão de desenhar qualquer coisa para a qual umPathnã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 camposx/yseparados. - CSS:
conic-gradient()eclip-path: circle()são invólucros declarativos em torno da mesma matemática; animar um elemento em torno de um caminho circular comoffset-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 é
angleentrando, posição saindo, exatamentepointOnCircle. - Menus radiais e de pizza. Distribuir N itens de menu uniformemente
em torno de um centro é
pointsAroundCirclede 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
anglea cada frame e recalcule a posição, em vez de rastrear velocidade dex/ydiretamente. - 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
angleem pequenos passos e conectar os pontos resultantes comquadraticTo/lineToem 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.



