/************************************************************************************************

Esta clase calcula la envolvente convexa de una nube de puntos
y triangula sus caras. Esta nube de puntos corresponde a los 
vértices de una caja de una herramienta en los instantes t-1 y t.
  
 ***********************************************************************************************/

#ifndef __vtkEnvolventeTriangulada_h
#define __vtkEnvolventeTriangulada_h

#ifdef _WIN32
#include <algorithm>
#include <math.h>
#else
#include <math.h>
#include <algo.h>
#endif
#include "vtkesquiColDetectWin32Header.h"
#include "vtkObject.h"
#include "Macros.h"
#define UMBRALMOVIMIENTO 0.1f
//! Estructura para almacenar la informacion del vertice de la envolvente de movimiento
typedef struct verticeEnvolvente{
	//! Componente absoluta x 
	float	x;				
	//! Componente absoluta y
	float	y;				
	//! Componente absoluta z
	float	z;				
	//! Puntero a posible array de componentes relativas. MEMORIA DINÁMICA
	float*	xyzRelativos;	

	//! Las siguientes variables indican si las coordenadas del vértice son máximas o mínimas.
	/*! Los valores asignados serán:
		* 0: La coordenada es mínima
		* 1: La coordenada es máxima
		* 2: La coordenada no es ni mínima ni máxima
	*/
	int		rolX;						
	int		rolY;
	int		rolZ;
	
	//! Bandera que indica si el vértice forma parte de la envolvente
	bool	flagEnvolvente;	
}verticeEnvolvente;

//!Clase para manejar la Envolvente del Movimiento usada en la deteccion de colisiones
class VTK_ESQUI_COLDETECT_EXPORT vtkEnvolventeTriangulada: public vtkObject
{

public:
	vtkTypeRevisionMacro(vtkEnvolventeTriangulada, vtkObject);
	static vtkEnvolventeTriangulada *New() {return new vtkEnvolventeTriangulada;};
	const char *GetClassName() {return "vtkEnvolventeTriangulada";};
	
	//========== CONSTRUCTOR Y DESTRUCTOR DE LA HERRAMIENTA =====================================
	vtkEnvolventeTriangulada();
	~vtkEnvolventeTriangulada();

	//!    Vector de desplazamiento relativo. Cada posición corresponde a:
	/*!
			* m_vDesplazamientoRelativo[0]: Desplazamiento en x
			* m_vDesplazamientoRelativo[1]: Desplazamiento en y
			* m_vDesplazamientoRelativo[2]: Desplazamiento en z
			 y se calcula como (coord en t)-(coord en t-1). Los valores serán:
			* 0 : No ha habido desplazamiento
			* +d: Desplazamiento positivo
			* -d: Desplazamiento negativo
	*/
	float m_vDesplazamientoRelativo[3];
	//!	 Matriz que en cada posición contiene una estructura verticeEnvolvente
	/*!
			* En la fila 0 estarán los vértices de la caja en el instante t-1
			* En la fila 1 estarán los vértices de la caja en el instante t
			* Las columnas corresponden a la struct verticeEnvolvente. 
				# Posicion 0 a 3: cara de la caja con z mínima
				# Posicion 4 a 7: cara de la caja con z máxima
	*/
	verticeEnvolvente m_mVertices[2][8];
	





	//========== FUNCIONES DE ACCESO ============================================================

	//!   Funcion que construye la envolvente convexa de dos prismas rectangulares

	void construyeEnvolvente(double* vVerticesIniciales, double* vVerticesFinales,double* vMovimiento,	
												 double* mTransformacion,
												 double *vVerticesEnvolvente);

	//! Calcula la matriz inversa de la matriz de transformacion de la caja t-1
	void setMatrizInversaTransformacion(float *mTransformacion);
	//! Crear la matriz de vertices de forma que estan ordenados de menor a mayor componente z.
	//! Solo es necesario calcularlo para la caja en t-1 ya que en t serán los mismo puntos
	void setMVertices(float* vAnt, float* vAct);
	//! Crea la lista de vértices de la envolvente
	void setVerticesEnvolvente();
	//! Devuelve la matriz inversa de transformacion de la caja
	float* getMatrizInversaTransformacion() {return 0;}
	//! Almacena los vertices de la envolvente en el vector vEnvolvente
	void obtenerVEnvolvente(float* vEnvolvente);
	//******** FUNCIONES DE DEPURACION ********
	//! Devuelve el tiempo que tarda en triangular
	double	getTiempoTrian();	
	//! Devuelve el tiempo que tarda en calcular la envolvente
	double	getTiempoEnv();		
	//! Devuelve el numero de vertices que forman la envolvente
	int		getSizeEnv();		


private:

	//========== VARIABLES MIEMBRO ==============================================================

	//--- Matriz que en cada posición contiene una estructura verticeEnvolvente
	//---	* En la fila 0 estarán los vértices de la caja en el instante t-1
	//---	* En la fila 1 estarán los vértices de la caja en el instante t
	//---	* Las columnas corresponden a la struct verticeEnvolvente. 
	//---		# Posicion 0 a 3: cara de la caja con z mínima
	//---		# Posicion 4 a 7: cara de la caja con z máxima
//	verticeEnvolvente m_mVertices[2][8];
	//! Matriz inversa de transformacion de la caja.
	/*!
		La matriz de transformacin A de la caja es un float matriz[16] almacenado en
		vtkModeloGeometrico y que representa el giro y desplazamiento de los vertices
		de la caja desde el sistema de coordenadas local a la misma (con origen el 
		centro de la caja) al sistema de coordenadas global. Con lo que:
		* (1/A)·verticeGlobal[i] = verticeLocal[i]
	*/
	float m_mInversaTransformacion[16];
	//! Vector de coordenadas x relativas
	float m_coordX[8];
	//! Vector de coordenadas y relativas
	float m_coordY[8];
	//! Numero de vértices que forman la envolvente convexa
	int m_numVerticesEnvolvente;

	//******** ATRIBUTOS DE DEPURACIÓN ********
	//! Tiempo que tarda en triangular
	double m_ttrian;						
	//! Tiempo que tarda en calcular la envolvente
	double m_tenv;							


	//========== FUNCIONES DE OPERACIÓN =========================================================

	//! Calcular las coordenadas relativas de la cara que minimiza z de cada caja
	void aplicaMatrizInversaTransformacion() {};
	//! Ordena los vectores de modo que la coordenada z vaya de menor a mayor
	/*! 
		Ordena los vectores de modo que la coordenada z vaya de menor a mayor
		con lo que las 4 primeras posiciones formarán la cara de la caja que minimiza z y las
		4 siguientes la cara de la caja que maximiza z de forma local
	*/
	void setPosOrdenadas(float* vAnt, int* vPosOrdenadas); 
	//! Funcion que ordena las posiciones de vAnt de menor a mayor coordenada z
	void intercambia(int j, int* vPosOrdenadas, float* vAnt); 
	//! Calcula las coordenadas relativas de los 8 vertices con z minima
	void setXYZRelativas();
	//! Comprobar sobre qué ejes se ha producido un desplazamiento entre las cajas
	void setDesplazamientoRelativo();
	//! Activa los flags de los vertices de m_matrizVertices que tienen,al menos,una coordenada
	/*
		Activa los flags de los vertices de m_matrizVertices que tienen,al menos,una coordenada
	    (abcisa, ordenada o cota) extrema(máxima o mínima) con la excepción de que para la cota
	    nos quedamos sólo con los mín(los máx estarán en la cara trasera de la otra caja)
	    sobre los ejes relativos. Estos puntos, junto con los correspondientes de la cara 
		trasera seran los que formen la envolvente convexa.
	*/
	void activarFlagsEnvolvente();
	//! Activa los flags de la envolvente debidos a que la coordenada X sea max o min
	void setMaxMinX();
	//! Activa los flags de la envolvente debidos a que la coordenada Y sea max o min
	void setMaxMinY();
	//! Activa los flags de la envolvente debidos a que la coordenada Z sea max o min
	void setMaxMinZ();

};//class EnvolventeTriangulada
#endif