/* -------------------- Program: ESQUI Info and Bugs: {marf,rsantana}@ctm.ulpgc.es ------------------------------------------- Copyright (c) 2006, Center for Technology in Medicine, University of Las Palmas de Gran Canaria (Canary Islands, Spain). All rights reserved. This program is free software; you can redistribute it and/or modify it under the terms of the Creative Commons' "by-attribution" license (http://creativecommons.org/licenses/by/2.5). Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. =============================================================================*/ #ifndef _COLDETECT_v10_ #define _COLDETECT_v10_ ////////////////////////////////////////////// /// Aqui los ficheros de inclusion necesarios #include "vtkLibGenerica.h" #include "vtkColDetection.h" #include "vtkEnvolventeTriangulada.h"// #include "MathGlobal.h" #include "vtkesquiColisionWin32Header.h" #include #include "Macros.h" static const double UMBRALPENETRACION=0.7; class vtkInfoColisionCollection; //! Clase que se encarga de la utilizacion de la libreria ColDetection desarrollada por el INRIA. class VTK_ESQUI_COLISION_EXPORT vtkColDetect: public vtkLibGenerica, public vtkColDetection { //***** Atributos Privados protected: //! Vector que almacena los identificadores locales de los objetos deformables /*! Valor = ident. del objeto en ColDetection */ std::vector IdDeformables; //! Vector que almacena los identificadores locales de los objetos estaticos /*! Valor = ident. del objeto en ColDetection */ std::vector IdEstaticos; //! Vector que almacena los identificadores locales de las herramientas /*! Valor = ident. del objeto en ColDetection */ std::vector IdHerramientas; //! Vector que almacena los modelos de colisiones para los modelos deformables std::vector VectorDeDeformables; //double vectorDeMovimiento[3]; //Vector de movimiento del centro de la caja de inclusion de la herramienta*** //***** Metodos Publicos public: vtkTypeRevisionMacro(vtkColDetect, vtkLibGenerica); static vtkColDetect *New(); const char *GetClassName() {return "vtkColDetect";}; /// ---------- Constructor / Destructor ----------- //! Constructor por defecto vtkColDetect(); ~vtkColDetect(); //! Inicializa la libreria, reservando el espacio de memoria necesario bool inicializar(); //BTX //! Obtiene los identificadores de los objetos que intervienen en la colision unsigned obtenerIdColisiones(unsigned idOrgano, unsigned idH, unsigned idCaja, unsigned tipoEnvolvente); //! Obtiene el identificador de la colision unsigned posIdColisiones(unsigned idOrgano, unsigned idH, unsigned idCaja); //ETX //! Crea los arboles de colisiones void crearArbolesColisionOrgano(unsigned idOrgano); //! Crea los arboles de colisiones void crearArbolesColisionHerramienta(unsigned idH, unsigned idCaja, unsigned tipoEnvolvente); // El orden de los objetos deformables es igual en este vector IdDeformables y en el vector de la clase vtkColision VectorDeDeformables //! Agnade un organo deformable a la libreria de colisiones int anadirDeformable(vtkModeloDeformable* pDeformable); //! Agnade una herramienta a la libreria de colisiones int anadirHerramienta(vtkModeloHerramienta* pHerramienta); //! Agnade un elemento estatico a la libreria de colisiones int anadirEstatico(vtkModeloEstatico* pEstatico); /// Esta libreria no permite eliminar los objetos /// por eso los metodos se encuentran vacios bool eliminarDeformable(int pos); bool eliminarHerramienta(int pos); bool eliminarEstatico(int pos); //! Agnade un organo deformable a la libreria de colisiones en una posicion dada bool insertarDeformable(int pos,vtkModeloDeformable* pDeformable); //! Agnade una herramienta a la libreria de colisiones en una posicion dada bool insertarHerramienta(int pos,vtkModeloHerramienta* pHerramienta, bool bNueva = false); //! Agnade un elemento estatico a la libreria de colisiones en una posicion dada bool insertarEstatico(int pos,vtkModeloEstatico* pEstatico); //BTX //! Detecta colisiones entre un organos y herramientas bool detectarColisionOrganoHerramienta( unsigned idCol, unsigned idOrgano, unsigned idHerramienta, unsigned idCaja, vtkInfoColisionCollection *vColisiones, std::vector& lista, vtkOBB caja); //ETX bool detectaColisionBolaHerramienta(unsigned int herramActual, vtkEsfera *bola); //bool detectarColisionHerramientas(unsigned id1, unsigned id2, vector &vertices); //BTX double* obtenerMatriz(unsigned id); unsigned idDeformable(unsigned id); unsigned idHerramienta(unsigned id); unsigned idCajaHerramienta(unsigned idHerr, unsigned idCaja); //**Emma unsigned idEnvolventeCajaHerramienta(unsigned idHerr, unsigned idCaja, unsigned idEnvolvente);//EMMA unsigned idEstatico(unsigned id); //ETX //! Devuelve en el parametro posicion un vector de tres float. La memoria debe reservarse antes de la llamada. void obtenerPosAnteriorCaja(unsigned id, unsigned caja, float* posicion); //! Devuelve en el parametro posicion un vector de tres float. La memoria debe reservarse antes de la llamada. void obtenerPosCaja(unsigned id, float* posicion); //BTX //! Obtiene en el parametro vertices, los vertices de la cara del modelo dado void obtenerVertices(unsigned id, unsigned cara, unsigned* vertices); //! Obtiene en el parametro coord, las componentes del vertice proporcionado void coordenadasVertices(unsigned id, unsigned vertice, float* coord); //! Calcula la normal void calcularNormal(float *verticeA, float *verticeB, float *verticeC, float *normal); //! Calcula la media de las normales void calcularMediaNormales(unsigned id, std::vector caras, float* mediaNormales); unsigned calcularPlanoDestino(unsigned id, unsigned idCaja, std::vector carasColisionHerramienta, double *normalCarasHerramienta, std::vector carasColisionOrgano, unsigned idOrg); void calcularNormalCarasHerramienta(unsigned idH, unsigned idCaja, double *normalCarasHerramienta); void obtenerVerticePlano(unsigned* verticesPlanoDestino, unsigned indicePlanoDestino); unsigned identificarPenetracionDeslizamiento(double indicePenetracion, double *planoDestinoVertices, int numCarasColision, bool primeraPenetracion); //*** /EvitarNormalesOrgano void crearVectorDeMovimiento(double *verticesPasoAnterior, double *verticesPasoActual); void crearVectorDoceVertices(double vector[], vtkModeloHerramienta* pHerramienta, unsigned posicion); void crearVectorCatorceVertices(double vector[], vtkModeloHerramienta* pHerramienta, unsigned posicion); void construirVectorColisiones(float* normal, float* punto, std::vector carasColisionOrgano, unsigned idH, unsigned idCaja, unsigned idOrgano, vtkInfoColisionCollection* vColisiones, std::vector &lista, bool pinzamiento); void construirVectorColisionesPuntosFijos(std::vector carasColisionOrgano,unsigned idH, unsigned idCaja, unsigned idOrgano, vtkInfoColisionCollection* vColisiones, std::vector &listaVerticesOrgano); //ETX //***** Metodos Privados private: //! Convierte un vector de float a una vector de double void convertirADouble(float* vectorDeFloat, unsigned longitud, double* vectorDeDouble); //! Convierte la matriz de transformacion de float a double void convertirMatrizTransformacion(float* matrizDeFloat, unsigned longitud, double** matrizDeDouble); //! Convierte la matriz de transformacion de double a float void convertirMatrizTransformacionDoubleFloat(double** matrizDeDouble, float* matrizDeFloat); //! Crea el vector de vertices de un vtkOBB void crearVectorVertices(double vector[], vtkModeloHerramienta* pHerramienta, unsigned posicion); //! Crea el vector de vertices de un vtkAABB void crearVectorVertices(double vector[], vtkModeloEstatico* pEstatico); //! Crea las caras de una caja void configurarCarasHerramienta(unsigned id); void configurarCarasEnvolventeDoce(unsigned id); void configurarCarasEnvolventeCatorce(unsigned id); void configurarCarasEstatico(unsigned id); float obtenerPosAnteriorCajaX(unsigned id, unsigned caja); // // Funciones para forma VTK // private: vtkColDetect(const vtkColDetect &); //NotImplemented vtkColDetect operator =(const vtkColDetect &); //Not Implemented }; #endif