Cajas Orientadas 2D

Funciones

OBB2D*	obb2d_create (...)
OBB2D*	obb2d_from_line (...)
OBB2D*	obb2d_from_points (...)
OBB2D*	obb2d_copy (...)
void	obb2d_destroy (...)
void	obb2d_update (...)
void	obb2d_move (...)
void	obb2d_transform (...)
const V2D*	obb2d_corners (...)
V2D	obb2d_center (...)
real	obb2d_width (...)
real	obb2d_height (...)
real	obb2d_angle (...)
real	obb2d_area (...)
Box2D	obb2d_box (...)

Las cajas orientadas (Oriented Bounding Box) son cajas 2D que pueden rotan sobre su centro (Figura 1), por lo que ya no estarán alineadas con los ejes. Aquí la detección de colisiones se complica un poco con respecto a las cajas 2D alineadas, a cambio de proporcionar un mejor ajuste ante objetos alargados que puedan girar en el plano.

Utiliza obb2d_from_pointsf para crear una caja orientada a partir de un conjunto de puntos.
Utiliza obb2d_from_linef para crear una caja orientada a partir de un segmento.
Utiliza obb2d_transformf para aplicar una transformación 2D a la caja.
Utiliza obb2d_boxf para obtener la caja alineada que contiene a la caja orientada.

Dibujo de una caja orientada en el plano. — Figura 1: Cajas orientadas en 2D.

Podemos obtener parámetros relevantes de un conjunto arbitrario de puntos a partir de la matriz de covarianza (Fórmula 1), que geométricamente representa una elipse rotada en el plano y centrada en la media de la distribución (Figura 2). Este análisis permite a obb2d_from_pointsf calcular la caja 2D asociada a la distribución de una forma bastante aceptable, sin llegar a ser la solución óptima mucho más costosa en términos computacionales.

Fórmula 1: Cálculo de la matriz de covarianza.

Representación geométrica de la matriz de covarianza. — Figura 2: La matriz de covarianza representa una elipse rotada en el plano.

Utiliza cajas orientadas (OBB2Df) para distribuciones "alargadas" de puntos. En casos redondeados o cuadrados la caja alineada (Box2Df) puede proporcionar un volumen de menor área.

obb2d_create ()

Crea una nueva caja orientada.

OBB2Df*
obb2d_createf(const V2Df *center,
              const real32_t width,
              const real32_t height,
              const real32_t angle);

OBB2Dd*
obb2d_created(const V2Dd *center,
              const real64_t width,
              const real64_t height,
              const real64_t angle);

OBB2D*
OBB2D::create(const V2D *center,
              const real width,
              const real height,
              const real angle);

center	El punto central.
width	El ancho de la caja.
height	El alto de la caja.
angle	El ángulo con respecto al eje X, en radianes.

Retorna

La caja recién creada.

Observaciones

Los ángulos positivos son los que giran desde el eje X al eje Y.

obb2d_from_line ()

Crea una caja a partir de un segmento.

OBB2Df*
obb2d_from_linef(const V2Df *p0,
                 const V2Df *p1,
                 const real32_t thickness);

OBB2Dd*
obb2d_from_lined(const V2Dd *p0,
                 const V2Dd *p1,
                 const real64_t thickness);

OBB2D*
OBB2D::from_line(const V2D *p0,
                 const V2D *p1,
                 const real thickness);

p0	El primer punto del segmento.
p1	El segundo punto del segmento.
thickness	El "grosor" del segmento.

Retorna

La caja recién creada.

Observaciones

La anchura de la caja corresponderá con la longitud del segmento. La altura será thickness y el centro el punto medio del segmento.

obb2d_from_points ()

Crea una caja orientada a partir de un conjunto de puntos.

OBB2Df*
obb2d_from_pointsf(const V2Df *p,
                   const uint32_t n);

OBB2Dd*
obb2d_from_pointsd(const V2Dd *p,
                   const uint32_t n);

OBB2D*
OBB2D::from_points(const V2D *p,
                   const uint32_t n);

p	Vector de puntos.
n	Número de puntos.

Retorna

La caja recién creada.

Observaciones

Se producirá un buen ajuste en distribuciones de puntos "alargadas" calculando la matriz de covarianza y proyectando puntos en el vector director de dicha distribución. No obstante, no proporciona la caja de volumen mínimo.

obb2d_copy ()

Crea una copia de la caja.

OBB2Df*
obb2d_copyf(const OBB2Df obb);

OBB2Dd*
obb2d_copyd(const OBB2Dd obb);

OBB2D*
OBB2D::copy(const OBB2D obb);

obb	La caja original.

Retorna

La caja copiada.

obb2d_destroy ()

Destruye la caja.

void
obb2d_destroyf(OBB2Df **obb);

void
obb2d_destroyd(OBB2Dd **obb);

void
OBB2D::destroy(OBB2D **obb);

obb	La caja. Será puesto a `NULL` tras la destrucción.

obb2d_update ()

Actualiza los parámetros de la caja.

void
obb2d_updatef(OBB2Df *obb,
              const V2Df *center,
              const real32_t width,
              const real32_t height,
              const real32_t angle);

void
obb2d_updated(OBB2Dd *obb,
              const V2Dd *center,
              const real64_t width,
              const real64_t height,
              const real64_t angle);

void
OBB2D::update(OBB2D *obb,
              const V2D *center,
              const real width,
              const real height,
              const real angle);

obb	La caja a actualizar.
center	El punto central.
width	La anchura.
height	La altura.
angle	El ángulo.

Observaciones

Ver obb2d_createf.

obb2d_move ()

Desplaza la caja en el plano.

void
obb2d_movef(OBB2Df *obb,
            const real32_t offset_x,
            const real32_t offset_y);

void
obb2d_moved(OBB2Dd *obb,
            const real64_t offset_x,
            const real64_t offset_y);

void
OBB2D::move(OBB2D *obb,
            const real offset_x,
            const real offset_y);

obb	La caja.
offset_x	Desplazamiento en X.
offset_y	Desplazamiento en Y.

obb2d_transform ()

Aplica una transformación a la caja.

void
obb2d_transformf(OBB2Df *obb,
                 const T2Df *t2d);

void
obb2d_transformd(OBB2Dd *obb,
                 const T2Dd *t2d);

void
OBB2D::transform(OBB2D *obb,
                 const T2D *t2d);

obb	La caja.
t2d	La transformación afín.

obb2d_corners ()

Obtiene los vértices que limitan la caja.

const V2Df*
obb2d_cornersf(const OBB2Df *obb);

const V2Dd*
obb2d_cornersd(const OBB2Dd *obb);

const V2D*
OBB2D::corners(const OBB2D *obb);

obb

La caja.

Retorna

Puntero a un array de 4 vértices.

Observaciones

No modificar el array devuelto. Copiar si fuera necesario.

obb2d_center ()

Obtiene el punto central de la caja.

V2Df
obb2d_centerf(const OBB2Df *obb);

V2Dd
obb2d_centerd(const OBB2Dd *obb);

V2D
OBB2D::center(const OBB2D *obb);

obb

La caja.

Retorna

El centro.

obb2d_width ()

Obtiene la anchura de la caja.

real32_t
obb2d_widthf(const OBB2Df *obb);

real64_t
obb2d_widthd(const OBB2Dd *obb);

real
OBB2D::width(const OBB2D *obb);

obb

La caja.

Retorna

La anchura.

obb2d_height ()

Obtiene la altura de la caja.

real32_t
obb2d_heightf(const OBB2Df *obb);

real64_t
obb2d_heightd(const OBB2Dd *obb);

real
OBB2D::height(const OBB2D *obb);

obb

La caja.

Retorna

La altura.

obb2d_angle ()

Obtiene el ángulo de la caja.

real32_t
obb2d_anglef(const OBB2Df *obb);

real64_t
obb2d_angled(const OBB2Dd *obb);

real
OBB2D::angle(const OBB2D *obb);

obb

La caja.

Retorna

El ángulo en radianes con respecto al eje X.

obb2d_area ()

Obtiene el área de la caja.

real32_t
obb2d_areaf(const OBB2Df *obb);

real64_t
obb2d_aread(const OBB2Dd *obb);

real
OBB2D::area(const OBB2D *obb);

obb

La caja.

Retorna

El área (width * height).

obb2d_box ()

Obtiene los límites de la caja.

Box2Df
obb2d_boxf(const OBB2Df *obb);

Box2Dd
obb2d_boxd(const OBB2Dd *obb);

Box2D
OBB2D::box(const OBB2D *obb);

obb

La caja.

Retorna

Caja alineada con los ejes, definida por los vectores mínimo y máximo.