Referencia de la Clase COSA_RIGIDA

Una `COSA_RIGIDA` es una `COSA` primitiva de una, dos o tres dimensiones. Más...

#include <cosa.h>

Diagrama de herencias de COSA_RIGIDA

[leyenda]Diagrama de colaboración para COSA_RIGIDA:

[leyenda]Lista de todos los miembros.

Métodos públicos
	COSA_RIGIDA ()
virtual	~COSA_RIGIDA ()
virtual COSA *	crear_copia (void)
	OJO: Redefine la version de la clase COSA.
BOOLEAN	consultar_variable (const char *nombre_variable, int &tipo, void **ref)
	OJO: Esta funcion, por la manera en que usa variables globales, hace que el programa no sea "thread-safe"!
BOOLEAN	actualizar_variable (const char *nombre_variable, int tipo, void *ref)
	Éste metodo, junto con `consultar_variable` es el núcleo del esquema de introspección AQUYNZA.
GEOMETRIA *	geometria (void)
VECTOR	posicion_absoluta (VECTOR p)
	Retorna las coordenadas absolutas de un punto que en el sistema local de coordenadas de esta COSA esta en la posicion `p`.
VECTOR	velocidad_angular_absoluta (void)
void	set_velocidad_angular_absoluta (VECTOR omega)
MATRIZ_4x4	tensor_de_inercia (void)
QUATERNION	orientacion_absoluta (void)
	Retorna la orientacion absoluta de esta cosa.
void	set_orientacion_absoluta (QUATERNION q)
	OJO: ESTO NO ESTA FUNCIONANDO CUANDO ESTA COSA TIENE PADRE!
void	aplicar_drag (double Kd)
void	tick (void)
void	actualizar (double delta_t)
int	ODE_numero_de_variables_de_estado (void)
	OJO: Notese que las variables de estado de interes para el solver son: pocision, velocidad, orientacion y velocidad_rotacional y cada una son un vector de 3 posiciones, excepto la orientacion, que ademas es un quaternion y tiene magnitud.
void	ODE_reportar_variables_de_estado (double *Datos)
void	ODE_actualizar_variables_de_estado (double *Datos)
void	ODE_calcular_la_primera_derivada (double *Datos)
	ATENCION: ESTE ES EL METODO CENTRAL DE LA SIMULACION FISICA DE LAS COSAS! A continuacion, pocas lineas de codigo y muchas de comentarios intentando dejar en claro todo.
void	minmax (VECTOR *min, VECTOR *max)
	La operacion `minmax` de la clase GEOMETRIA calcula el paralelogramo envolvente de esta COSA en coordenadas relativas a la COSA.
virtual double	interseccion (RAYO *Rayo, VECTOR *Punto, VECTOR *Normal)
	Dado un Rayo, calcula el punto y la normal de la interseccion de dicho rayo con la geometria de dicha cosa.
void	pintar_gl (CALIDAD_VISUAL *Calidad, CAMARA *Camara)
	PRE: GL esta en GL_MODELVIEW.
void	pintar_povray (FILE *fd)
BOOLEAN	leer (TOKENIZADOR *Sabiondo)
BOOLEAN	resolver (LISTA< COSA * > *Cosa)
void	grabar (FILE *fd)
Métodos protegidos
BOOLEAN	leer_rigida (TOKENIZADOR *Sabiondo, char *cad)
	Esto es un procedimiento de `leer`.
void	resolver_tensor_de_inercia (void)
	Esto es un procedimiento de `leer`.
Atributos protegidos
VECTOR	_centro_de_masa
VECTOR	_velocidad_angular
QUATERNION	_orientacion
MATRIZ_4x4	tensor_de_inercia_0
Atributos privados
GEOMETRIA *	Geometria
double	_ultimo_Kd

---

Descripción detallada

Una `COSA_RIGIDA` es una `COSA` primitiva de una, dos o tres dimensiones.

Ademas de lo que posee una `MASA_PUNTUAL`, representa orientación y velocidad angular, y la distribución de su masa.

Nótese que la dimensión de una `COSA_RIGIDA` está dada por las dimensiones de su `GEOMETRIA`.

Tareas Pendientes:

OJO: Dado que la variación de `GEOMETRIA` puede encapsularse dentro del método `actualizar`, puede ser que el nombre de rígida está indebidamente asignado. Debe revisarse el diseńo de esta clase.

Definición en la línea 302 del archivo cosa.h.

---

Documentación del constructor y destructor

COSA_RIGIDA::COSA_RIGIDA (   )

Definición en la línea 58 del archivo cosa_rigida.C. References _centro_de_masa, _orientacion, COSA::_tipo_de_cosa, _ultimo_Kd, _velocidad_angular, CC_COSA_RIGIDA, Geometria, MATRIZ_4x4::identidad(), QUATERNION::importar_angulo_eje(), tensor_de_inercia_0, VECTOR::x, VECTOR::y, y VECTOR::z.

Here is the call graph for this function:

COSA_RIGIDA::~COSA_RIGIDA (   )  [virtual]

Definición en la línea 84 del archivo cosa_rigida.C. References COSA::_nombre_padre.

---

Documentación de las funciones miembro

void COSA_RIGIDA::actualizar (  double  delta_t  )  [virtual]

Implements COSA. Definición en la línea 948 del archivo cosa_rigida.C. References _ultimo_Kd, _velocidad_angular, SOLVER_EULER::ejecutar_solucion(), y VECTOR::norma().

Here is the call graph for this function:

BOOLEAN COSA_RIGIDA::actualizar_variable (  const char *  nombre_variable, int  tipo, void *  ref )  [virtual]

Éste metodo, junto con `consultar_variable` es el núcleo del esquema de introspección AQUYNZA. La introspección permite consultar y/o actualizar cualquier variable de cualquier tipo mediante una interfaz unificada. Éste metodo rétorna TRUE si la operación de acutalización en introspección fue válida o FALSE si no (ya sea porque el tipo de datos era incorrecto o el nombre de variable suministrado no existe dentro de la clase). Este método deberá ser sobrecargado por las clases que se deseen entren al esquema de introspección AQUYNZA (las cuales además deben heredar de ésta clase). El comportamiento por defecto es tener la introspección desactivada (siempre retornar FALSE). Reimplementado de COSA. Definición en la línea 169 del archivo cosa_rigida.C. References _orientacion, COSA::actualizar_variable(), MATRIZ_4x4::exportar_angulos_euler(), MATRIZ_4x4::exportar_quaternion(), MATRIZ_4x4::importar_quaternion(), orientacion_absoluta(), MATRIZ_4x4::rotacion_angulos_euler(), set_orientacion_absoluta(), T_FLOAT, T_VECTOR, TMP_float, TMP_vector, VECTOR::x, VECTOR::y, y VECTOR::z.

Here is the call graph for this function:

void COSA_RIGIDA::aplicar_drag (  double  Kd  )  [virtual]

Reimplementado de COSA. Definición en la línea 976 del archivo cosa_rigida.C. References _velocidad_angular, COSA::anexar_fuerza(), VECTOR::imprimir(), VECTOR::norma(), VECTOR::normalizar(), posicion_absoluta(), VECTOR::producto_cruz(), MATRIZ_4x4::rotacion_punto_punto(), y COSA::velocidad_absoluta().

Here is the call graph for this function:

BOOLEAN COSA_RIGIDA::consultar_variable (  const char *  nombre_variable, int &  tipo, void **  ref )  [virtual]

OJO: Esta funcion, por la manera en que usa variables globales, hace que el programa no sea "thread-safe"! Reimplementado de COSA. Definición en la línea 100 del archivo cosa_rigida.C. References _centro_de_masa, _orientacion, COSA::consultar_variable(), MATRIZ_4x4::exportar_angulos_euler(), MATRIZ_4x4::importar_quaternion(), orientacion_absoluta(), T_FLOAT, T_QUATERNION, T_VECTOR, TMP_float, TMP_quaternion, TMP_vector, VECTOR::x, VECTOR::y, y VECTOR::z.

Here is the call graph for this function:

COSA * COSA_RIGIDA::crear_copia (  void   )  [virtual]

OJO: Redefine la version de la clase COSA. Reimplementado de COSA. Definición en la línea 236 del archivo cosa_rigida.C. References GEOMETRIA::crear_copia(), y Geometria.

Here is the call graph for this function:

GEOMETRIA * COSA_RIGIDA::geometria (  void   )  [virtual]

Implements COSA. Definición en la línea 90 del archivo cosa_rigida.C. References Geometria.

void COSA_RIGIDA::grabar (  FILE *  fd  )  [virtual]

Implements COSA. Definición en la línea 565 del archivo cosa_rigida.C. References _velocidad_angular, MATRIZ_4x4::exportar_angulos_euler(), Geometria, COSA::grabar_basico(), MATRIZ_4x4::importar_quaternion(), ENTIDAD::nombre(), VECTOR::norma(), orientacion_absoluta(), GEOMETRIA::pintar_aqz(), simplifique_real(), VECTOR::x, VECTOR::y, y VECTOR::z.

Here is the call graph for this function:

double COSA_RIGIDA::interseccion (  RAYO *  Rayo, VECTOR *  Punto, VECTOR *  Normal )  [virtual]

Dado un Rayo, calcula el punto y la normal de la interseccion de dicho rayo con la geometria de dicha cosa. Se retorna la distancia desde el origen del rayo hasta el punto de interseccion. Si la distancia es menor a 0 (cero), no hay en realidad interseccion. OJO: Que tan ineficiente es esto? Tips... Deberia precalcularse en la constructora y en actualizar() a R y su inversa, al igual que p. `n` debe dejar de usarse! En vez de usar matrices se deberian usar quaternions Reimplementado de COSA. Reimplementado en ESPACIO_ABIERTO, y ESPACIO. Definición en la línea 812 del archivo cosa_rigida.C. References RAYO::direccion, Geometria, MATRIZ_4x4::importar_quaternion(), GEOMETRIA::interseccion(), MATRIZ_4x4::inversa(), VECTOR::normalizar(), orientacion_absoluta(), RAYO::origen, y posicion_absoluta().

Here is the call graph for this function:

BOOLEAN COSA_RIGIDA::leer (  TOKENIZADOR *  Sabiondo  )  [virtual]

Implements COSA. Definición en la línea 600 del archivo cosa_rigida.C. References COSA::_color, BOOLEAN, des_comille(), MATERIAL::difusa(), Geometria, COSA::leer_basico(), leer_geometria(), leer_rigida(), COSA::Material, resolver_tensor_de_inercia(), ENTIDAD::set_nombre(), TOKENIZADOR::siguiente_token(), TK_ABRIR, TK_CADENA, TK_CERRAR, TK_DESCONOCIDO, y TK_IDENTIFICADOR.

Here is the call graph for this function:

BOOLEAN COSA_RIGIDA::leer_rigida (  TOKENIZADOR *  Sabiondo, char *  cad )  [protected]

Esto es un procedimiento de `leer`. Definición en la línea 478 del archivo cosa_rigida.C. References _orientacion, _velocidad_angular, MATRIZ_4x4::exportar_quaternion(), QUATERNION::importar_angulo_eje(), VECTOR::normalizar(), MATRIZ_4x4::rotacion_angulos_euler(), TOKENIZADOR::siguiente_token(), TK_DESCONOCIDO, TK_NUMERO, TK_VECTOR_FIN, TK_VECTOR_INICIO, VECTOR::x, VECTOR::y, y VECTOR::z. Referenciado por leer(), y ESPACIO_ABIERTO::leer_espacio().

Here is the call graph for this function:

void COSA_RIGIDA::minmax (  VECTOR *  min, VECTOR *  max )  [virtual]

La operacion `minmax` de la clase GEOMETRIA calcula el paralelogramo envolvente de esta COSA en coordenadas relativas a la COSA. Esta, la operacion `minmax` de la COSA_RIGIDA calcula un min-max en coordenadas globales, utilizando las coordenadas de los 8 vertices extremos de la envolvente local. Implements COSA. Definición en la línea 771 del archivo cosa_rigida.C. References Geometria, GEOMETRIA::minmax(), posicion_absoluta(), VECTOR::x, VECTOR::y, y VECTOR::z.

Here is the call graph for this function:

void COSA_RIGIDA::ODE_actualizar_variables_de_estado (  double *  Datos  )  [virtual]

Implements COSA. Definición en la línea 1087 del archivo cosa_rigida.C. References COSA::_estoy_fijo, _orientacion, COSA::_posicion, COSA::_velocidad, _velocidad_angular, QUATERNION::direccion, QUATERNION::magnitud, QUATERNION::normalizar(), VECTOR::x, VECTOR::y, y VECTOR::z.

Here is the call graph for this function:

void COSA_RIGIDA::ODE_calcular_la_primera_derivada (  double *  Datos  )  [virtual]

ATENCION: ESTE ES EL METODO CENTRAL DE LA SIMULACION FISICA DE LAS COSAS! A continuacion, pocas lineas de codigo y muchas de comentarios intentando dejar en claro todo. Este metodo se realiza en varias etapas, las cuales por el momento abarcan lo siguiente: 1. Calcular la contribucion total de las fuerzas sobre el cuerpo 2. Actualizar la posicion y velocidad del cuerpo mediante la aplicacion de las ecuaciones de dinamica de cuerpos (no se usan las de cinematica) 3. Actualizar la orientacion y velocidad rotacional del cuerpo de manera similar al paso 2. A medida que AQUYNZA soporte la simulacion de mas comportamientos para las COSAs, este metodo ira creciendo! Respecto a la simulacion del movimiento lineal -------------------------- OJO: para el vector de posicion `X`, el vector de velocidad `V` y el vector acumulado de fuerza `V` se tiene, con la masa `m` y `delta_t`: Vf ::= Vi + (delta_t/m)F ::= Vi + delta_t * (DERIV(Vi)) y como F = m*A = m*DERIV(V), DERIV(V) ::= F/m Tenga en cuenta que como la actualizacion de la ecuacion diferencial que describe el movimiento de una COSA se realiza con un SOLVER mediante metodos numericos, esta funcion lo que calcula exactamente son los cambios que maneja el SOLVER (i.e. deriva la ecuacion diferencial). Respecto a la simulacion del movimiento angular ------------------------- En cuanto a la contraparte que calcula el cambio en la orientacion debido a la velocidad angular de la COSA, debe tenerse en cuenta lo siguiente: Tanto la orientacion como la velocidad angular estan representadas como QUATERNIONs (un vector normalizado y una magnitud) La ecuacion de actualizacion es de forma matricial: R'(t) = omega(t)[asterisco] * R(t) Como se deriva en el curso de Baraff "Physically Based Modelling: principles and practice, Siggraph 1997", donde para un vector <x,y,z>, tenemos la matriz: <x, y, z>[asterisco] ::= [0, -z, y;z, 0, -x;-y, x, 0] derivada utilizando la tecnica de rotacion infinitesimal descrita en el capitulo 4.8. de "H. Goldstein - Classical Mechanics, AddisonWesley 1983". Notas varias ------------------------------------------------------------ WARNINGS: Este metodo es muy importante dentro del sistema AQUYNZA, porque es el encargado de ejecutar la simulacion basada en fisica. Para colmo es altamente complejo y usa matematicas delicadamente. Dentro de la serie de pruebas realizadas, se debe notar que hay algunos advertencias: Al parecer queda algun error en alguno de los tipos basicos VECTOR, MATRIZ_4x4 o QUATERNION, porque hay un excesivo acumulamiento de error numerico (draft). Sin embargo, cabe la posibilidad de que todos los tipos esten perfectos, y ese error se este acumulando como concecuencia de problemas de presicion. Hay alguna confusion con los signos de las orientaciones. Notese que en el metodo `cargar`, se le estan cambiando los signos al leer la velocidad angular y a la orientacion. OJO: Hay que mirar si el algoritmo se mejora si se realizan los siguientes cambios: En vez de usar la velocidad angular como variable de estado se usa el momentum (impetu) angular Si se guardan las variables temporales como I_t y R_t como metodos de la clase para calcular facilmente las conversiones del caso. Implements COSA. Definición en la línea 1110 del archivo cosa_rigida.C. References COSA::_estoy_fijo, COSA::_masa, _orientacion, COSA::_posicion, COSA::_velocidad, _velocidad_angular, QUATERNION::direccion, MATRIZ_4x4::exportar_quaternion(), MATRIZ_4x4::importar_quaternion(), QUATERNION::importar_quaternion_puro(), MATRIZ_4x4::inversa(), COSA::limpiar_fuerzas(), COSA::lista_fuerzas_externas, QUATERNION::magnitud, VECTOR::producto_cruz(), LISTA< FUERZA_PUNTO * >::tam(), tensor_de_inercia_0, VECTOR::x, VECTOR::y, y VECTOR::z.

Here is the call graph for this function:

int COSA_RIGIDA::ODE_numero_de_variables_de_estado (  void   )  [virtual]

OJO: Notese que las variables de estado de interes para el solver son: pocision, velocidad, orientacion y velocidad_rotacional y cada una son un vector de 3 posiciones, excepto la orientacion, que ademas es un quaternion y tiene magnitud. Implements COSA. Definición en la línea 1054 del archivo cosa_rigida.C. References COSA::_estoy_fijo.

void COSA_RIGIDA::ODE_reportar_variables_de_estado (  double *  Datos  )  [virtual]

Implements COSA. Definición en la línea 1067 del archivo cosa_rigida.C. References COSA::_estoy_fijo, _orientacion, COSA::_posicion, COSA::_velocidad, _velocidad_angular, QUATERNION::direccion, QUATERNION::magnitud, VECTOR::x, VECTOR::y, y VECTOR::z.

QUATERNION COSA_RIGIDA::orientacion_absoluta (  void   )  [virtual]

Retorna la orientacion absoluta de esta cosa. OJO: Notese que la rotacion compuesta de dos rotaciones expresadas mediante cuaterniones es la multiplicacion de los cuaterniones. Reimplementado de COSA. Definición en la línea 673 del archivo cosa_rigida.C. References _orientacion, QUATERNION::normalizar(), COSA::orientacion_absoluta(), y COSA::Padre. Referenciado por actualizar_variable(), ESPACIO_ABIERTO::anexar_objetos_rayables(), consultar_variable(), grabar(), ESPACIO_ABIERTO::interseccion(), interseccion(), ESPACIO_ABIERTO::pintar_gl(), pintar_gl(), y pintar_povray().

Here is the call graph for this function:

void COSA_RIGIDA::pintar_gl (  CALIDAD_VISUAL *  Calidad, CAMARA *  Camara )  [virtual]

PRE: GL esta en GL_MODELVIEW. Implements COSA. Reimplementado en ESPACIO_ABIERTO, y ESPACIO. Definición en la línea 864 del archivo cosa_rigida.C. References COSA::_color, MATRIZ_4x4::cargar_gl(), MATERIAL::difusa(), Geometria, MATRIZ_4x4::importar_quaternion(), COSA::Material, GEOMETRIA::minmax(), CAMARA::minmax_visible(), orientacion_absoluta(), GEOMETRIA::pintar_gl(), posicion_absoluta(), MATERIAL::set_difusa(), VECTOR::x, VECTOR::y, y VECTOR::z.

Here is the call graph for this function:

void COSA_RIGIDA::pintar_povray (  FILE *  fd  )  [virtual]

Reimplementado de COSA. Definición en la línea 917 del archivo cosa_rigida.C. References COSA::_color, MATERIAL::activar_povray(), MATRIZ_4x4::activar_povray(), MATERIAL::difusa(), Geometria, MATRIZ_4x4::importar_quaternion(), MATRIZ_4x4::inversa(), COSA::Material, orientacion_absoluta(), GEOMETRIA::pintar_povray(), posicion_absoluta(), MATERIAL::set_difusa(), VECTOR::x, VECTOR::y, y VECTOR::z.

Here is the call graph for this function:

VECTOR COSA_RIGIDA::posicion_absoluta (  VECTOR  p  )  [virtual]

Retorna las coordenadas absolutas de un punto que en el sistema local de coordenadas de esta COSA esta en la posicion `p`. OJO: Esto es respecto al centro geometrico de la COSA. Reimplementado de COSA. Definición en la línea 706 del archivo cosa_rigida.C. References _orientacion, COSA::_posicion, COSA::consultar_variable(), MATRIZ_4x4::importar_quaternion(), COSA::Padre, T_QUATERNION, y T_VECTOR. Referenciado por ESPACIO_ABIERTO::anexar_objetos_rayables(), aplicar_drag(), ESPACIO_ABIERTO::interseccion(), interseccion(), minmax(), ESPACIO_ABIERTO::pintar_gl(), pintar_gl(), y pintar_povray().

Here is the call graph for this function:

BOOLEAN COSA_RIGIDA::resolver (  LISTA< COSA * > *  Cosa  )  [virtual]

Reimplementado de COSA. Definición en la línea 462 del archivo cosa_rigida.C. References COSA::_nombre_padre, ENTIDAD::nombre(), COSA::Padre, y LISTA< T >::tam().

Here is the call graph for this function:

void COSA_RIGIDA::resolver_tensor_de_inercia (  void   )  [protected]

Esto es un procedimiento de `leer`. Definición en la línea 541 del archivo cosa_rigida.C. References COSA::_masa, MATRIZ_4x4::identidad(), MATRIZ_4x4::M, y tensor_de_inercia_0. Referenciado por leer(), y ESPACIO_ABIERTO::leer_espacio().

Here is the call graph for this function:

void COSA_RIGIDA::set_orientacion_absoluta (  QUATERNION  q  )

OJO: ESTO NO ESTA FUNCIONANDO CUANDO ESTA COSA TIENE PADRE! Definición en la línea 691 del archivo cosa_rigida.C. References _orientacion, y COSA::Padre. Referenciado por actualizar_variable().

void COSA_RIGIDA::set_velocidad_angular_absoluta (  VECTOR  omega  )  [virtual]

Reimplementado de COSA. Definición en la línea 751 del archivo cosa_rigida.C. References _velocidad_angular.

MATRIZ_4x4 COSA_RIGIDA::tensor_de_inercia (  void   )  [virtual]

Reimplementado de COSA. Definición en la línea 760 del archivo cosa_rigida.C. References _orientacion, MATRIZ_4x4::importar_quaternion(), y tensor_de_inercia_0.

Here is the call graph for this function:

void COSA_RIGIDA::tick (  void   )

Definición en la línea 657 del archivo cosa_rigida.C. References COSA::_posicion, VECTOR::x, VECTOR::y, y VECTOR::z.

VECTOR COSA_RIGIDA::velocidad_angular_absoluta (  void   )  [virtual]

Reimplementado de COSA. Definición en la línea 742 del archivo cosa_rigida.C. References _velocidad_angular.

---

Documentación de los datos miembro

VECTOR COSA_RIGIDA::_centro_de_masa [protected]

Definición en la línea 320 del archivo cosa.h. Referenciado por consultar_variable(), y COSA_RIGIDA().

QUATERNION COSA_RIGIDA::_orientacion [protected]

Definición en la línea 322 del archivo cosa.h. Referenciado por actualizar_variable(), consultar_variable(), COSA_RIGIDA(), leer_rigida(), ODE_actualizar_variables_de_estado(), ODE_calcular_la_primera_derivada(), ODE_reportar_variables_de_estado(), orientacion_absoluta(), posicion_absoluta(), set_orientacion_absoluta(), y tensor_de_inercia().

double COSA_RIGIDA::_ultimo_Kd [private]

Definición en la línea 330 del archivo cosa.h. Referenciado por actualizar(), y COSA_RIGIDA().

VECTOR COSA_RIGIDA::_velocidad_angular [protected]

Definición en la línea 321 del archivo cosa.h. Referenciado por actualizar(), aplicar_drag(), COSA_RIGIDA(), grabar(), leer_rigida(), ODE_actualizar_variables_de_estado(), ODE_calcular_la_primera_derivada(), ODE_reportar_variables_de_estado(), set_velocidad_angular_absoluta(), y velocidad_angular_absoluta().

GEOMETRIA* COSA_RIGIDA::Geometria [private]

Definición en la línea 329 del archivo cosa.h. Referenciado por COSA_RIGIDA(), crear_copia(), geometria(), grabar(), interseccion(), leer(), minmax(), pintar_gl(), y pintar_povray().

MATRIZ_4x4 COSA_RIGIDA::tensor_de_inercia_0 [protected]

Definición en la línea 323 del archivo cosa.h. Referenciado por COSA_RIGIDA(), ODE_calcular_la_primera_derivada(), resolver_tensor_de_inercia(), y tensor_de_inercia().

---

La documentación para esta clase fué generada a partir de los siguientes archivos:

• cosa.h
• cosa_rigida.C

---

Este archivo HTML ha sido generado automáticamente a partir del código fuente AQUYNZA. NO LO EDITE. Para mayor información contacte al autor.