git-svn-id: svn+ssh://lulu.fing.edu.uy/ens/home01/pgperui/repoSVN@175 65703dd9-322d-4ecd-a169-f49c4620ba53

6 files changed, 485 insertions, 132 deletions

diff --git a/Utilidades/src/Estructuras.h b/Utilidades/src/Estructuras.h
index 88b6ace..9d3d018 100644
--- a/Utilidades/src/Estructuras.h
+++ b/Utilidades/src/Estructuras.h
@@ -28,10 +28,7 @@ typedef struct {
 	HistogramasData data_histogramas;
 	RangosColorApuntador resultado_rangos_color;	//Resultados de la calibracion por color
 
-	//int tomar_muestra;					//Cuando se quiera tomar una muestra dentro de la mascara generada debe ponerse en 1
-	//int aplicar_mascara;				//Cuando se quiera aplicar la mascara a la imagen debe ponerse en 1
 	int debug_imagenes;					//Cuando se quiera ver las imagenes de uso interno del calibrador (imagen enmascarada y mascara) debe ponerse en 1
-	//int aplicar_nueva_mascara;			//Cuando se quiera calcular y aplicar una nueva a la imagen debe ponerse en 1
 	int restarAlRadio;					//Este valor se usa para restar al radio del circulo de las mascaras circulares y achicarlas para poder calibrar objetos mas pequenos que los marcadores. Por defecto es 0
 
 /*Calibracion de la relacion marcador-apuntador*/
@@ -47,6 +44,15 @@ typedef struct {
 }PropiedadesCalibracion;
 
 typedef struct {
+	int min_area;
+	float factorProporcionApuntadorMarcador;
+	int erode;
+	int dilate;
+	int smooth;
+	int enclosing_circle;
+}PropiedadesDeteccionApuntador;
+
+typedef struct {
 	CvPoint2D32f centro;
 	float radio;
 } Circle;
diff --git a/Utilidades/src/EstructurasPublicas.h b/Utilidades/src/EstructurasPublicas.h
index 06c7e15..10af15f 100644
--- a/Utilidades/src/EstructurasPublicas.h
+++ b/Utilidades/src/EstructurasPublicas.h
@@ -28,6 +28,14 @@ typedef struct {
 	int idImagenSDL;
 }Elemento;
 
+
+typedef struct {
+	Elemento* objetosPUI;
+	int max_elementos;
+	char* soundOK;
+	char* soundError;
+}PUI_Multimodal;
+
 typedef struct {
 	int tope;
 	int cantHistorico;
diff --git a/Utilidades/src/Pui.cpp b/Utilidades/src/Pui.cpp
index 2b064d7..4c49ddd 100644
--- a/Utilidades/src/Pui.cpp
+++ b/Utilidades/src/Pui.cpp
@@ -130,7 +130,9 @@ void Pui::obtenerCoordenadasIdealesMarcadorNoDetectado(double markerToCameraMatr
 	}
 }
 
-int Pui::leerConfiguracionElementos(const char* archivoConfiguracion,  Elemento* elementos, int MAX_ELEMENTOS, char * clickSound, char *errorSound){
+int Pui::leerConfiguracionObjetosPUI(const char* archivoConfiguracion,int max_elementos){
+	this->multimodalInfo.objetosPUI = new Elemento[max_elementos];
+	this->multimodalInfo.max_elementos = max_elementos;
 	FILE *fich;
 	char c = '#';
 	char str[255];
@@ -140,7 +142,7 @@ int Pui::leerConfiguracionElementos(const char* archivoConfiguracion,  Elemento*
 	int id=-1;
 	if(fich != NULL) {
 		int i=0;
-		while((c!=EOF)&&(i<=MAX_ELEMENTOS)){
+		while((c!=EOF)&&(i<=max_elementos)){
 			if( fscanf(fich,"%c",&c) < 0){
 				break;
 			}
@@ -150,8 +152,8 @@ int Pui::leerConfiguracionElementos(const char* archivoConfiguracion,  Elemento*
 						fscanf(fich,"%c",&c);
 					}
 				}else if(c=='&'){
-					fscanf(fich,"%s\n",clickSound);
-					fscanf(fich,"%s\n",errorSound);
+					fscanf(fich,"%s\n",this->multimodalInfo.soundOK);
+					fscanf(fich,"%s\n",this->multimodalInfo.soundError);
 				}else{
 					fseek(fich, -1, SEEK_CUR);
 					fscanf(fich,"%d",&id);
@@ -168,20 +170,20 @@ int Pui::leerConfiguracionElementos(const char* archivoConfiguracion,  Elemento*
 						}
 						break;
 					}else{
-						elementos[i].idPatt = id;
+						this->multimodalInfo.objetosPUI[i].idPatt = id;
 						fgetc(fich);//consumo fin de linea
 
-						fscanf(fich,"%s\n",&elementos[i].imagen);
-						fscanf(fich,"%s\n",&elementos[i].sonido);
-						fscanf(fich,"%s\n",&elementos[i].nombre);
-						fscanf(fich,"%d",&elementos[i].conjunto);
+						fscanf(fich,"%s\n",&this->multimodalInfo.objetosPUI[i].imagen);
+						fscanf(fich,"%s\n",&this->multimodalInfo.objetosPUI[i].sonido);
+						fscanf(fich,"%s\n",&this->multimodalInfo.objetosPUI[i].nombre);
+						fscanf(fich,"%d",&this->multimodalInfo.objetosPUI[i].conjunto);
 						fgetc(fich); //consumo fin de linea
-						fscanf(fich,"%d",&elementos[i].idElementoRelacionado);
+						fscanf(fich,"%d",&this->multimodalInfo.objetosPUI[i].idElementoRelacionado);
 						fgetc(fich); //consumo fin de linea
 
-						largo = fscanf(fich,"%s\n",&elementos[i].nombreRelacion);
+						largo = fscanf(fich,"%s\n",&this->multimodalInfo.objetosPUI[i].nombreRelacion);
 
-						elementos[i].idImagenSDL = -1;
+						this->multimodalInfo.objetosPUI[i].idImagenSDL = -1;
 
 						fscanf(fich,"%c",&c);
 						//fscanf(fich,"%c",&c);
@@ -196,10 +198,7 @@ int Pui::leerConfiguracionElementos(const char* archivoConfiguracion,  Elemento*
 			}
 		}
 		fclose(fich);
-		if(i>MAX_ELEMENTOS){
-			printf("Demasiados elementos cargados. El maximo permitido es %d \n",MAX_ELEMENTOS);
-			res = 0;
-		}else if(res>0){
+		if(res>0){
 			res = i; //Retorna la CANTIDAD de elementos, por eso hay que sumar 1
 		}
 	}else{
@@ -208,6 +207,77 @@ int Pui::leerConfiguracionElementos(const char* archivoConfiguracion,  Elemento*
 	return res;
 }
 
+
+char * Pui::getNombreObjetoPUI(int idObjeto){
+	if(idObjeto< this->multimodalInfo.max_elementos){
+		return this->multimodalInfo.objetosPUI[idObjeto].nombre;
+	}else{
+		return "";
+	}
+}
+
+char * Pui::getSonidoObjetoPUI(int idObjeto){
+	if(idObjeto< this->multimodalInfo.max_elementos){
+		return this->multimodalInfo.objetosPUI[idObjeto].sonido;
+	}else{
+		return "";
+	}
+}
+
+
+char * Pui::getImagenObjetoPUI(int idObjeto){
+	if(idObjeto< this->multimodalInfo.max_elementos){
+		return this->multimodalInfo.objetosPUI[idObjeto].imagen;
+	}else{
+		return "";
+	}
+}
+
+/**
+ * Retorna true si y solo si el objeto1 esta relacionado con el objeto2
+ * objeto1---->objeto2
+ * No tiene porque cumplirse la coondicion inversa ( objeto2--->objeto1)
+ */
+bool Pui::esRelacionCorrecta(int idObjeto1,int idObjeto2){
+	bool res = false;
+	if(idObjeto1< this->multimodalInfo.max_elementos && idObjeto2< this->multimodalInfo.max_elementos){
+		res =  this->multimodalInfo.objetosPUI[idObjeto1].idElementoRelacionado == idObjeto2;
+	}
+	return res;
+}
+
+int Pui::getConjuntoObjetoPui(int idObjeto){
+	if(idObjeto< this->multimodalInfo.max_elementos){
+		return this->multimodalInfo.objetosPUI[idObjeto].conjunto;
+	}else{
+		return -1;
+	}
+}
+
+int Pui::getIdElementoRelacionado(int idObjeto){
+	if(idObjeto< this->multimodalInfo.max_elementos){
+		return this->multimodalInfo.objetosPUI[idObjeto].idElementoRelacionado;
+	}else{
+		return -1;
+	}
+}
+
+char* Pui::getNombreRelacionObjetoPUI(int idObjeto){
+	if(idObjeto< this->multimodalInfo.max_elementos){
+		return this->multimodalInfo.objetosPUI[idObjeto].nombreRelacion;
+	}else{
+		return "";
+	}
+}
+
+char* Pui::getSonidoError(){
+	return this->multimodalInfo.soundError;
+}
+
+char* Pui::getSonidoOk(){
+	return this->multimodalInfo.soundOK;
+}
+
 int Pui::leerConfiguracionCalibracion(const char* archivoConfiguracion, int cantMarcadores, char** imagenes){
 		FILE *fich;
 		char c = '#';
@@ -242,18 +312,49 @@ int Pui::leerConfiguracionCalibracion(const char* archivoConfiguracion, int cant
 		return res;
 }
 
-void Pui::imprimirPropiedadesElementos(Elemento* elementos,int cantidadElementos){
+void Pui::imprimirPropiedadesObjetosPUI(){
 	int i;
-	for(i=0;i<cantidadElementos;i++){
-		printf("IdPatt=%d\n",elementos[i].idPatt);
-		printf("IdPattElementoRelacionado=%d\n",elementos[i].idElementoRelacionado);
-		printf("Nombre=%s\n",elementos[i].nombre);
-		printf("NombreRelacion=%s\n",elementos[i].nombreRelacion);
-		printf("Imagen=%s\n",elementos[i].imagen);
-		printf("IdImagenSDL=%d\n",elementos[i].idImagenSDL);
-		printf("Sonido=%s\n",elementos[i].sonido);
-		printf("Conjunto=%d\n",elementos[i].conjunto);
+	for(i=0;i<this->multimodalInfo.max_elementos;i++){
+		printf("IdPatt=%d\n",this->multimodalInfo.objetosPUI[i].idPatt);
+		printf("IdPattElementoRelacionado=%d\n",this->multimodalInfo.objetosPUI[i].idElementoRelacionado);
+		printf("Nombre=%s\n",this->multimodalInfo.objetosPUI[i].nombre);
+		printf("NombreRelacion=%s\n",this->multimodalInfo.objetosPUI[i].nombreRelacion);
+		printf("Imagen=%s\n",this->multimodalInfo.objetosPUI[i].imagen);
+		printf("IdImagenSDL=%d\n",this->multimodalInfo.objetosPUI[i].idImagenSDL);
+		printf("Sonido=%s\n",this->multimodalInfo.objetosPUI[i].sonido);
+		printf("Conjunto=%d\n",this->multimodalInfo.objetosPUI[i].conjunto);
+	}
+}
+
+int Pui::detectarSeleccion(){
+	int resultado = -1;
+	if(this->dataArtoolkit.marker_num>0){
+		for(int i = 0; i < this->dataArtoolkit.config->marker_num; i++ ) {
+			if( (this->dataArtoolkit.coordenadas_marcadores[i].visible<=0)){
+
+				double areaZonaEstudio = 0;
+				float area = hayApuntador(this->propiedades.resultado_rangos_color,this->dataArtoolkit.coordenadas_marcadores[i].vertex,
+										  OFFSET_ROI,this->dataArtoolkit.dataPtr,this->imageColorApuntador,this->imageMonoApuntador,
+										  MIN_AREA_WIDTH_HEIGHT,this->propiedadesDeteccion.min_area,this->propiedadesDeteccion.factorProporcionApuntadorMarcador,
+										  this->propiedadesDeteccion.erode,this->propiedadesDeteccion.dilate,this->propiedadesDeteccion.smooth,
+										  this->propiedadesDeteccion.enclosing_circle,&areaZonaEstudio,"Debug Image","ROI Image");
+
+				if(area>0){
+					int cant =0;
+					if(this->historicoHabilitado){
+						cant = registrarColision(i);
+					}
+					if(cant>=this->historico.cantHistorico || !this->historicoHabilitado){
+						resultado=i;
+						break;				// Cuando se detecta la primera colision ya frenamos
+					}else if(this->debugMode){
+						printf("Colision nro %d con marcador %d\n",cant,i);
+					}
+				}
+			}
+		}
 	}
+	return resultado;
 }
 
 void Pui::habilitarHistorico(bool habilitar,int cantHistorico,int valorInicial){
@@ -1338,6 +1439,72 @@ int Pui::calcularResultadosCalibracionApuntador(int factorThreshH,int minPorcent
 	}
 }
 
+int Pui::cargarConfiguracionDeteccionApuntadorDesdeArchivo(char * fileName) {
+	FILE *fich;
+	char c;
+	fich=fopen(fileName,"r");
+	if(fich != NULL) {
+		fscanf(fich," %c",&c);
+		if(c=='#'){ //si el separador es correcto y no es fin de fichero carga valores;
+			fscanf(fich,"%d",&this->propiedades.resultado_rangos_color.hmin);
+			fscanf(fich,"%d",&this->propiedades.resultado_rangos_color.hmax);
+			fscanf(fich,"%d",&this->propiedades.resultado_rangos_color.smin);
+			fscanf(fich,"%d",&this->propiedades.resultado_rangos_color.smax);
+			fscanf(fich,"%d",&this->propiedades.resultado_rangos_color.vmin);
+			fscanf(fich,"%d",&this->propiedades.resultado_rangos_color.vmax);
+			fscanf(fich,"%d",&this->propiedadesDeteccion.min_area);
+			fscanf(fich,"%f",&this->propiedadesDeteccion.factorProporcionApuntadorMarcador);
+			fscanf(fich,"%d",&this->propiedadesDeteccion.erode);
+			fscanf(fich,"%d",&this->propiedadesDeteccion.dilate);
+			fscanf(fich,"%d",&this->propiedadesDeteccion.smooth);
+			fscanf(fich,"%d",&this->propiedadesDeteccion.enclosing_circle);
+		}
+		fclose(fich);
+		printf("*** Configuración HSV cargada ***\n");
+		printf("minH = %d , maxH = %d\n",this->propiedades.resultado_rangos_color.hmin,this->propiedades.resultado_rangos_color.hmax);
+		printf("minS = %d , maxS = %d\n",this->propiedades.resultado_rangos_color.smin,this->propiedades.resultado_rangos_color.smax);
+		printf("minB = %d , maxB = %d\n",this->propiedades.resultado_rangos_color.vmin,this->propiedades.resultado_rangos_color.vmax);
+		printf("*** Configuración del algoritmo de detección del apuntador ***\n");
+		printf("Area mínima del aputnador = %d\n",this->propiedadesDeteccion.min_area);
+		printf("Proporción Máxima (area marcador/area apuntador) = %f\n",this->propiedadesDeteccion.factorProporcionApuntadorMarcador);
+		printf("Erode = %d\n",this->propiedadesDeteccion.erode);
+		printf("Dilate = %d\n",this->propiedadesDeteccion.dilate);
+		printf("Smooth = %d\n",this->propiedadesDeteccion.smooth);
+		if(this->propiedadesDeteccion.enclosing_circle){
+			printf("Se utiliza algoritmo con Enclosing Circle\n ");
+		}else{
+			printf("NO se utiliza algoritmo con Enclosing Circle\n ");
+		}
+
+		return 1;
+	}else{
+		printf("Se usaran los valores por defecto, el motivo es: No se puede leer el archivo de configuracion\n");
+	}
+	return 0;
+}
+
+
+void Pui::initImagenesOpenCVApuntador(){
+	/*Estas imagenes seran procesadas por funciones de opencv para detectar el apuntador*/
+	this->imageColorApuntador =  crearImagenCv2((uchar*)this->dataArtoolkit.dataPtr,this->dataArtoolkit.xsize,this->dataArtoolkit.ysize);
+	this->imageMonoApuntador = cvCreateImage( cvGetSize(this->imageColorApuntador), 8, 3 );//convertImageRGBtoHSV(imageColor);
+}
+
+int Pui::initDeteccionApuntador(char* configuracionFileName){
+	int res = cargarConfiguracionDeteccionApuntadorDesdeArchivo(configuracionFileName);
+	if(res){
+		initImagenesOpenCVApuntador();
+	}
+	return res;
+}
+
+void Pui::initDeteccionApuntador(PropiedadesDeteccionApuntador propiedadesDeteccion,RangosColorApuntador rangosColorApuntador){
+	this->propiedadesDeteccion = propiedadesDeteccion;
+	this->propiedades.resultado_rangos_color = rangosColorApuntador;
+
+	initImagenesOpenCVApuntador();
+}
+
 void Pui::initARConVideo(char * config_name,char * camera_para,char *vconf,int usarAlgoritmoRapido,int loopSpeed,double zoom){
 	printf("initARConVideo!\n");
 	ARParam  wparam;
@@ -1390,18 +1557,11 @@ void Pui::initARConVideo(char * config_name,char * camera_para,char *vconf,int u
 		this->dataArtoolkit.coordenadas_marcadores = new ARCoordMarcador[this->dataArtoolkit.config->marker_num];
     }
 
-    /* open the graphics window */
     zoomFactor = zoom;
 
-    //argInit( &(this->dataArtoolkit.cparam), zoom, 0, 2, 1, 0 );
-
-
     arFittingMode   = AR_FITTING_TO_IDEAL;
 	arImageProcMode = AR_IMAGE_PROC_IN_FULL;
 
-	//argDrawMode     = AR_DRAW_BY_TEXTURE_MAPPING;
-    //argTexmapMode   = AR_DRAW_TEXTURE_HALF_IMAGE;
-
     this->dataArtoolkit.usarAlgoritmoLite = usarAlgoritmoRapido;
     this->dataArtoolkit.thresh = 100;
 
@@ -1410,9 +1570,39 @@ void Pui::initARConVideo(char * config_name,char * camera_para,char *vconf,int u
 
     timeUtils->utilTimerReset();
     image_has_updated = false;
+}
+
 
+/****Init Principal****/
+void Pui::initPuiConCapturaDeVideo(PropiedadesDeteccionApuntador propiedadesDeteccion,RangosColorApuntador rangosColorApuntador,char * config_name,char * camera_para,char *vconf,int usarAlgoritmoRapido,int loopSpeed,double zoom){
+	this->initARConVideo(config_name,camera_para,vconf,usarAlgoritmoRapido,loopSpeed,zoom);//no modificar el orden de las invocaciones!
+	this->initDeteccionApuntador(propiedadesDeteccion,rangosColorApuntador);
 }
 
+/****Init Principal desde archivo de Configuracion****/
+void Pui::initPuiConCapturaDeVideo(char* configuracionFileName,char * config_name,char * camera_para,char *vconf,int usarAlgoritmoRapido,int loopSpeed,double zoom){
+	this->initARConVideo(config_name,camera_para,vconf,usarAlgoritmoRapido,loopSpeed,zoom);//no modificar el orden de las invocaciones!
+	this->initDeteccionApuntador(configuracionFileName);
+}
+
+
+PropiedadesDeteccionApuntador Pui::getPropiedadesDeteccionApuntador(){
+	return this->propiedadesDeteccion;
+}
+
+RangosColorApuntador Pui::getPropiedadesColorApuntador(){
+	return this->propiedades.resultado_rangos_color;
+}
+
+void Pui::setPropiedadesDeteccionApuntador(PropiedadesDeteccionApuntador propiedadesDeteccion){
+	this->propiedadesDeteccion = propiedadesDeteccion;
+}
+
+void Pui::setPropiedadesColorApuntador(RangosColorApuntador rangosColorApuntador){
+	this->propiedades.resultado_rangos_color = rangosColorApuntador;
+}
+
+
 
 void Pui::abrirVentanaGrafica(){
 #ifdef GLUT_HABILITADO
diff --git a/Utilidades/src/Pui.h b/Utilidades/src/Pui.h
index 6fa0aa0..5ef6c44 100644
--- a/Utilidades/src/Pui.h
+++ b/Utilidades/src/Pui.h
@@ -24,8 +24,6 @@
 #include "cvUtilities.h"
 #include "Estructuras.h"
 #include "Funciones.h"
-//#include "Estructuras_wrapp.h"
-
 
 #ifndef PUI_H_
 #define PUI_H_
@@ -50,6 +48,10 @@
 #define ERROR_TOMAR_MUESTRA_FORMA_NO_IMPLEMENTADA 13
 #define ERROR_TOMAR_MUESTRA_OK 14
 
+#define OFFSET_ROI 5			//Cuanto mas grande mas grande sera el ROI donde busco el apuntador
+#define MIN_AREA_WIDTH_HEIGHT 5	//Este valor sirve para indicar cual es el area minima en la cual se busca un apuntador.
+								//Por ejemplo si el marcador se encuentra apenas dentro de la pantalla y el height o el width no superan este valor entonces
+								//el area no sera analizada en busca de un apuntador
 
 
 	typedef struct binary_data {
@@ -57,11 +59,6 @@
 		unsigned char* data;
 	} binary_data;
 
-
-
-
-	//Definicion de estructuras
-	//TODO mover estas estructuras a otro archivo
 	typedef struct {
 		ARUint8 *dataPtr;	/*Imagen RBG*/
 		ARMultiMarkerInfoT  *config;/*Estructura donde se almacena la informacion de configuracion de los marcadores y las matrices de transformacion*/
@@ -92,6 +89,11 @@ private:
 	char			*vconfUtil;
 	int count;
 
+	/*Imagenes de uso interno para la deteccion del apuntador*/
+	IplImage* imageColorApuntador;
+	IplImage* imageMonoApuntador;
+
+
 	/*Imagenes openCV de uso interno del calibrador*/
 	IplImage* imageColor;
 	IplImage* imageHsv;
@@ -116,6 +118,10 @@ private:
 
 	PropiedadesCalibracion propiedades;
 	ResultadosCalibracion resultados;
+	PropiedadesDeteccionApuntador propiedadesDeteccion;
+
+	PUI_Multimodal multimodalInfo;
+
 	int cantidad_marcadores_calib ;
 
 	bool historicoHabilitado; //FIXME hacer setter y getter
@@ -149,143 +155,173 @@ public:
 	Pui();
 	virtual ~Pui();
 
-	//Se sacan los parametros propiedades y resultados. Los manejara internamente PUI
-	//void initPropiedadesCalibracion(int veces_por_marcador,PropiedadesCalibracion *propiedades,ResultadosCalibracion *resultados, int cant_marcadores, int metodo,int debug);
+			/************************************** Manejo de Objetos PUI **************************************/
+	int leerConfiguracionObjetosPUI(const char* archivoConfiguracion,int max_elementos);
+	void imprimirPropiedadesObjetosPUI();
 
-	void initPropiedadesCalibracion(int veces_por_marcador, int cant_marcadores, int metodo,int debug);
+	/*Obtener propiedades de los objetos PUI*/
+	char * getNombreObjetoPUI(int idObjeto);
 
+	char * getSonidoObjetoPUI(int idObjeto);
 
+	char * getImagenObjetoPUI(int idObjeto);
 
-	int leerConfiguracionElementos(const char* archivoConfiguracion,  Elemento* elementos, int MAX_ELEMENTOS, char * clickSound, char *errorSound);
+	char* getSonidoError();
 
-	int leerConfiguracionCalibracion(const char* archivoConfiguracion, int cantMarcadores, char** imagenes);
+	char* getSonidoOk();
 
-	void imprimirPropiedadesElementos(Elemento* elementos,int cantidadElementos);
+	/**
+	 * Retorna true si y solo si el objeto1 esta relacionado con el objeto2
+	 * objeto1---->objeto2
+	 * No tiene porque cumplirse la coondicion inversa ( objeto2--->objeto1)
+	 */
+	bool esRelacionCorrecta(int idObjeto1,int idObjeto2);
 
-	//NUEVA indica a la clase PUI si debe llevar el historico y cual es el nro para
-	//considerar un hit
-	void habilitarHistorico(bool habilitar,int cantHistorico,int valorInicial);
+	int getConjuntoObjetoPui(int idObjeto);
 
+	int getIdElementoRelacionado(int idObjeto);
 
-	//FIXME se sacan todos los parametros que son manejados internamente
-	//void procesarDatosCalibracion(PropiedadesCalibracion *propiedades,ResultadosCalibracion *resultados, int cantidad_marcadores);
+	char * getNombreRelacionObjetoPUI(int idObjeto);
 
-	void procesarDatosCalibracion();
+	/*Si hay algun apuntador tocando un marcador entonces devuelve el indice del marcador,
+	 * de lo contrario retorna -1*/
+	int detectarSeleccion();
+
+	void initDeteccionApuntador(PropiedadesDeteccionApuntador propiedadesDeteccion,RangosColorApuntador rangosColorApuntador);
+
+	int initDeteccionApuntador(char* configuracionFileName);
+
+	int cargarConfiguracionDeteccionApuntadorDesdeArchivo(char * fileName);
 
-	//FIXME se sacan todos los parametros que son manejados internamente
-	//void guardarDatosCalibracion(ResultadosCalibracion *resultados,const char* nombreArchivo,int cantidad_marcadores);
+	void initImagenesOpenCVApuntador();
+
+	PropiedadesDeteccionApuntador getPropiedadesDeteccionApuntador();
+
+	RangosColorApuntador getPropiedadesColorApuntador();
+
+	void setPropiedadesDeteccionApuntador(PropiedadesDeteccionApuntador propiedadesDeteccion);
+
+	void setPropiedadesColorApuntador(RangosColorApuntador rangosColorApuntador);
+
+	void setHminApuntador(int hMin);
+	int getHminApuntador();
+
+	void setHmaxApuntador(int hMax);
+	int getHmaxApuntador();
+
+	void setSminApuntador(int vMin);
+	int getSminApuntador();
+
+	void setSmaxApuntador(int vMax);
+	int getSmaxApuntador();
+
+	void setVminApuntador(int vMin);
+	int getVminApuntador();
+
+	void setVmaxApuntador(int vMax);
+	int getVmaxApuntador();
+
+			/***************************************************************************************************/
+
+
+		   /***************************  Calibracion de Proporcion apuntador-marcador  ***********************/
+
+	void procesarDatosCalibracion();
 
 	void guardarDatosCalibracion(const char* nombreArchivo);
 
-	//FIXME no queda y ya no se usa mas
-	/**
-	 * busca el apuntador en toda la imagen
-	 * */
-	//int detectarApuntador(ARUint8 *dataPtr,int invert,int minH,int maxH,int minS, int maxS,int minB, int maxB,
-	//				   int area_min, int area_max, int max_apuntadores, CoordApuntador *apuntadores);
+	void initPropiedadesCalibracion(int veces_por_marcador, int cant_marcadores, int metodo,int debug);
 
+	int leerConfiguracionCalibracion(const char* archivoConfiguracion, int cantMarcadores, char** imagenes);
+
+		/***************************************************************************************************/
+
+
+
+		/*********************************** Calibracion Threshold ARToolkit **************************************/
 	void calibrarThreshold(int cantidad_iteraciones);
 
+		/***************************************************************************************************/
 
-	//FIXME no queda, podria borrarla porque SDL no va a estar integrado
-	/*Se llama cuando el programa finaliza
-	 * Detiene la captura de video y finaliza SDL*/
-	void cleanupAll(void);
 
-	//Quedan todas
+
+
+	    /**************************************** Propiedades y manejo de video ************************************/
+
 	void setBrillo(int brillo, char * device);
 	void setAutoWhiteBalance(int habilitado,char * device);
 	void setAutoGain(int habilitado,char * device);
 	void setHorizontalFlip(int habilitado,char * device);
 
+	void abrirVentanaGrafica();
 
-	/*-------------  ARTOOLKIT Y CALIBRACION AUTOMATICA -------------*/
-
-
-	//FIXME No queda,no puede recibir el parametro. Tiene que ser igual pero sin parametros
-	/*Devuelve la informacion de todos los marcadores
-	 * Tanto los marcadores  que no figuran en la estructura de dectados pero estan como visible o aquellos
-	 * que directamente estan como no visibles tendran su area y cf en -1 */
-	//int detectarYCalcularPosicionTodosMultiMarkers(ArtoolkitData* data);
-
-	int detectarYCalcularPosicionTodosMultiMarkers();
+	void desplegarImagenAR(bool debug);
+	void desplegarImagenFromData(unsigned char * imageData);
 
+	void capNext();
+	void capStart();
+	void capStop();
 
-					//FIXME las desplegar imagen deberian ser cambiadas por una operacion que devuelva
-					//la imagen para que el usuario de la API la despliegue de la manera que quiera
-	//FIXME no queda. Se podria borrar porque no se va a brindar funcionalidad de desplegar imagenes
-	//void desplegarImagenAR(ArtoolkitData* data);
+		/***************************************************************************************************/
 
-	//FIXME no queda. Se podria borrar porque no se va a brindar funcionalidad de desplegar imagenes
-	//void desplegarImagenLite(ArtoolkitData* data);
 
-	//FIXME no queda, hay que sacar el parametro. Esta misma operacion podria devolver la imagen, suena coherente!!!
-	//void capturarImagenAR(ArtoolkitData* data);
+			/*********************************** Captura de video *********************************/
 	unsigned char* capturarImagenAR();
 
 	binary_data capturarPyImageAR();
-	//FIXME No queda, creamos una parecida que devuelve la imagen debug
-	/**
-	 * recibe un boleano que indica si se desea mostrar la imagen en modo debug
-	 */
-	//void mostrarImagenDebugAR(int debug);
 
 	//NUEVA. Devuelve la imagen Debug de artoolkit
 	unsigned char* obtenerImagenDebugAR();
 
+	//TODO
+	//binary_data* obtenerPyImagenDebugAR();
+
+
+		/*******************************************************************************************/
+
 
+		/******************************** Calibracion de color el apuntador ********************************/
 
-	//FIXME no queda, hay que sacarle los parametros que estan de mas
 	/*Inicializa el histograma en cero
 	 * Inicializa los resultados en los rangos maximos (H:0-360,S:0-100,V:0-100)
 	 * Registra la forma que se utilizara para detectar el apuntador (circulo, rectangulo, mano)
 	 * */
-	//void initPropiedadesCalibracionSoloApuntador(int cantidad_de_muestras,int forma,ArtoolkitData* data, PropiedadesCalibracion *propiedades,
-	//									  RangosColorApuntador rangos_escala,int h_bins, int s_bins, int v_bins,int debug);
-
 	void initPropiedadesCalibracionSoloApuntador(int forma,RangosColorApuntador rangos_escala,int h_bins, int s_bins, int v_bins,int debug);
 
 	void initPropiedadesCalibracionSoloApuntador(int forma,int hmin,int hmax, int smin, int smax, int vmin, int vmax,int h_bins, int s_bins, int v_bins,int debug );
 
 
-	//FIXME no queda, sacarle los parametros que no van
 	/*A partir de los marcadores detectados selecciona uno y aplica la mascara segun la forma seleccionada
-	Como resultado se deja en data->dataPtr la imagen con la mascara aplicada
-	En data se debe encontrar el centro y los vertices del marcador de identificador idMarcador*/
-//	int aplicarNuevaMascaraCalibrador(PropiedadesCalibracion* propiedades,ArtoolkitData* data,int idMarcador,int tipoMascara);
-
+	Como resultado se deja en data->dataPtr la imagen con la mascara aplicada*/
 	int aplicarNuevaMascaraCalibrador(int idMarcador,int tipoMascara);
 
-	//FIXME no queda, sacarle los parametros
 	/*Solamente aplica una mascara previamente calculada por la funcion aplicarNuevaMascaraCalibrador
 	 * si antes no se llama al menos una vez a aplicarNuevaMascaraCalibrador entonces no se aplicara la mascara*/
-	//int aplicarMascaraCalibrador(PropiedadesCalibracion* propiedades,ArtoolkitData* data,int tipoMascara);
-
 	int aplicarMascaraCalibrador(int tipoMascara);
 
 	unsigned char* getCalibrationImage();
 
-	//FIXME no queda, sacarle los parametros
-	/*Calcula el histograma filtrado por la mascara lo acumula al histograma calculado con las muestras
-	anteriores*/
-	//int tomarMuestraApuntador(PropiedadesCalibracion *propiedades,ArtoolkitData* data);
+	//TODO
+	//binary_data getCalibrationImage();
 
-	/*Calcula el histograma filtrado por la mascara lo acumula al histograma calculado con las muestras
-		anteriores*/
+	/*Calcula el histograma filtrado por la mascara lo acumula al histograma calculado con las muestras	anteriores*/
 	int tomarMuestraApuntador();
 
-	//FIXME no queda, sacarle los parametros
-	//int calcularResultadosCalibracionApuntador(PropiedadesCalibracion *propiedades,ArtoolkitData* data, int factorThreshH,int minPorcentajeRuido);
-
 	int calcularResultadosCalibracionApuntador(int factorThreshH,int minPorcentajeRuido);
 
+	//Setea la propiedad debug_imagenes en las props del calibrador
+	void setDebugCalibracion(bool debug);
 
-	//FIXME no queda, hay que sacarle los parametros que no van
-	/*Inicializacion de artoolkit
-	 * Si se quiere leer un archivo de configuracion para multi pattern entonces config_name debe contener la ruta del archivo, sino debe ser NULL
-	 * */
-	//void initARConVideo( ArtoolkitData* data ,char * config_name,char *vconf,int usarAlgoritmoRapido,double zoom);
+	bool isDebugCalibracion();
+
+	//Retorna los resultados de la calibracion del color del apuntador
+	RangosColorApuntador getResultadosRangosColor();
+
+		/******************************************************************************************************************/
 
+
+
+		/******************************************* Manejo de ARToolkit **************************************************/
 	/*Inicializacion de artoolkit
 	 * Si se quiere leer un archivo de configuracion para multi pattern entonces config_name debe contener la ruta del archivo, sino debe ser NULL
 	 * */
@@ -294,31 +330,70 @@ public:
 	//TODO *********** IMPORTANTEEEEEEEEEEEEEEEEEEEEEEEEE   ********** TODO
 	//void initAR(int usarAlgoritmoRapido);-->no inicia el video!!
 
+
+	//FIXME No queda,no puede recibir el parametro. Tiene que ser igual pero sin parametros
+	/*Devuelve la informacion de todos los marcadores
+	 * Tanto los marcadores  que no figuran en la estructura de dectados pero estan como visible o aquellos
+	 * que directamente estan como no visibles tendran su area y cf en -1 */
+	//int detectarYCalcularPosicionTodosMultiMarkers(ArtoolkitData* data);
+
+	int detectarYCalcularPosicionTodosMultiMarkers();
+
+
+
 	int getARThreshold();
 
 	void setARThreshold(int threshold);
 
-	//NUEVA Invoca a los cleanUp y libera recursos
-	void finish();
+	/**************************************************************************************************************************************/
+
 
 
-	//Setea la propiedad debug_imagenes en las props del calibrador
-	void setDebugCalibracion(bool debug);
 
-	bool isDebugCalibracion();
 
-	//Retorna los resultados de la calibracion del color del apuntador
-	RangosColorApuntador getResultadosRangosColor();
 
 
-	void abrirVentanaGrafica();
 
-	void desplegarImagenAR(bool debug);
-	void desplegarImagenFromData(unsigned char * imageData);
 
-	void capNext();
-	void capStart();
-	void capStop();
+
+
+
+
+
+
+
+
+
+	/****************************************GENERALES PUI**********************************************************/
+
+	void initPuiConCapturaDeVideo(PropiedadesDeteccionApuntador propiedadesDeteccion,RangosColorApuntador rangosColorApuntador,char * config_name,char * camera_para,char *vconf,int usarAlgoritmoRapido,int loopSpeed,double zoom);
+
+	void initPuiConCapturaDeVideo(char* configuracionFileName,char * config_name,char * camera_para,char *vconf,int usarAlgoritmoRapido,int loopSpeed,double zoom);
+
+
+
+
+	/****************************************************************************************************************/
+
+
+
+
+
+
+	/**************************************************OTRAS*********************************************************/
+
+	//NUEVA indica a la clase PUI si debe llevar el historico y cual es el nro para
+	//considerar un hit
+	void habilitarHistorico(bool habilitar,int cantHistorico,int valorInicial);
+
+
+	//NUEVA Invoca a los cleanUp y libera recursos
+	void finish();
+
+	//FIXME no queda, podria borrarla porque SDL no va a estar integrado
+	/*Se llama cuando el programa finaliza
+	 * Detiene la captura de video y finaliza SDL*/
+	void cleanupAll(void);
 
 	/**
 	 * retorna la cantidad de imagenes procesadas por segundo y comienza el contador desde 0 nuevamente
@@ -330,8 +405,6 @@ public:
 	 */
 	double getFPS();
 
-
-
 	char* getModuleInfo();
 };
 
diff --git a/Utilidades/src/cvUtilities.cpp b/Utilidades/src/cvUtilities.cpp
index 5bba42b..0d2dfe0 100644
--- a/Utilidades/src/cvUtilities.cpp
+++ b/Utilidades/src/cvUtilities.cpp
@@ -813,9 +813,78 @@ void mostrarTarget(IplImage* img,float xStart,float yStart, int width,int height
 }
 
 
+/**
+ * Nueva version.
+ * Recibe un parametro factor el cual se utiliza para calcular un area maxima segun el area de la zona de estudio.
+ * area_max = areaZonaEstudio/factor
+ */
+float hayApuntador(RangosColorApuntador rangos, double vertices[4][2], int offsetRoi, uchar* dataPtr,
+					IplImage* img,IplImage* mono_Image,int min_area_width_height,int min_area,float factor,int erode, int dilate,int smooth, int enclosingCircle,double *areaZonaEstudio,char* ventanaMostrarImagenMono,char* ventanaMostrarImagenColor){
+
+	if(factor==0)
+		factor=1;
+	int resultado[2];
+	int xsize = img->width;
+	int ysize = img->height;
+	calcularPuntoOrigen(vertices, resultado);
+	float v0_x = vertices[resultado[0]][0];
+	float v0_y = vertices[resultado[0]][1];
+	float v2_x = vertices[resultado[1]][0];
+	float v2_y = vertices[resultado[1]][1];
+	//Calculo x inicial
+	int xStart = 0;
+	if(v0_x>offsetRoi){ //Chequeo para no salirme del ancho de la pantalla
+		xStart = v0_x - offsetRoi;
+	}
+	//Calculo y inicial
+	int yStart = 0;
+	if(v0_y > offsetRoi){ //Chequeo para no salirme del alto de la pantalla
+		yStart = v0_y -offsetRoi;
+	}
+	//Calculo ancho
+	int widthZonaEstudio = abs( v2_x - xStart) + offsetRoi;
+	if(xStart + widthZonaEstudio > xsize){ //Chequeo para no salirme del ancho de la pantalla
+		printf("Borde pantalla: xStart = %d , widthZonaEstudio = %d \n",xStart,widthZonaEstudio);
+		widthZonaEstudio = xsize - xStart;
+	}
+	//Calculo alto
+	int heightZonaEstudio = abs(v2_y - yStart) + offsetRoi;
+	if(yStart + heightZonaEstudio > ysize){ //Chequeo para no salirme del alto de la pantalla
+		printf("Borde pantalla: yStart = %d , heightZonaEstudio = %d \n",yStart,heightZonaEstudio);
+		heightZonaEstudio = ysize - yStart;
+	}
+
+	cvSetImageData( img, (uchar*)(dataPtr), img->width* img->nChannels );
+	img->origin = IPL_ORIGIN_TL;
+	cvZero(mono_Image);							//FIXME Es necesario? Probar sin esto. Creo que antes era necesario porque en el else del filtrado por hsv tenia mal el acceso al pixel que tenia que setear en 0. En ese caso faltaba sumar los xstart e ystart
+	float area = -1;
+
+	//Calculo el area de la zona de estudio. Segun este area vamos a obtener la cota minima y maxima del area del apuntador esperado segun la calibracion que se hay realizado
+	//Por ejemplo si el apuntador ocupa 1/8 del marcador, y el area de la zona de estudio (que es aproximadamente el area del marcador) es de 800, entonces
+	//buscaremos un apuntador de (800)*(1/8) = 100 +/- UMBRAL_AREA_APUNTADOR
+	*areaZonaEstudio = heightZonaEstudio*widthZonaEstudio;
+
+	if(heightZonaEstudio>min_area_width_height  &&  widthZonaEstudio > min_area_width_height){ //Ver definicion de MIN_AREA_WIDTH_HEIGHT para comprender mejor este chequeo
+		area = fabs(hayObjetoColor(img,mono_Image,rangos.hmin,rangos.hmax,rangos.smin,rangos.smax,rangos.vmin,rangos.vmax,ventanaMostrarImagenMono!=NULL,xStart,yStart,widthZonaEstudio,heightZonaEstudio,min_area, *areaZonaEstudio/factor,erode,dilate,smooth,enclosingCircle,ventanaMostrarImagenMono,ventanaMostrarImagenColor));
+		if(area>0){
+			printf("Area zona estudio = %f\n",*areaZonaEstudio);
+			printf("Area apuntador = %f\n",area);
+			/************************************************************************************************************
+			 * 	DESCOMENTAR EL SIGUIENTE CODIGO PARA VER LOS SEGMENTOS DE IMAGEN EN LOS CUALES SE DETECTO EL APUNTADOR
+			 *	mostrarTarget(img,xStart,yStart,widthZonaEstudio,heightZonaEstudio);
+			 *	mostrarTarget(mono_Image,xStart,yStart,widthZonaEstudio,heightZonaEstudio);
+			 * **********************************************************************************************************/
+			//mostrarTarget(img,xStart,yStart,widthZonaEstudio,heightZonaEstudio);
+			//mostrarTarget(mono_Image,xStart,yStart,widthZonaEstudio,heightZonaEstudio);
 
+		}
+	}
+	return area;
+
+}
 
 
+/*Queda por compatibilidad hacia atras pero hace un manejo del area maxima diferente a la nueva version de esta funcion*/
 float hayApuntador(int minH,int maxH, int minS, int maxS, int minV, int maxV, double vertices[4][2], int offsetRoi, uchar* dataPtr,
 					IplImage* img,IplImage* mono_Image,int min_area_width_height,int min_area,int max_area,int erode, int dilate,int smooth, int enclosingCircle,double *areaZonaEstudio,char* ventanaMostrarImagenMono,char* ventanaMostrarImagenColor){
 	int resultado[2];
diff --git a/Utilidades/src/cvUtilities.h b/Utilidades/src/cvUtilities.h
index 80b7f8d..77c0f50 100644
--- a/Utilidades/src/cvUtilities.h
+++ b/Utilidades/src/cvUtilities.h
@@ -56,6 +56,13 @@ float hayApuntador(int minH,int maxH, int minS, int maxS, int minV, int maxV, do
 					int smooth,int enclosingCircle, double *areaZonaEstudio, char* ventanaMostrarImagenMono,char* ventanaMostrarImagenColor);

 

 

+/**

+ * Version mas nueva

+ * Idem a la anterior pero recibe el rango de colores en una estructura RangosColorApuntador.

+ * Ademas no recibe un max_area sino que lo calcula mediante areaZonaEstudio/factor
+ */

+float hayApuntador(RangosColorApuntador rangos, double vertices[4][2], int offsetRoi, uchar* dataPtr,

+					IplImage* img,IplImage* mono_Image,int min_area_width_height,int min_area,float factor,int erode, int dilate,int smooth, int enclosingCircle,double *areaZonaEstudio,char* ventanaMostrarImagenMono,char* ventanaMostrarImagenColor);