Introducción

Las matrices de rotación son la base de cualquier motor gráfico, simulación física o proceso de visión por computadora. Permiten girar puntos, vectores o sistemas completos alrededor de un origen sin perder la longitud ni la ortogonalidad. En este artículo profundizamos en los fundamentos matemáticos de las rotaciones en 2 dimensiones (2D) y 3 dimensiones (3D), y presentamos implementaciones prácticas con NumPy en Python.

Rotación en 2D

Concepto matemático

Una rotación en el plano XY se describe mediante un ángulo θ medido en sentido antihorario. La matriz de rotación 2×2 es:

R(θ) = [[cosθ, -sinθ],
        [sinθ,  cosθ]]

Esta matriz es ortogonal (R·Rᵀ = I) y tiene determinante 1, lo que garantiza que la transformación conserva áreas y longitudes.

Implementación en Python

Usaremos numpy para crear la matriz y aplicar la rotación a un conjunto de puntos.

import numpy as np
def rot2d(theta_deg):
    """Devuelve la matriz de rotación 2D para un ángulo en grados."""
    theta = np.radians(theta_deg)
    c, s = np.cos(theta), np.sin(theta)
    return np.array([[c, -s],
                     [s,  c]])
# Ejemplo: rotar un triángulo
points = np.array([[0, 0], [1, 0], [0, 1]])  # vértices del triángulo
R = rot2d(45)                     # rotar 45°
rotated = points @ R.T            # (N,2) · (2,2)ᵀ
print(rotated)

Salida típica:

[[0.         0.        ]
 [0.70710678 0.70710678]
 [-0.70710678 0.70710678]]

Rotación en 3D

Ejes básicos

En 3D disponemos de tres ejes ortogonales: X, Y y Z. Cada uno tiene su propia matriz de rotación elemental:

• Rotación alrededor de X (pitch):

  Rₓ(θ) = [[1, 0, 0],
          [0, cosθ, -sinθ],
          [0, sinθ,  cosθ]]

• Rotación alrededor de Y (yaw):

  Rᵧ(θ) = [[ cosθ, 0, sinθ],
          [0, 1, 0],
          [-sinθ, 0, cosθ]]

• Rotación alrededor de Z (roll):

  R𝓏(θ) = [[cosθ, -sinθ, 0],
          [sinθ,  cosθ, 0],
          [0, 0, 1]]

Combinación de rotaciones

Para rotaciones arbitrarias se multiplican las matrices en el orden deseado (recordar que la multiplicación no es conmutativa). Por ejemplo, una rotación yaw → pitch → roll se representa como:

R = R𝓏(roll) @ Rₓ(pitch) @ Rᵧ(yaw)

Esta convención es la más usada en gráficos 3D y robótica.

Implementación en Python (3D)

def rot_x(theta_deg):
    t = np.radians(theta_deg)
    c, s = np.cos(t), np.sin(t)
    return np.array([[1, 0, 0],
                     [0, c, -s],
                     [0, s,  c]])
def rot_y(theta_deg):
    t = np.radians(theta_deg)
    c, s = np.cos(t), np.sin(t)
    return np.array([[ c, 0, s],
                     [ 0, 1, 0],
                     [-s, 0, c]])
def rot_z(theta_deg):
    t = np.radians(theta_deg)
    c, s = np.cos(t), np.sin(t)
    return np.array([[c, -s, 0],
                     [s,  c, 0],
                     [0,  0, 1]])
# Rotación compuesta: yaw=30°, pitch=45°, roll=60°
R = rot_z(60) @ rot_x(45) @ rot_y(30)
# Rotar un cubo unitario
cube = np.array([[-0.5, -0.5, -0.5],
                 [ 0.5, -0.5, -0.5],
                 [ 0.5,  0.5, -0.5],
                 [-0.5,  0.5, -0.5],
                 [-0.5, -0.5,  0.5],
                 [ 0.5, -0.5,  0.5],
                 [ 0.5,  0.5,  0.5],
                 [-0.5,  0.5,  0.5]])
rotated_cube = cube @ R.T
print(rotated_cube)

Comparativa 2D ↔ 3D

Mejores Prácticas y Optimización

• Pre‑calcular seno y coseno cuando el ángulo es constante dentro de un bucle.
• Utilizar np.dot o el operador @ en vez de bucles Python nativos.
• Para animaciones en tiempo real, almacenar la matriz de rotación como float32 para reducir el tráfico de memoria.
• En 3D, considerar cuaterniones para interpolación suave (slerp) y evitar gimbal lock.
• Si la aplicación requiere cientos de miles de rotaciones por cuadro, evaluar SIMD vía numba o torch.

Solución de Problemas Comunes (Troubleshooting)

1. Rotación invertida

Los sistemas de coordenadas pueden ser derecha o izquierda. Verifique la convención de su entorno (OpenGL usa eje Z positivo hacia fuera, mientras que DirectX usa el opuesto).

2. Gimbal lock

Ocurre cuando dos ejes de rotación se alinean (por ejemplo, pitch = ±90°). Solución: cambiar a cuaterniones o usar una parametrización basada en matrices de dirección.

3. Pérdida de precisión

Al encadenar muchas rotaciones, los errores de redondeo pueden acumularse. Normalice la matriz resultante periódicamente (R = R / np.linalg.norm(R, axis=0)).

Casos de Uso del Mundo Real

• Visor de imágenes 2D: rotar fotos sin perder calidad usando la matriz 2D.
• Robótica: cálculo de la orientación del efector final mediante matrices de rotación 3D.
• Realidad Aumentada: alinear objetos virtuales con la cámara usando cuaterniones convertidos a matrices 3D.
• Simulación de física: aplicar torque como rotación incremental en cuerpos rígidos.

Conclusión

Las matrices de rotación son herramientas versátiles y de bajo coste computacional. Dominar su construcción en 2D y 3D, así como saber cuándo sustituirlas por cuaterniones, es esencial para cualquier profesional que trabaje con gráficos, visión por computadora o sistemas de control. Con los ejemplos en Python presentados, podrás integrar rotaciones robustas y optimizadas en tus proyectos desde el primer día.