Matemática da Visão Computacional: Rotação, Translação e Escala com Python

Toda manipulação geométrica de uma imagem digital se resume, no fundo, a uma multiplicação de matrizes. Rotacionar, escalar, transladar, cisalhar. Cada uma dessas operações pode ser descrita como uma transformação linear aplicada às coordenadas dos pixels. Entender a matemática da visão computacional por trás dessas transformações é o que separa quem usa funções prontas do OpenCV de quem realmente entende o que está acontecendo.

Neste artigo, vamos construir passo a passo o ferramental matemático que sustenta o image warping. Partimos do problema concreto (por que matrizes 2×2 não conseguem representar translação?), derivamos a solução (coordenadas homogêneas e matrizes 3×3), e demonstramos cada transformação afim com implementação do zero em Python.

💻

Código do Artigo

Acesse o código-fonte deste artigo gratuitamente.

Informe seu email para acessar o código:

✓ Seu código está pronto!

Abrir no Google Colab →

Transformações de Domínio vs. Transformações de Range

Antes de entrar nas matrizes, é importante distinguir dois tipos fundamentais de operação sobre imagens.

Uma imagem digital pode ser modelada como uma função $f(x, y)$ que associa a cada par de coordenadas $(x, y)$ um valor de intensidade. Quando alteramos os valores de intensidade (o range da função), estamos fazendo filtragem (image filtering). Realce de bordas, suavização, equalização de histograma: todas operam sobre $f$ sem mover os pixels de lugar.

Quando alteramos as coordenadas (o domínio da função), estamos fazendo deformação (image warping). A função de transformação $T$ mapeia cada ponto $(x, y)$ para uma nova posição $(x', y')$ . É aqui que entram scaling, rotação, translação e cisalhamento.

Infográfico comparando Image Filtering e Image Warping em visão computacional: filtering altera valores de intensidade no range da imagem enquanto warping altera coordenadas no domínio

Este artigo trata exclusivamente de transformações de domínio. Para entender como uma imagem é formada antes de ser transformada, veja o artigo sobre os fundamentos da formação da imagem na visão computacional.

O Limite das Matrizes 2×2

Considere uma imagem como uma coleção de vetores de coordenadas. Cada pixel na posição $(x, y)$ pode ser representado como um vetor coluna. Uma transformação linear sobre esse vetor é uma multiplicação por uma matriz $A$ de dimensão 2×2:

$\begin{bmatrix} x' \\ y' \end{bmatrix} = \begin{bmatrix} a_{11} & a_{12} \\ a_{21} & a_{22} \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix}$

Com essa estrutura, a escala funciona perfeitamente. Para expandir a imagem por um fator $S_x$ na horizontal e $S_y$ na vertical:

$\begin{bmatrix} x' \\ y' \end{bmatrix} = \begin{bmatrix} S_x & 0 \\ 0 & S_y \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix}$

A rotação também cabe nessa estrutura. Para girar um ponto por um ângulo $\theta$ em torno da origem, basta derivar as relações trigonométricas. Um ponto $(x, y)$ pode ser escrito em coordenadas polares como $x = r\cos\alpha$ e $y = r\sin\alpha$ , onde $r$ é a distância à origem e $\alpha$ é o ângulo com o eixo horizontal. Após uma rotação de $\theta$ , o novo ângulo é $\alpha + \theta$ :

$x' = r\cos(\alpha + \theta) = r\cos\alpha\cos\theta - r\sin\alpha\sin\theta = x\cos\theta - y\sin\theta$

$y' = r\sin(\alpha + \theta) = r\cos\alpha\sin\theta + r\sin\alpha\cos\theta = x\sin\theta + y\cos\theta$

Em forma matricial:

$\begin{bmatrix} x' \\ y' \end{bmatrix} = \begin{bmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix}$

Até aqui, matrizes 2×2 resolvem o problema. Mas considere agora a translação: deslocar toda a imagem por $t_x$ unidades na horizontal e $t_y$ na vertical.

$x' = x + t_x$

$y' = y + t_y$

A pergunta é: existe uma matriz 2×2 que produza esse resultado? A resposta é não. Uma multiplicação de matriz 2×2 por um vetor sempre produz combinações lineares das componentes do vetor. O resultado será sempre da forma $x' = a_{11}x + a_{12}y$ . Não há como introduzir uma constante aditiva $t_x$ dentro desse framework. A translação não é uma transformação linear no espaço bidimensional.

Precisamos de algo a mais.

Coordenadas Homogêneas

A solução vem de uma ideia central da geometria projetiva: adicionar uma dimensão extra ao espaço de trabalho. Um ponto $(x, y)$ no plano é representado em coordenadas homogêneas como uma tripla:

$\tilde{P} = (x, y, 1)$

A terceira coordenada, por convenção, vale 1. Mas a definição é mais geral: qualquer tripla $(kx, ky, k)$ com $k \neq 0$ representa o mesmo ponto $(x, y)$ . Para recuperar as coordenadas cartesianas, basta dividir as duas primeiras componentes pela terceira:

$(x, y) = \left(\frac{\tilde{x}}{\tilde{w}}, \frac{\tilde{y}}{\tilde{w}}\right)$

Geometricamente, imagine o plano cartesiano original posicionado na altura $z = 1$ de um espaço tridimensional. Qualquer reta que parta da origem e passe por um ponto desse plano define uma classe de equivalência: todos os pontos sobre essa reta (exceto a origem) representam a mesma coordenada homogênea.

Por exemplo, o ponto $(2, 3)$ se torna $(2, 3, 1)$ em coordenadas homogêneas. Os vetores $(4, 6, 2)$ , $(6, 9, 3)$ e $(2k, 3k, k)$ são todos equivalentes, pois divididos pela terceira coordenada retornam $(2, 3)$ .

Essa “dimensão extra” pode parecer artificial, mas é exatamente o que precisamos para representar a translação como multiplicação matricial. Para quem quiser se aprofundar na teoria, Szeliski trata o tema em detalhe no capítulo 2 de Computer Vision: Algorithms and Applications.

A Matemática da Visão Computacional: As Quatro Transformações Afins

Com coordenadas homogêneas, todas as transformações básicas de imagem podem ser expressas de forma unificada como matrizes 3×3. O vetor de entrada passa a ser $(x, y, 1)^T$ e o resultado é $(x', y', 1)^T$ .

Translação

A translação, que era impossível com matrizes 2×2, agora se resolve naturalmente:

$\begin{bmatrix} x' \\ y' \\ 1 \end{bmatrix} = \begin{bmatrix} 1 & 0 & t_x \\ 0 & 1 & t_y \\ 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} x \\ y \\ 1 \end{bmatrix}$

Fazendo a multiplicação linha a linha: $x' = x + t_x \cdot 1 = x + t_x$ e $y' = y + t_y \cdot 1 = y + t_y$ . A constante aditiva aparece porque a terceira componente do vetor é sempre 1. A última linha $(0, 0, 1)$ garante que essa componente se preserva.

No notebook, aplicamos $t_x = 20$ e $t_y = 10$ sobre uma grade regular:

Resultado da translação de uma grade regular com deslocamento horizontal e vertical usando mapeamento inverso em Python

A imagem se desloca para a direita e para baixo, sem qualquer distorção. As regiões que ficam fora do campo de visão original aparecem em preto.

Scaling (Escala)

$T_{escala} = \begin{bmatrix} S_x & 0 & 0 \\ 0 & S_y & 0 \\ 0 & 0 & 1 \end{bmatrix}$

A escala multiplica as coordenadas pelos fatores $S_x$ e $S_y$ . Com $S_x > 1$ , a imagem se expande horizontalmente. Com $S_y < 1$ , comprime verticalmente.

Rotação

$T_{rotacao} = \begin{bmatrix} \cos\theta & -\sin\theta & 0 \\ \sin\theta & \cos\theta & 0 \\ 0 & 0 & 1 \end{bmatrix}$

A rotação preserva distâncias e ângulos. A matriz $R$ é ortogonal ( $R^{-1} = R^T$ ) e tem determinante igual a 1. Rotações sucessivas podem ser combinadas por multiplicação de matrizes.

Cisalhamento (Shear)

O cisalhamento desloca as coordenadas proporcionalmente à posição no eixo perpendicular. O cisalhamento horizontal tem fator na posição $(0,1)$ da matriz e desloca linhas ao longo de x. O cisalhamento vertical tem fator na posição $(1,0)$ e desloca colunas ao longo de y. Em ambos os casos, retângulos se transformam em paralelogramos, e retas paralelas permanecem paralelas.

Propriedades das Transformações Afins

Toda transformação cuja matriz 3×3 tem a última linha igual a $(0, 0, 1)$ é uma transformação afim. Essas transformações compartilham três propriedades fundamentais:

A origem não necessariamente mapeia para a origem. A translação é o exemplo mais direto: o ponto $(0, 0)$ vai para $(t_x, t_y)$ .
Retas mapeiam para retas. Uma linha reta na imagem original continua sendo reta após a transformação. Nunca se curva.
Retas paralelas permanecem paralelas. Duas linhas paralelas antes da transformação continuam paralelas depois. Essa propriedade é o que distingue transformações afins das projetivas (homografias), onde retas paralelas podem convergir.

Essas propriedades têm consequências práticas diretas. Se você aplica uma transformação afim a uma imagem contendo um retângulo, o resultado será no máximo um paralelogramo. Se o resultado for um trapézio (lados não paralelos), a transformação não é afim.

Para uma exploração aprofundada de transformações projetivas e do modelo de câmera pinhole, veja o artigo sobre a geometria da formação de imagens e matrizes de transformação.

Composição de Transformações

Uma das maiores vantagens de representar todas as transformações como matrizes 3×3 é a possibilidade de compor operações por multiplicação matricial. Se você precisa aplicar uma escala seguida de uma rotação, basta multiplicar as duas matrizes:

$T_{composta} = T_{rotacao} \cdot T_{escala}$

A ordem de leitura é da direita para a esquerda: primeiro aplica-se $T_{escala}$ , depois $T_{rotacao}$ . A multiplicação de matrizes não é comutativa. Trocar a ordem produz um resultado diferente.

Resultado da composição de scaling seguido de rotação aplicada a uma grade regular em Python

Computacionalmente, isso é muito eficiente. Em vez de percorrer todos os pixels da imagem múltiplas vezes (uma para cada operação), você calcula a matriz composta uma única vez e faz uma única passagem.

Rotação em torno de um ponto arbitrário

A composição resolve um problema prático importante. A rotação padrão gira em torno da origem $(0, 0)$ , que na imagem corresponde ao canto superior esquerdo. Para girar em torno do centro da imagem, compomos três operações:

Transladar o centro da imagem para a origem
Aplicar a rotação
Transladar de volta

$T = T_{+centro} \cdot T_{rotacao} \cdot T_{-centro}$

O resultado é uma única matriz 3×3 que executa as três operações de uma só vez:

Comparação lado a lado entre imagem original e rotação de 45 graus em torno do centro usando composição de matrizes em Python

Compare com a rotação simples (em torno da origem) mostrada anteriormente. Aqui a imagem gira sobre si mesma, sem deslocar.

Mapeamento Inverso e Interpolação

Na implementação, há uma decisão técnica importante. O mapeamento direto percorre cada pixel $(x, y)$ da imagem original e calcula onde ele deve ir na imagem de saída. O problema é que isso gera buracos: dois pixels podem mapear para o mesmo destino (sobreposição), e algumas posições da saída podem não receber nenhum pixel.

Infográfico comparando Forward Mapping e Inverse Mapping: o mapeamento direto gera buracos na imagem de destino enquanto o inverso garante que todos os pixels sejam preenchidos

O mapeamento inverso resolve isso. Para cada pixel $(x', y')$ da imagem de saída, calcula-se a posição correspondente na imagem original usando a inversa da transformação:

$\begin{bmatrix} x \\ y \\ 1 \end{bmatrix} = T^{-1} \begin{bmatrix} x' \\ y' \\ 1 \end{bmatrix}$

Como a posição $(x, y)$ resultante pode ter coordenadas fracionárias (um pixel da saída pode corresponder a um ponto “entre” pixels na entrada), precisamos de um método de interpolação.

Infográfico comparando os três métodos de interpolação em processamento de imagens: vizinho mais próximo, bilinear e bicúbica, com suas fórmulas e trade-offs de qualidade versus velocidade

A interpolação por vizinho mais próximo arredonda para o pixel inteiro mais perto. É rápida, mas produz bordas serrilhadas. A interpolação bilinear pondera os quatro vizinhos mais próximos usando as distâncias fracionárias como pesos, produzindo transições mais suaves. A interpolação bicúbica pondera uma vizinhança de 4×4 pixels e preserva melhor os detalhes finos, ao custo de maior processamento.

Essas mesmas transformações matriciais são a base da calibração de câmeras com OpenCV e Python, onde os parâmetros intrínsecos e extrínsecos da câmera são representados como matrizes que convertem coordenadas do mundo real para coordenadas de pixel.

Takeaways

Matrizes 2×2 representam scaling e rotação, mas não translação. A translação exige somar uma constante, o que foge do escopo da multiplicação matricial em duas dimensões.
Coordenadas homogêneas resolvem essa limitação. Ao adicionar uma terceira coordenada (sempre igual a 1), a translação se torna uma multiplicação por uma matriz 3×3.
Toda transformação afim tem última linha $(0, 0, 1)$ . Isso garante que retas mapeiam para retas e paralelas permanecem paralelas.
Composição de transformações é multiplicação de matrizes. Isso permite combinar múltiplas operações em uma única matriz, com uma única passagem pelos pixels.
Mapeamento inverso evita buracos na imagem de saída. Combinado com interpolação bilinear, produz resultados suaves sem artefatos de aliasing.

Matemática da Visão Computacional: Rotação, Translação e Escala com Python

Introdução ao PyTorch: Como Treinar sua Primeira CNN

Carlos Melo

Relacionado Artigos

Introdução ao PyTorch: Como Treinar sua Primeira CNN

Quanto ganha um Engenheiro de Visão Computacional

Analisando uma Tomografia 3D com Python

Faster R-CNN: O Paper Que Mudou a Detecção de Objetos

Transfer Learning com PyTorch na Prática

Deixe um comentário Cancelar resposta

Mais Populares

ORB-SLAM 3: Tutorial Completo para Mapeamento 3D e Localização em Tempo Real

Vision Transformer (ViT): Implementação com Python

Introdução ao MediaPipe e Pose Estimation

O Que é Amostragem e Quantização no Processamento de Imagens

Processamento de Nuvens de Pontos com Open3D e Python

Como Tratar Dados Ausentes com Pandas

Como usar o DALL-E 2 para gerar imagens a partir de textos

Introdução ao MediaPipe e Pose Estimation

ORB-SLAM 3: Tutorial Completo para Mapeamento 3D e Localização em Tempo Real

Como Analisar Ações da Bolsa com Python

Setembro Amarelo: Análise do Suicídio no Brasil, com Data Science

Como Aprender Data Science?

Qual o Cenário de Data Science no Brasil hoje?