Revisa elevación por coordenadas, si encuentra, pone z distinta, que se usa para las distancias

Olivia/olv.cpp

@@ -411,7 +411,7 @@ void COlivia::prueba()
 	switch(i)
 	{	
 	case 1:
-		sprintf_s(config, max_char_cap,"/CONFIG_PLANIF /t_tto:2900 /restr_cir:0 /u_tto:3 /v_despl:5 /t_conv:480 /t_descan:30 /t_despl:25 /t_carg:40 "\
+		sprintf_s(config, max_char_cap,"/CONFIG_TODO /t_tto:2900 /restr_cir:0 /u_tto:3 /v_despl:5 /t_conv:480 /t_descan:30 /t_despl:25 /t_carg:40 "\
 			"/h_inicio:450 /trafico:80 /n_ptsctrl:3 /n_secdef:3 /anch_med:2 /coor_inst_x:0 /coor_inst_y:0 /aislados:1 /cons_obser:OBSERVACIONES "\
 			"/cons_anch_tip:ANCHO_TIPO /cons_tipolo:TIPOLOGIA /cons_tip_ent:NOM_TIPO_ENTIDAD /atr_aparc:Banda Aparcamiento /atr_bord:Bordillo Libre "\
 			"/atr_acera:Aceras /atr_peat:Peatonales /atr_ap_lin:Linea /atr_ap_bat:Bateria /cons_onew:ONEWAY /cons_kph:KPH /cons_fow:FOW /cons_name:NAME "\

Olivia/olv_limp_def.h

@@ -550,13 +550,14 @@ typedef struct Info_aso_nw_elev
 								//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
 {
-	NO_ELEV = 0,
+	MISMA_ELEV = 0,
-	ELEV = 1,
+	DIST_ELEV = 1,
 	N_ELEV = 2
 };
 /*
@@ -577,5 +578,5 @@ typedef struct Info_aso_conj_elev_aux
 */
 typedef struct Info_aso_conj_elev
 {
-	std::vector<Info_aso_conj_elev_aux>	conj_nw;	//dos maps con las entidades de la nw que están a nivel 0 y a nivel 1 en la misma conjunción		
+	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		
 }Info_aso_conj_elev;

Olivia/olv_limp_thr.cpp

@@ -1237,15 +1237,20 @@ void Colv_limp_thr::rellena_elev_nw()
 
 	idd = dbf.leeNexRow();
 	n = 0;
-	
+	CartoBaseInfoEntity ient;
+	int npts;
 	while (idd == 1)
 	{
 		//inicia
 		olv_limp->iaso_elev[n].inod_check[FROM] = olv_limp->iaso_elev[n].inod_check[TO] = false;
 		olv_limp->iaso_elev[n].i_nw = n;
 		//conj
-		olv_limp->iaso_elev[n].inod[TO]= dbf.getD(ic_conj_to);
+		olv_limp->iaso_elev[n].inod[TO] = -1;
-		olv_limp->iaso_elev[n].inod[FROM] = dbf.getD(ic_conj_from);
+		olv_limp->iaso_elev[n].inod[FROM] = -1;
+		ient = olv_limp->carto.getEntity(n + olv_limp->n_amb);
+		npts = ient.getNumberPtos();
+		memcpy(olv_limp->iaso_elev[n].coord[FROM], ient.getPto(0), 3 * sizeof(double));
+		memcpy(olv_limp->iaso_elev[n].coord[TO], ient.getPto(npts - 1), 3 * sizeof(double));
 		//elev
 		olv_limp->iaso_elev[n].elev[TO] = dbf.getI(ic_elev_to);
 		olv_limp->iaso_elev[n].elev[FROM] = dbf.getI(ic_elev_from);
@@ -1270,7 +1275,7 @@ void Colv_limp_thr::rellena_elev_nw()
  */
 BOOL Colv_limp_thr::revisa_elev_nw()
 {
-	std::map<int, Info_aso_conj_elev> conj_elev = busca_elev_nw();
+	std::vector<Info_aso_conj_elev> conj_elev = busca_elev_nw();
 
 	olvlog(LOG_TODO, "olv_limp_t", "Encontrados %ld nodos con elevaciones distintas", conj_elev.size());
 
@@ -1286,16 +1291,15 @@ BOOL Colv_limp_thr::revisa_elev_nw()
 /**
 	* Busca y almacena los elementos que tienen nodo compartido pero a distinta elevación
 	*/
-std::map<int, Info_aso_conj_elev>  Colv_limp_thr::busca_elev_nw()
+std::vector<Info_aso_conj_elev>  Colv_limp_thr::busca_elev_nw()
 {
-	std::map<int, Info_aso_conj_elev> conj_elev;
+	std::vector<Info_aso_conj_elev> conj_elev;
 	Info_aso_conj_elev conj_elev_i1;
 	Info_aso_conj_elev_aux conj_elev_nw_i1, conj_elev_nw_i2;
 	std::map<int, Info_aso_nw_elev>::iterator it1;
 	std::map<int, Info_aso_nw_elev>::iterator it2;
 	int i1, i2,elev1,elev2;
 	Info_aso_nw_elev* info1, * info2;
-	BOOL encontrado_distinta_elev = false;
 
 	it1 = olv_limp->iaso_elev.begin();
 	while (it1 != olv_limp->iaso_elev.end())
@@ -1305,6 +1309,8 @@ std::map<int, Info_aso_conj_elev>  Colv_limp_thr::busca_elev_nw()
 		{
 			if (info1->inod_check[i1]) //si ya se ha comprobado, pasa
 				continue;
+			conj_elev_i1.conj_nw[MISMA_ELEV].clear();
+			conj_elev_i1.conj_nw[DIST_ELEV].clear();
 			it2 = olv_limp->iaso_elev.begin();
 			while (it2 != olv_limp->iaso_elev.end())
 			{
@@ -1314,32 +1320,40 @@ std::map<int, Info_aso_conj_elev>  Colv_limp_thr::busca_elev_nw()
 					it2++;
 					continue;//mismo elemento
 				}
-				encontrado_distinta_elev = false;
+				for (i2 = 0; i2 < N_NODOS; i2++)
-				for (i2 = 0; i2 < N_NODOS && !encontrado_distinta_elev; i2++)
 				{
 					if (info2->inod_check[i2])//si ya se ha comprobado, pasa
 						continue;
-					if (info1->inod[i1] == info2->inod[i2])
+					if ((Colv_geom::pto_equals(info1->coord[i1], info2->coord[i2]))) //if (info1->inod[i1] == info2->inod[i2])					
 					{
 						//comparten nodo, revisa elevación
+						conj_elev_nw_i2.set(info2->i_nw, i2);
 						if (info1->elev[i1] != info2->elev[i2])
 						{
 							//distinta elevación
-							encontrado_distinta_elev = true;
+							//añade i2
+							conj_elev_i1.conj_nw[DIST_ELEV].push_back(conj_elev_nw_i2);
 						}
-					}
+						else
-					//info2->inod_check[i2] = true;
+						{
-				}
+							//misma elev
-				if (encontrado_distinta_elev)
+							conj_elev_i1.conj_nw[MISMA_ELEV].push_back(conj_elev_nw_i2);
-				{
+						}
-					//añade i2
+					}					
-					conj_elev_nw_i2.set(info2->i_nw, i2);
-					conj_elev[info1->inod[i1]].conj_nw.push_back(conj_elev_nw_i2);
 				}
 				///////////////////////////////////////
 				it2++;
 			}
 			info1->inod_check[i1] = true;
+			//solo los almacena si tiene alguno en dist elev, si todos son la misma, no
+			if (conj_elev_i1.conj_nw[DIST_ELEV].size() > 0)
+			{
+				//se añade a sí mismo
+				conj_elev_nw_i1.set(info1->i_nw, i1);
+				conj_elev_i1.conj_nw[MISMA_ELEV].push_back(conj_elev_nw_i1);
+				conj_elev.push_back(conj_elev_i1);
+
+			}
 		}
 		it1++;
 	}
@@ -1351,43 +1365,50 @@ std::map<int, Info_aso_conj_elev>  Colv_limp_thr::busca_elev_nw()
 /**
  * Mueve las coordenadas de una conjunción de las que tienen distinta elevación
  */
-BOOL Colv_limp_thr::mueve_distint_elev_nw(std::map<int, Info_aso_conj_elev> conj_elev)
+BOOL Colv_limp_thr::mueve_distint_elev_nw(std::vector<Info_aso_conj_elev> conj_elev)
 {
-	int ELEV_MUEVE = ELEV; //mueve los que están a elev, y deja igual los que están a no_elev
+	int ELEV_MUEVE = DIST_ELEV; //mueve los que están a distinta elev, y deja igual los que están a misma_elev
-	std::map<int, Info_aso_conj_elev>::iterator it_conj = conj_elev.begin();
+	std::vector<Info_aso_conj_elev>::iterator it_conj = conj_elev.begin();
 	CartoBaseInfoEntity ient;
 	std::vector<Info_aso_conj_elev_aux>::iterator it_nw;
 	int ipt, nptos;
 	double pto_aux[3];
-
+	int cont = 0;
 	try
 	{
 		while (it_conj != conj_elev.end())
 		{
-			//coge las nw que están a elev distinta de 0 y les mueve su coordenada en común 
+			//si solo hay una no la mueve, se quedaría aislada
-			it_nw = it_conj->second.conj_nw.begin();
+			if ((it_conj->conj_nw[DIST_ELEV].size() > 1) && (it_conj->conj_nw[MISMA_ELEV].size() > 1))
-			while (it_nw != it_conj->second.conj_nw.end())
 			{
-				ient = olv_limp->carto.getEntity(it_nw->i_nw + olv_limp->n_amb); //+n_amb porque el nw empieza a continuación de los ámbitos
+				//coge las nw que están a elev distinta de 0 y les mueve su coordenada en común 
-				if (it_nw->tofrom == FROM)
+				it_nw = it_conj->conj_nw[ELEV_MUEVE].begin();
+				while (it_nw != it_conj->conj_nw[ELEV_MUEVE].end())
 				{
-					ipt = 0;
+					ient = olv_limp->carto.getEntity(it_nw->i_nw + olv_limp->n_amb); //+n_amb porque el nw empieza a continuación de los ámbitos
+					if (it_nw->tofrom == FROM)
+					{
+						ipt = 0;
+					}
+					else
+					{
+						nptos = ient.getNumberPtos();
+						ipt = nptos - 1;
+					}
+					//////////////////////////////////////////////////////
+					//ient.getPto(ipt)[2] = MUEVE_COOR_METROS; //le pone z
+					//coge el pto original
+					memcpy(pto_aux, ient.getPto(ipt), 3 * sizeof(double));
+					//lo mueve
+					pto_aux[0] += MUEVE_COOR_METROS;
+					pto_aux[1] += MUEVE_COOR_METROS;
+					pto_aux[2] = MUEVE_COOR_METROS;//le pone z
+					//lo sobreescribe
+					memcpy(ient.getPto(ipt), pto_aux, 3 * sizeof(double));
+					//////////////////////////////////////////////////////
+					it_nw++;
+					cont++;
 				}
-				else
-				{
-					nptos = ient.getNumberPtos();
-					ipt = nptos - 1;
-				}
-				//////////////////////////////////////////////////////
-				//coge el pto original
-				memcpy(&pto_aux, ient.getPto(ipt), 3 * sizeof(double));
-				//lo mueve
-				pto_aux[0] += MUEVE_COOR_METROS;
-				pto_aux[1] += MUEVE_COOR_METROS;
-				//lo sobreescribe
-				memcpy(ient.getPto(ipt), &pto_aux, 3 * sizeof(double));
-				//////////////////////////////////////////////////////
-				it_nw++;
 			}
 			it_conj++;
 		}
@@ -1396,6 +1417,7 @@ BOOL Colv_limp_thr::mueve_distint_elev_nw(std::map<int, Info_aso_conj_elev> conj
 	{
 		return FALSE;
 	}
+	olvlog(LOG_TODO, "olv_limp_t", "Movidos %ld nodos con elevaciones distintas", cont);
 	return TRUE;
 }
 //*************************************************************************************
@@ -1946,12 +1968,12 @@ BOOL Colv_limp_thr::busca_inw_dmin(int i_amb)
 
 				//necesita una función que dé la distancia media de prime_ptos a ientnw
 				daux=prime_ptos.disMedLines(&ientnw,&desv);		//coge la dis media para quedarse con la min
-				ientnw.DisPtoLine(prime_ptos.getPto(0),&ip, &lamb);	//coge el punto donde se da la min
+				ientnw.DisPtoLine(prime_ptos.getPto(0),&ip, &lamb, olv_limp->revisa_elev);	//coge el punto donde se da la min
 			}
 			else if(KK==OLV_AMB_PUN)
 			{
 				//calcula la daux media
-				daux=ientnw.DisPtoLine(ientamb.pto()->pts,&ip, &lamb);				
+				daux=ientnw.DisPtoLine(ientamb.pto()->pts,&ip, &lamb, olv_limp->revisa_elev);
 			}
 
 			inwaux.ip=(short)ip;
@@ -2015,8 +2037,8 @@ BOOL Colv_limp_thr::busca_inw_dmin(int i_amb)
 				pt_ang[1][2] = inww[j+k*OLV_LIMP_N_DMIN_NW].pt[2];
 
 				prod=GeometryFunction::ProdEscalar(&prime_ptos,&ptos_aux);
-				mod1=GeometryFunction::Dist2d(prime_ptos.getPto(0), prime_ptos.getPto(1));
+				mod1=Dist2d(prime_ptos.getPto(0), prime_ptos.getPto(1));
-				mod2=GeometryFunction::Dist2d(pt_ang[0],pt_ang[1]);
+				mod2=Dist2d(pt_ang[0],pt_ang[1]);
 				inww[j+k*OLV_LIMP_N_DMIN_NW].alpha=(float)fabs(prod/(mod1*mod2));					
 			}
 		}			
@@ -2277,7 +2299,7 @@ void Colv_limp_thr::compr_cortes_amb_sub(int ithr)
 				}
 				pt_amb2=ient_ia.getPto((npt_amb2-1)*h);
 				//calcula distancia del ámbito a ientamb2
-				dist=GeometryFunction::Dist2d(ient_i.getPto(1),pt_amb2);//el segundo punto de la unión es el punto del ámbito
+				dist=Dist2d(ient_i.getPto(1),pt_amb2);//el segundo punto de la unión es el punto del ámbito
 				distseg=ient_i.getLong();//la longitud del segmento que lo unía con la carretera
 				if(dist<1.5*distseg && dist<OLV_DIST_MAX_AMB_NW)
 				{
@@ -2355,7 +2377,7 @@ void Colv_limp_thr::comprueba_amb_lejos(int i_amb )
 	for(k=0;k<KK;k++)
 	{
 		pt_amb=ientamb.getPto((npt_amb-1)*k);
-		dist_aux2 =  GeometryFunction::Dist2d(pt_amb, 
+		dist_aux2 =  Dist2d(pt_amb, 
 			olv_limp->inww_amb[i_amb+k*olv_limp->n_amb].pt);
 		guarda_nw_old=TRUE;
 
@@ -2390,7 +2412,7 @@ void Colv_limp_thr::comprueba_amb_lejos(int i_amb )
 			for(h=0;h<KK;h++)
 			{
 				pt_amb2 = ientamb2.getPto((npt_amb2-1)*h);
-				dist_aux=GeometryFunction::Dist2d(pt_amb, pt_amb2);
+				dist_aux=Dist2d(pt_amb, pt_amb2);
 				if(dist_aux<dmin)
 				{
 					dmin=dist_aux;
@@ -11059,6 +11081,16 @@ void Colv_limp_thr::borra_temp_files(BOOL todo/*=TRUE*/)
 	dm.borra_archivos(olv_limp->olv->paths.path_temp,TASKS_EXT_DIS,TRUE);
 }
 //*************************************************************************************
+//Devuelve la distancia 2D pero tiene en cuenta si hay z
+double Colv_limp_thr::Dist2d(double *pt1, double *pt2)
+{
+	//si tienen distinta z
+	if (olv_limp->revisa_elev && (pt1[2] != pt2[2]))
+		return MAYUSCULO;
+	
+	return GeometryFunction::Dist2d(pt1, pt2);
+}
+//*************************************************************************************
 //*************************************************************************************
 //*************************************************************************************
 //*************************************************************************************

Olivia/olv_limp_thr.h

@@ -146,8 +146,8 @@ public:
 	BOOL rellena_info_amb();
 	void rellena_elev_nw();
 	BOOL revisa_elev_nw();
-	std::map<int, Info_aso_conj_elev> busca_elev_nw();
+	std::vector<Info_aso_conj_elev> busca_elev_nw();
-	BOOL mueve_distint_elev_nw(std::map<int, Info_aso_conj_elev> conj_elev);
+	BOOL mueve_distint_elev_nw(std::vector<Info_aso_conj_elev> conj_elev);
 	BOOL replica_peat();
 	void mejora_barr_mix();
 	void mejora_barr_mix_sub(int ithr);
@@ -300,6 +300,8 @@ public:
 	BOOL task_dj_fin();
 	void borra_temp_files(BOOL todo=TRUE);
 
+	double Dist2d(double* pt1, double* pt2);
+
 	//Para los viajes
 	void cuenta_tramos();
 	virtual void rellena_tramos();

includes/Utiles/CartoBaseElements.h

@@ -112,7 +112,7 @@ public:
 	double getLong();
 	double disMedLines(SetPtsR *line2, double l_avan, double *desv=NULL);
 	double disMedLines(SetPtsR *line2, double *desv=NULL);
-	double DisPtoLine(double*p, int* idpto=NULL, double *lamb=NULL);
+	double DisPtoLine(double*p, int* idpto=NULL, double *lamb=NULL, BOOL usa_z=FALSE);
 	SetPtsW *GetNPrimePtos(SetPtsW *ldst, int nptos, double dis, BOOL avanza);
 	bool DivLine(SetPtsW* ldst1, SetPtsW* ldst2,  int ip, double lamb);
 	double *GetPtoDis(double dis, double *dst, double *distTot);

includes/Utiles/GeometryFunction.h

@@ -32,7 +32,7 @@ public:
 	//calcula envoltura convexa
 	static Cgarray<double[3]>* EnvConvex(SetPtsR* pts, Cgarray<double[3]>* dst);
 	//distancia de un punto a una linea
-	static double DisPtoLine(SetPtsR* line, double*p, int* idpto=NULL, double *lamb=NULL);
+	static double DisPtoLine(SetPtsR* line, double*p, int* idpto=NULL, double *lamb=NULL, BOOL usa_z = FALSE);
 	//distancia media entre dos líneas
 	static double DisMedLines( SetPtsR* line1, SetPtsR* line2, double *desv=NULL);
 	static double DisMedLines( SetPtsR* line1, SetPtsR* line2, double l_avan, double *desv=NULL);