SDK Multiplataforma en C logo

SDK Multiplataforma en C

Vectores 2D

❮ Anterior
Siguiente ❯

Funciones

V2Dv2d (...)
V2Dv2d_add (...)
V2Dv2d_sub (...)
V2Dv2d_mul (...)
V2Dv2d_unit (...)
V2Dv2d_perp_pos (...)
V2Dv2d_perp_neg (...)
bool_tv2d_norm (...)
realv2d_length (...)
realv2d_sqlength (...)
realv2d_dot (...)
realv2d_dist (...)
realv2d_sqdist (...)
realv2d_angle (...)
voidv2d_rotate (...)

Tipos y Constantes

V2DkZERO
V2DkX
V2DkY

El vector es el elemento geométrico más elemental. Representa un punto, una dirección o un desplazamiento mediante sus dos componentes x e y (Figura 1).

Dibujo de un plano con un punto y un vector.
Figura 1: Un vector 2D representa una posición o un desplazamiento en el plano.

El Álbegra Vectorial define una serie de operaciones básicas: Suma, negación, multiplicación por un escalar, módulo y normalización (Fórmula 1). La representación visual de dichas operaciones la tenemos en (Figura 2).

Álbegra vectorial elemental.
Fórmula 1: Álbegra vectorial elemental.
Dibujo de un plano con diferentes operaciones con vectores.
Figura 2: Interpretación geométrica de las operaciones básicas con vectores.

El ángulo de rotación de un vector se expresará siempre en radianes y el sentido positivo corresponde al giro desde el eje X hacia el eje Y. Normalmente se asocia como positiva la dirección antihoraria y negativa la horaria. Esto es cierto en coordenadas cartesianas pero no en otro tipo de sistemas de referencia, como imágenes o monitores (Figura 3). Debemos tenerlo presente para evitar confusiones, algo que sucede con relativa frecuencia. El mismo criterio se aplica al calcular el vector perpendicular, diferenciando entre positivo y negativo.

Dibujo de un plano con diferentes rotaciones de vectores.
Figura 3: Rotación de un vector en diferentes sistemas de coordenadas.

Otra operación utilizada con bastante frecuencia por los algoritmos geométricos es la proyección de puntos sobre un vector. Intuitivamente, podemos verlo como el punto sobre el vector más cercano al punto original y que siempre estará sobre la línea perpendicular. La calcularemos con el producto escalar (Fórmula 2) y su valor (escalar) será la distancia desde el origen a la proyección en la dirección del vector (Figura 4).

Proyección de varios puntos en un vector.
Fórmula 2: Proyección de varios puntos en un vector.
Dibujo de un plano con diferentes proyecciones de puntos en un vector.
Figura 4: Interpretación geométrica de las proyecciones.
Si lo que nos interesa es la posición relativa entre diferentes proyecciones, podemos evitar la división por el módulo del vector, lo que es más eficiente computacionalmente al no calcular raíces cuadradas.

kZERO

const V2Df kV2D_ZEROf;

const V2Dd kV2D_ZEROd;

const V2D V2D::kZERO;

El vector (0,0).


kX

const V2Df kV2D_Xf;

const V2Dd kV2D_Xd;

const V2D V2D::kX;

El vector (1,0).


kY

const V2Df kV2D_Yf;

const V2Dd kV2D_Yd;

const V2D V2D::kY;

El vector (0,1).


v2d ()

Crea un vector 2d a partir de sus componentes.

V2Df
v2df(const real32_t x,
     const real32_t y);

V2Dd
v2dd(const real64_t x,
     const real64_t y);

V2D
V2D(const real x,
    const real y);
x

Coordenada x.

y

Coordenada y.

Retorna

El vector 2d.


v2d_add ()

Suma dos vectores.

V2Df
v2d_addf(const V2Df *v1,
         const V2Df *v2);

V2Dd
v2d_addd(const V2Dd *v1,
         const V2Dd *v2);

V2D
V2D::add(const V2D *v1,
         const V2D *v2);
v1

Vector 1.

v2

Vector 2.

Retorna

El vector resultado.


v2d_sub ()

Resta dos vectores.

V2Df
v2d_subf(const V2Df *v1,
         const V2Df *v2);

V2Dd
v2d_subd(const V2Dd *v1,
         const V2Dd *v2);

V2D
V2D::sub(const V2D *v1,
         const V2D *v2);
v1

Vector 1.

v2

Vector 2.

Retorna

El vector resultado.


v2d_mul ()

Multiplica un vector por un escalar.

V2Df
v2d_mulf(const V2Df *v,
         const real32_t s);

V2Dd
v2d_muld(const V2Dd *v,
         const real64_t s);

V2D
V2D::mul(const V2D *v,
         const real s);
v

Vector.

s

Escalar.

Retorna

El vector resultado.


v2d_unit ()

Vector unitario (dirección) desde 1 a 2.

V2Df
v2d_unitf(const V2Df *v1,
          const V2Df *v2,
          real32_t *dist);

V2Dd
v2d_unitd(const V2Dd *v1,
          const V2Dd *v2,
          real64_t *dist);

V2D
V2D::unit(const V2D *v1,
          const V2D *v2,
          real *dist);
v1

Punto 1 (origen).

v2

Punto 2 (destino).

dist

Distancia entre puntos. Puede ser NULL.

Retorna

El vector unitario.


v2d_perp_pos ()

Obtiene el vector perpendicular positivo.

V2Df
v2d_perp_posf(const V2Df *v);

V2Dd
v2d_perp_posd(const V2Dd *v);

V2D
V2D::perp_pos(const V2D *v);
v

Vector inicial.

Retorna

El vector perpendicular.

Observaciones

Es la perpendicular que se obtiene mediante ángulo positivo (+π/2).


v2d_perp_neg ()

Obtiene el vector perpendicular negativo.

V2Df
v2d_perp_negf(const V2Df *v);

V2Dd
v2d_perp_negd(const V2Dd *v);

V2D
V2D::perp_neg(const V2D *v);
v

Vector inicial.

Retorna

El vector perpendicular.

Observaciones

Es la perpendicular que se obtiene mediante ángulo negativo (-π/2).


v2d_norm ()

Normaliza un vector, es decir, lo convierte en un vector de longitud = 1.

bool_t
v2d_normf(V2Df *v);

bool_t
v2d_normd(V2Dd *v);

bool_t
V2D::norm(V2D *v);
v

El vector que será normalizado.

Retorna

FALSE si el vector no se puede normalizar (el vector 0).


v2d_length ()

Calcula la longitud de un vector.

real32_t
v2d_lengthf(const V2Df *v);

real64_t
v2d_lengthd(const V2Dd *v);

real
V2D::length(const V2D *v);
v

El vector.

Retorna

El módulo del vector.


v2d_sqlength ()

Calcula el cuadrado de la longitud de un vector.

real32_t
v2d_sqlengthf(const V2Df *v);

real64_t
v2d_sqlengthd(const V2Dd *v);

real
V2D::sqlength(const V2D *v);
v

El vector.

Retorna

El cuadrado del módulo del vector.

Observaciones

Evita utilizar la raíz cuadrada, por lo que es más eficiente que v2d_lengthf. Suele utilizarse para comparar distancias.


v2d_dot ()

Producto escalar de dos vectores.

real32_t
v2d_dotf(const V2Df *v1,
         const V2Df *v2);

real64_t
v2d_dotd(const V2Dd *v1,
         const V2Dd *v2);

real
V2D::dot(const V2D *v1,
         const V2D *v2);
v1

Vector 1.

v2

Vector 2.

Retorna

Producto escalar.


v2d_dist ()

Calcula la distancia entre dos puntos.

real32_t
v2d_distf(const V2Df *v1,
          const V2Df *v2);

real64_t
v2d_distd(const V2Dd *v1,
          const V2Dd *v2);

real
V2D::dist(const V2D *v1,
          const V2D *v2);
v1

Punto 1.

v2

Punto 2.

Retorna

La distancia.


v2d_sqdist ()

Calcula el cuadrado de la distancia entre dos puntos.

real32_t
v2d_sqdistf(const V2Df *v1,
            const V2Df *v2);

real64_t
v2d_sqdistd(const V2Dd *v1,
            const V2Dd *v2);

real
V2D::sqdist(const V2D *v1,
            const V2D *v2);
v1

Punto 1.

v2

Punto 2.

Retorna

La distancia al cuadrado.

Observaciones

Evita utilizar la raíz cuadrada, por lo que es más eficiente que v2d_distf. Suele utilizarse para comparar distancias.


v2d_angle ()

Calcula el ángulo formado por dos vectores.

real32_t
v2d_anglef(const V2Df *v1,
           const V2Df *v2);

real64_t
v2d_angled(const V2Dd *v1,
           const V2Dd *v2);

real
V2D::angle(const V2D *v1,
           const V2D *v2);
v1

Vector 1.

v2

Vector 2.

Retorna

El ángulo en radianes (-Pi, Pi)

Observaciones

Los ángulos positivos se expresan desde v1 a v2, en el mismo sentido que el giro del eje X hacia el eje Y. Para ángulos mayores de π rad (180°) se devolverá sentido negativo.


v2d_rotate ()

Aplica un rotación a un vector.

void
v2d_rotatef(V2Df *v,
            const real32_t a);

void
v2d_rotated(V2Dd *v,
            const real64_t a);

void
V2D::rotate(V2D *v,
            const real a);
v

Vector que será rotado (origen/destino).

a

Ángulo en radianes.

Observaciones

Esta función implica calcular el seno y coseno. Utiliza t2d_vmultnf si tienes que aplicar la misma rotación a varios vectores.

❮ Anterior
Siguiente ❯