#pragma once
#include <float.h>
#include <vector>
#include <map>
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////
/**
*	@file olv_limp_def.h
*	Archivo de definiciones generales de Olivia.
*/
//Defines
#define OLV_LIMP_AMB_NW_NODEF		USHRT_MAX//-1		//<Indica que no hay índice del ámbito a la carretera asignada
#define OLV_LIMP_MILIS_PROGRE		500		///<Milisegundos cada los que se actualiza el progreso de la tarea
#define OLV_LIMP_N_DMIN_NW			3		///<Número de carreteras que almacena más cercanas
#define OLV_LIMP_N_PTOS_MED			4		///<Número de puntos con los que calcular distancia media entre ámbito y carretera
#define OLV_LIMP_N_PTOS_DIST		2.5		///<Distancia entre los puntos de la media
#define OLV_LIMP_M_CONJ				32		///<Incrementos de memoria en el array de conjunciones
#define OLV_LIMP_MAX_CAMP			32		///<Longitud máxima de la cadena de caracteres del campo de la dbf
#define OLV_LIMP_ANCH_DEF			2.2		///<El ancho por defecto por si hubiera algún error
#define OLV_LIMP_COST_SEGM			3		///<El coste asignado a los segmentos de unión, en segundos
#define OLV_LIMP_VELO_CIRC_PEAT		1		///<La velocidad de circulación en calles prohibidas y peatonales, muy bajita, en km/h
#define OLV_LIMP_VELO_DESP_PEAT		3		///<La velocidad de desplazamiento por las réplicas de peatonales, en km/h
#define OLV_LIMP_VELO_CIRC_NW		30		///<La velocidad de desplazamiento por la nw cuando la velo es la de las vías, en km/h
#define OLV_LIMP_VELO_DEF			10		///<La velocidad por defecto cuando viene a 0 en la nw, en km/h
#define OLV_LIMP_GIRO_VEHIC			175		///<El giro máximo del vehículo por defecto
#define OLV_LIMP_THR_N				1		///<Número de threads para los cálculos multiproceso
#define OLV_LIMP_FACT_PERM			4		///<Número de elementos contiguos para permutar
#define OLV_DESV_MAX				0.15	///<Desviación relativa con la que deja de iterar
#define OLV_DESV_MAX_ABS_MIN		1800.	///<Desviación en segundos con la que, si es menor que esa, se deja de iterar si se cumple la relativa
#define OLV_DESV_MAX_ABS			1800.	///<Desviación en segundos con la que deja de iterar
#define OLV_DESV_MAX_NAMB			0.1		///
#define OLV_DESV_MAX_NAMB_MIN		400		//
#define OLV_T_SLEEP_MSG				6000	///<ms a dormir después del mensaje para que se pueda leer
#define MAX_LEN_BUF_CERCANAS		24
#define OLV_DIST_PARALELAS			0.2		///<En metros, lo que se distancia la paralela del eje al hacer la ruta
#define OLV_DIST_MAX_AMB_NW			25		///<En metros, la dist max deseable entre un ámbito y su inw asignado, si es más, se busca otro ámbito más cercano
#define OLV_DIST_MAX_AMB_NW_MAX		30		///<En metros, la dist max para que se quede la unión con la nw, si no la desecha completamente
#define OLV_BARRMIX_DMAX_DESC		20
#define OLV_BARRMIX_DMED_MAX		3
#define OLV_BARRMIX_DESV_MAX		1
#define OLV_PORC_LINRECT			0.5
#define OLV_TOMTOM_PEDESTRIAN		14
#define OLV_NOMB_OID				"OBJECTID"
#define OLV_SHP_SZ_CAMP_CHAR		32		
#define OLV_SHP_SZ_CAMP_SZ			32 //sizeof(double)		
#define OLV_DIF_MAX_MISMA_COOR		0.01
//defines para ini de configuracion campos dbf-------------------------
#define OLV_LIMP_GRUPO_DBF					"CONF_CAMPOS_DBF"		
#define OLV_LIMP_PARAM_OBS					"Observaciones"		
#define OLV_LIMP_PARAM_ANCHO				"Ancho_tipo"		
#define OLV_LIMP_PARAM_TIPO_AP				"Tipo_ap"		
#define OLV_LIMP_PARAM_TIPO_ENT				"Tipo_entrada"		
#define OLV_LIMP_PARAM_TIPO_ENT_APARCA		"Banda_aparcamiento"
#define OLV_LIMP_PARAM_TIPO_ENT_BORD		"Bordillo_Libre"	
#define OLV_LIMP_PARAM_TIPO_ENT_PEATO		"Entidad_peatonal"			
#define OLV_LIMP_PARAM_TIPO_ENT_ACERA		"Entidad_acera"		
#define OLV_LIMP_PARAM_TIPO_AP_LIN			"Aparcamiento_linea"		
#define OLV_LIMP_PARAM_TIPO_AP_BAT			"Aparcamiento_bateria"
#define OLV_LIMP_GRUPO_OTROS				"OTROS_PARAM"		
#define OLV_LIMP_PARAM_GIRO_VEHIC			"Giro_max_vehiculo"	
#define OLV_LIMP_PARAM_ANCH_DEF_PEAT		"Ancho_peat_def"	
#define OLV_LIMP_PARAM_ANCH_DEF_ACE			"Ancho_acera_def"	
#define OLV_LIMP_PARAM_ANCH_DEF_APLIN		"Ancho_ap_lin_def"	
#define OLV_LIMP_PARAM_ANCH_DEF_APBAT		"Ancho_ap_bat_def"	
#define OLV_LIMP_PARAM_ANCH_DEF_BORD		"Ancho_bord_lib_def"
#define OLV_LIMP_PARAM_DESV_MAX				"Desv_max"
#define OLV_LIMP_PARAM_DESV_MAX_ABS			"Desv_max_abs"
//flags de la info de la inw-------------------------
#define OLV_LIMP_FLG_CIRC_FT	0x00000001	///<Indica sentido de circulación FT , ningún flag indica sentido BOTH
#define OLV_LIMP_FLG_CIRC_TF	0x00000002	///<Indica sentido de circulación TF
#define OLV_LIMP_FLG_CIRC_NONE	0x00000004	///<Indica sentido de circulación NONE
#define OLV_LIMP_FLG_CIRC_NO_DOB 0x00000007	///<Indica sentido de circulación FT+TF+NONE
#define OLV_LIMP_FLG_NW_REP		0x00000008	///<Indica si la entidad es una réplica de calle de nw
#define OLV_LIMP_FLG_AMB		0x00000020	///<Indica si la entidad es un ámbito, ausencia de este y el de seg indica que es nw
#define OLV_LIMP_FLG_DER		0x00000010	///<Indica que el ámbito está a la derecha de la carretera asignada, tomado su sentido FT
#define OLV_LIMP_FLG_SEG_LIN	0x00000040	///<Indica si la entidad es un segmento de unión con los ámbitos lineales
#define OLV_LIMP_FLG_SEG_PUN	0x00000080	///<Indica si la entidad es un segmento de unión con los ámbitos puntuales
#define OLV_LIMP_FLG_PEAT_REP	0x00000200	///<Indica si la entidad es un ámbito peatonal replicado
#define OLV_LIMP_FLG_EJE		0x00000800	///<Indica si la entidad es un ámbito tipo eje de calle
#define OLV_LIMP_FLG_EJE_SEG	0x00001000	///<Indica si la entidad es un segmento de ámbito tipo eje de calle
#define OLV_LIMP_FLG_FIN		0x00002000	///<Indica que es final del ámbito
#define OLV_LIMP_FLG_SEG_AMB	0x00004000	///<Indica que es segmento de unión entre ámbitos
#define OLV_LIMP_FLG_AMB_NO 	0x00008000	///<indica que el ambito no se va a usar para la secto ni planif
#define OLV_LIMP_FLG_NW			0x00010000	///<Indica que es red navegable
#define OLV_LIMP_FLG_AMB_APA	0x00020000	///<Indica que es aparcamiento
#define OLV_LIMP_FLG_AMB_BORD	0x00040000	///<Indica que es bordillo
#define OLV_LIMP_FLG_AMB_ACE	0x00080000	///<Indica que es acera
#define OLV_LIMP_FLG_AMB_PEAT	0x00100000	///<Indica que es peatonal
#define OLV_LIMP_FLG_PEAT_SEG	0x00200000	///<Indica segmento de peatonal

#define OLV_MAX_ERR			256
#define OLV_MAX_TAREA		256
#define OLV_MAX_MSG_PROCE	1024
#define OLV_KMH2MS			1.0*1000/3600
#define OLV_MS2KMH			1.0*3600/1000
#define OLV_MAX_IP			32
#define OLV_MAX_COL_SHP		10

#ifndef LOG_TODO
#define LOG_TODO 1
#endif

//Flags para sectores
#define OLV_LIMP_FLG_SEC_INFO_BLOCK	0x0001	//<Indica que ese sector esta bloqueado (no se puede quitar ni poner ambitos)
#define OLV_LIMP_FLG_SEC_DISTINTO	0x0002	//<Indica que ese sector puede ser distinto a los demás para cuadrar jornadas
#define OLV_LIMP_FLG_SEC_CAMB		0x0004	//<Indica que ese sector se ha cambiado
//****************************************************
#ifndef	MAYUSCULO
#define MAYUSCULO		(double) 1.e+30

#endif
#ifndef MINUSCULO
#define MINUSCULO       (double) 1.e-20
#endif
//****************************************************
//Enums
/**
 * Para distinguir si se guardan los viajes a descargar y vuelta por separado, o junto a su recogida correspondiente
 */
enum TipoShpViaj
{
	OLV_SHPRUT_SHPINST=0, //Guarda en un shp Ruta cada viaje de cada sector, 
						//sin incluir los viajes a instalación, que se guardan en un shp aparte
	OLV_SHPRUTINST,		//Guarda en un único shp cada viaje de cada sector, incluida la ida a descargar y la vuelta de la descarga anterior
						//Oferta barcelona
};
/**
 * Para identificar los tipos de ámbitos
 */
enum TipoAmbit
{
	OLV_AMB_PUN=1, //tiene que empezar siempre en 1 porque se usa para multiplicar, y el lineal ser el 2, no cambiar!
	OLV_AMB_LIN,
};
;
/**
 * Para los tipos de viaje a las instalaciones
 */
enum DesplTto{
	OLV_DESP,
	OLV_TTO, //aquí almacena los metros lineales
	OLV_TTO_2, //para cuando es tratamiento en m2/h, almacenar aquí los m2
	OLV_DT_N
};
/**
 * Para identificar los tipos de atributos de circulación
 */
enum AtrCirc
{
	OLV_ATR_CIRC_TF,
	OLV_ATR_CIRC_FT,
	OLV_ATR_CIRC_NONE,
	OLV_ATR_CIRC_PEDES,
	OLV_ATR_CIRC_N
};
/**
 * Para identificar los tipos de atributos de tipos de entidad
 */
enum AtrTipEnt
{
	OLV_ATR_NOM_TIP_ENT_AP,
	OLV_ATR_NOM_TIP_ENT_BORD,
	OLV_ATR_NOM_TIP_ENT_PEAT,
	OLV_ATR_NOM_TIP_ENT_ACERA,
	OLV_ATR_NOM_TIP_ENT_N
};
/**
 * Para identificar los tipos de atributos de tipos de aparcamiento
 */
enum AtrTipAp
{
	OLV_ATR_TIP_AP_LIN,
	OLV_ATR_TIP_AP_BAT,
	OLV_ATR_TIP_AP_N
};
/**
 * Para identificar los tipos de anchos por defecto
 */
enum AnchosDef
{
	OLV_ANCH_DEF_PEAT,
	OLV_ANCH_DEF_ACE,
	OLV_ANCH_DEF_APLIN,
	OLV_ANCH_DEF_APBAT,
	OLV_ANCH_DEF_BORD,
	OLV_ANCH_DEF_N
};
/**
 * Para identificar los tipos de atributos de tipos de elementos en la planificación
 */
enum TipElemPlan
{
	OLV_PLAN_TIP_NW,
	OLV_PLAN_TIP_AMB,
	OLV_PLAN_TIP_AMB_PEAT,
	OLV_PLAN_TIP_AMB_PEAT_DESP,
	OLV_PLAN_TIP_SEG_LIN,
	OLV_PLAN_TIP_SEG_PUN,
};
/**
 * Para los tipos de restricciones de circulación
 */
enum TipRestr
{
	OLV_RES_NO,
	OLV_RES_SENTIDOS_CIRC,
	OLV_RES_RECOGER_SOLO_LADO_Y_GIROS,
};
/**
 * Para los tipos de viaje a las instalaciones
 */
enum ViajesInsta{
	OLV_IDA_INST,
	OLV_VUELTA_INST,
	OLV_IDA_PLANT,
	OLV_VUELTA_PLANT,
	OLV_IDA_PLANT_ULT,
};
/**
 * Para los tipos de llamadas a la generación de la planificación
 */
enum TiposPlan{
	OLV_PLAN_NORMAL,
	OLV_PLAN_INST,
	OLV_PLAN_RECO,
};
//****************************************************
//****************************************************
//Structs
/**
 * Nueva Estructura que contiene la información asociada de la nw
 */
typedef struct Info_aso_nw
{
	double		velo;			//velocidad de la vía, en km/h
	char		*nomb;			//nombre de la vía	
}Info_aso_nw;
/**
 * Nueva Estructura que contiene la información asociada de las entidades de limpieza (aceras, bordillos, peatonales...)
 */
typedef struct Info_aso_limp
{
	//int			refe2;		//en barrido mixto, el bordillo que es equivalente
								//en las peatonales replicadas, la peatonal original
	double		ancho;		//el ancho de la entidad
}Info_aso_limp;
/**
 * Nueva Estructura que contiene la información asociada de los contenedores
 */
typedef struct Info_aso_reco
{
	double		kg;			//kg de carga en total en esa ubicación
	char		*id;		//id en texto del contenedor para llamadas a sensores
	int			uds;		//num de cont en esa ubicación
}Info_aso_reco;
/**
 * Nueva Estructura que contiene la información asociada de la carto
 * se accede como map, según la clave de la referencia de la carto, pero en los ámbitos se puede
 * acceder por el i del ámbito directamente porque están los primeros en el map
 */
typedef struct Info_aso2
{
	INT64		flgs;		//flags
	int			inod[2];	//índice a los nodos ini y final de la entidad
	int			oid;		//objetct id de la carto
	int			refe2;		//en los segmentos o replicadas, el ámbito original
	int			refe;		//referencia en la carto a ese elemento
	int			iamb;		//índice al ámbito que es
	union
	{
		Info_aso_nw		inf_n;
		Info_aso_limp	inf_l;
		Info_aso_reco	inf_r;
	};

	Info_aso2()
	{
		reset();
	};

	void reset()
	{
		flgs=0;
		iamb=-1;
		inod[0]=inod[1]=oid=refe2=refe=-1;
		inf_r.id=inf_n.nomb=0;
		inf_n.velo=inf_l.ancho=inf_r.kg=-1;		
		inf_r.uds=0;
	};
	void del()
	{
		if(inf_n.nomb)
			free(inf_n.nomb); //solo lo hace para este porque comparte direccion de memoria con el id de reco
		inf_n.nomb=NULL;
	};
}Info_aso2;
/**
 * Contiene la info de los tramos de la planificación
 */
typedef struct Info_tramos
{
	short		ie[2];		//el ind al elemento incial y final del tramo
	short		iins[2];	//el ind al viaje a la inst inicial y final que corresponden a ese tramo
	short		namb;		//el número de ámbitos del tramo
	short		ncont;		//el número de contenedores del tramo
	float		long_tr;	//la longitud en metros del tramo
	float		t_total_tr;	//el tiempo total del tramo en segundos
	float		t_tto_tr;	//el tiempo de tto en segundos del tramo
	float		t_ini;		//el tiempo inicial del tramo
	float		t_fin;		//el tiempo final del tramo
}Info_tramos;
/**
 * Estructura que contiene la información de la carretera más cercana a un ámbito
 */
typedef struct Info_inw_dmin
{
	short			flgs;			//<Flags, para almacenar información variada
	unsigned short	refamb;			//<La referencia de la carto del ámbito, para cuando el array no esté ordenado por ámbito sino por inw
	unsigned short	ip;				//<El índice al punto de la carretera donde se da la distancia mínima
	unsigned short	refnw;			//<La referencia de la carretera (la ref de la carto), entidad de la capa nw, más cercana al ámbito dado
	float			dmin;			//<Distancia mínima encontrada entre el ámbito y la carretera en el punto más cercano
	float			lamb;			//<Parámetro de la recta del punto más cercano: pnw[ip] + (pnw[ip+1]-pnw[ip])*lamb
	float			alpha;			//<Diferencia con pi/2 del ángulo que forman el ámbito con el segmento que une 
									//<el extremo del ámbito con la carretera elegida
	double			pt[3];			//<Punto de la carretera donde se da la distancia mínima al ámbito
	Info_inw_dmin	*inw_old;		//<Para cuando reapunta
	Info_inw_dmin(){reset();}
	void reset(int refamb=-1)
	{
		refnw=0;
		refamb=0;
		dmin=(float)FLT_MAX;
		inw_old=NULL;
		ip=flgs=0;
		lamb=alpha=0;
		pt[0]=pt[1]=pt[2]=0;
	}
}Info_inw_dmin;
/**
 * Estructura que contiene la información de las carreteras que llegan a una intersección
 */
typedef struct Info_conjs_inw
{
	int				n;				//<Número de incidencias de entidades tipo carretera en la conjunción, o -1 si es conjunción de ámbito o segmento
	int				refnw0;			//<Índice a la primera carretera que incide, que es interesante por si sólo hay una	
}Info_conjs_inw;
/**
 * Estructura que contiene la información de las intersecciones
 */
typedef struct Info_conjs
{
	int				n;				//<Tamaño del array
	int				m;				//<Memoria reservada para el array		
	double			(*coor)[3];		//<Array de conjunciones de la red navegable y los ámbitos, de tamaño n
	Info_conjs_inw	*inc;			//<Array de carreteras que inciden en dicha conjunción, o -1 si es una conjunción de ámbito o segmento
}Info_conjs;
/**
 * Estructura que contiene la información de los sectores
 */
typedef struct Info_sec
{
	short			namb;				//<Número de ámbitos del sector
	short			*iamb;				//<Array de índices de los ámbitos asignados al sector
	short			sec_def;			//<El número de sector. Habitualmente coincide con el índice del array de sectores, excepto si se lee la secto y no empieza en 0
	short			flags_tem;			//<Flags temporales usados para igualar setores
	short			iamb_ini_def;		//<Índice al ámbito inicial de la planificación del sector, si se define en la columna "secuencia"
	float			t_despl[2];			//<Tiempos de desplazamiento de la instalación al inicio, y del final a la planta
	float			cost_ac;			//<Coste acumulado del sector
	float			cost_despl_aux;		//<Coste de desplazamiento auxiliar del sector (para almacenar medio, mínimo, máximo..)
	float			dis_med;			//<Distancia media entre ambitos del sector y su ambito central
	float			*cost_amb_sec;		//<Array de distancias del sector a todos los ámbitos
	float			*cost_amb_sec_aux;	//<Array de distancias del sector a todos los ámbitos, ponderado con las distancias al resto de sectores
}Info_sec;
/**
 * Estructura que contiene la información de los ámbitos en los sectores
 */
typedef struct Info_amb_sec
{
	short				sec;			//<Sector al que pertenece el ámbito
	short				iseq;			//<Secuencia con la que se recorre el ámbito en su sector
	short				namb_cerca;		//indica numero de ambitos cerca de este
	short				res;
	int					iamb_cerca[MAX_LEN_BUF_CERCANAS];
	float		    	t;				//<Tiempo de trabajo acumulado hasta este ámbito dentro del sector
 
}Info_amb_sec;
/**
 * Estructura que contiene la informacion de cada ambito correspondiente para poder recostruir el estado de sectorizacion
 */
typedef struct Info_est_amb
{
	short				sec;			//<Sector al que pertenece el ámbito
	short				iseq;			//<Secuencia con la que se recorre el ámbito en su sector
	float				t;					//<Tiempo de trabajo acumulado hasta este ámbito dentro del sector
}Info_est_amb;
/**
 * Estructura que contiene la información de cada elemento de la planificación.
 */
typedef struct Info_elem_planif
{
	short			aux;		//<Variable auxiliar, indica en recogida si es ámbito en el que se va o vuelve a descargar				
	int				refe;		//<Referencia de la línea dentro de la carto
	int				k;			//<Indica k=0 si es entrada, k=1 si es salida
	int				tp;			//<Tipo de elemento TipElemPlan
	int				ref_nw;		//<referencia a qué carretera está asociado el elemento
	double			coste;		//<Coste acumulado hasta ese elemento
	double			ltot;		//<Longitud del elemento
}Info_elem_planif;
/**
 * Estructura que contiene la información de los puntos de control de la información
 */
typedef struct Info_planif_ctrl
{
	int				ipt;		//<Punto de la planificación tras el que está el punto de control
	double			cost;		//<Coste acumulado hasta el punto de control
}Info_planif_ctrl;
/**
 * Estructura que contiene la información de la planificación. Hay una por sector
 */
typedef struct Info_planif
{
	int					nelem;			//<Número de elementos en la secuencia de la planificación
	int					ninsta;			//<Número de viajes que hace a la instalación
	double				m[OLV_DT_N];	//<Metros de desplazamiento/tratamiento de la ruta
	double				t[OLV_DT_N];	//<Tiempos de desplazamiento/tratamiento de la ruta, en segundos
	Info_planif_ctrl	*pts_ctrl;		//<Array de tamaño npts_ctrl-2 contiene índices al final de qué elemento hay un punto de control intermedio
	Info_elem_planif	*elem;			//<Array de elementos
	Info_planif			*planif_insta;	//<Planificaciones de los viajes que hace a las instalaciones
}Info_planif;

/**
 * Estructura que contiene los nombres de los campos a leer
 */
typedef struct Campos_dbf
{
	/////////////////////////////////////////////	
	char			campo_circ[OLV_LIMP_MAX_CAMP];
	char			campo_velo[OLV_LIMP_MAX_CAMP];
	char			campo_name[OLV_LIMP_MAX_CAMP];
	char			campo_fow[OLV_LIMP_MAX_CAMP];
	//ELEV TOM TOM
	char			campo_conj_to[OLV_LIMP_MAX_CAMP];
	char			campo_conj_from[OLV_LIMP_MAX_CAMP];
	char			campo_elev_to[OLV_LIMP_MAX_CAMP];
	char			campo_elev_from[OLV_LIMP_MAX_CAMP];
	/////////////////////////////////////////////
	char			campo_obs[OLV_LIMP_MAX_CAMP];
	char			campo_anch[OLV_LIMP_MAX_CAMP];
	char			campo_tipo_ap[OLV_LIMP_MAX_CAMP];
	char			campo_tipo_ent[OLV_LIMP_MAX_CAMP];
	char			campo_secto[OLV_LIMP_MAX_CAMP];
	char			campo_secuen[OLV_LIMP_MAX_CAMP];
	char			campo_oid[OLV_LIMP_MAX_CAMP];
	char			atr_circ[OLV_ATR_CIRC_N][OLV_LIMP_MAX_CAMP];
	char			atr_tip_ent[OLV_ATR_NOM_TIP_ENT_N][OLV_LIMP_MAX_CAMP];
	char			atr_tip_apa[OLV_ATR_TIP_AP_N][OLV_LIMP_MAX_CAMP];
}Campos_dbf;
struct Djkt_nodo;
/*
 * Estructura de secuencia de ambitos usada para la planificacion
 */
typedef struct Secu_amb
{
	short iamb;
	short entrada;//indice a nodo entrada
	short flags;
	int res;
	Djkt_nodo *ctnod[2];
	void libera(int i, int n);
}Secu_amb;
//****************************************************************
/**
 * Datos de los thead que prueban combinaciones de planificacion
 */
typedef struct th_data_planif
{
	BOOL currando;
	BOOL activo;
	int	 pos[2];//utilizado en sustitucion de posiciones
	double coste;//coste minimo alcanzado
	Secu_amb*sec;//secuencia de coste minimo alcanzado
}th_data_planif;
class Colv_limp_thr;
/**
 * Parametros de los thead que prueban combinaciones de planificacion
 */
typedef struct th_param_planif
{
	BOOL pirate;//indica a los thread que hay que irse
	BOOL abs;
	int id_curro;//id de curro
	int modo;//indica el modo de curro
	long nth;//numero de thread currando
	int id_th;//indica al thread el id que tiene
	int namb;
	int param[2];
	int namb_t;//numero de ambitos totales
	int milis_sleep;
	th_data_planif *dth;//datos obtenidos por los thread
	Secu_amb*sec;
	Info_sec *s;
	Colv_limp_thr* tl;
	//*******************************************
	void a_currar()
	{
		for (int i=0; i<nth; i++)
		{
			dth[i].currando=dth[i].activo;
		}
		id_curro=(id_curro+1)%1000;
	};
	//*******************************************
	BOOL terminado()
	{
		for (int i=0; i<nth; i++)
		{
			if(dth[i].currando)
				return FALSE;
		}
		return TRUE;
	};

	int dame_min()
	{
		int j=0;
		for (int i=1; i<nth; i++)
		{
			if(dth[j].coste>dth[i].coste)
				j=i;
		}
		return j;
	};
}th_param_planif;
/*
* Para revisar la elevación de las carreteras y borrar uniones que no debería haber por estar a distinta elevación
*/
#define INFO_ASO_NW_NO_ELEV 0
enum INFO_ASO_NW_NODOS
{
	FROM = 0,
	TO = 1,
	N_NODOS = 2
};
/*
* Estructura para almacenar los id de los nodos de cada ent de la nw TO y FROM, y la elevación
*/
typedef struct Info_aso_nw_elev
{
	short		elev[N_NODOS];	//indica elevación 
								//elev[FROM] = 0 o 1
								//elev[TO]=0 o 1
	double		inod[N_NODOS];			//almacena aquí el id de las conjunciones de la carto FROM y TO	
	double		coord[N_NODOS][3];			//almacena aquí las coord de las conjunciones de la carto FROM y TO	
	bool		inod_check[N_NODOS];	//almacena aquí si se ha comprobado ya ese nodo
	int			i_nw;					//la ref de la nw
}Info_aso_nw_elev;
enum INFO_ASO_NW_ELEV
{
	MISMA_ELEV = 0,
	DIST_ELEV = 1,
	N_ELEV = 2
};
/*
* Estructura para almacenar nodos que están a distinta elevación
*/
typedef struct Info_aso_conj_elev_aux
{
	short			tofrom;
	int				i_nw;
	void set(int _i_nw, short _tofrom)
	{
		i_nw = _i_nw;
		tofrom = _tofrom;
	}
}Info_aso_conj_elev_aux;
/*
* Estructura para almacenar los id de los nodos a los que llegan ent de la nw con distinta elevación
*/
typedef struct Info_aso_conj_elev
{
	std::vector<Info_aso_conj_elev_aux>	conj_nw[N_ELEV];	//dos maps con las entidades de la nw que están a nivel 0 y a nivel 1 en la misma conjunción	
	char key_coord[64]; //indica la key de la coordenada
}Info_aso_conj_elev;
/*
* Estructura para almacenar los id de los nodos a los que llegan ent de la nw con distinta elevación de cada subthread
*/
typedef struct th_param_dist_elev_thr
{
	std::vector<Info_aso_conj_elev> conj_elev_i; //la clave son las coordenadas x-y en formato texto
}th_param_dist_elev_thr;
/**
 * Parametros de los thead que buscan nodos a dist elev
 */
typedef struct th_param_dist_elev
{
	BOOL pirate;//indica a los thread que hay que irse
	BOOL abs;
	int id_curro;//id de curro
	int modo;//indica el modo de curro
	long nth;//numero de thread currando
	long nth_tot;
	int id_th;//indica al thread el id que tiene	
	int n_nw;	
	int milis_sleep;		
	th_param_dist_elev_thr	*conj_th;
	std::vector<Info_aso_nw_elev>	iaso_elev; ///<Map con mismos elementos que la nw, con la info de elevación de los nodos, cada thr su copia
}th_param_dist_elev;