Arreglos lee secuencia

Olivia/olv_limp_def.h

@@ -398,7 +398,7 @@ typedef struct Info_est_amb
  */
 typedef struct Info_elem_planif
 {
-	short			aux;		//<Variable auxiliar, indica en recogida si es ámbito en el que se va o vuelve a descargar			
+	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

Olivia/olv_limp_thr.cpp

@@ -6677,7 +6677,7 @@ BOOL Colv_limp_thr::lee_secto()
 		olv_limp->sec[i].namb = (int)it->second.size();		
 		if(!secuen_vacia && ! secuen_incompleta)//se ha indicado toda la secuencia en l_secuen
 		{
-			olv_limp->sec[i].iamb_ini_def = l_secuen[it->first][1];			
+			olv_limp->sec[i].iamb_ini_def = -1;// l_secuen[it->first][1];
 			for (ia = 1; ia < olv_limp->sec[i].namb + 1; ia++)
 			{
 				olv_limp->sec[i].iamb[ia - 1] = l_secuen[it->first][ia];
@@ -6696,7 +6696,11 @@ BOOL Colv_limp_thr::lee_secto()
 		}
 	}
 	if (!secuen_vacia && !secuen_incompleta)//se ha indicado toda la secuencia en l_secuen
+	{
 		olv_limp->usa_secuen = TRUE;
+		//loguea  
+		pon_mi_msg("Usa información de secuencia de la capa de entrada");
+	}
 
 fin:
 
@@ -7034,7 +7038,7 @@ BOOL Colv_limp_thr::planifica()
 	memset(olv_limp->plan,0,olv_limp->nsec*sizeof(Info_planif));
 
 	//lanza los threads
-	lanza_subthrs(OLV_LIMP_EV_PLANIFICA_SUB);
+	lanza_subthrs(OLV_LIMP_EV_PLANIFICA_SUB,1);
 
 	return TRUE;
 }
@@ -7135,21 +7139,35 @@ void Colv_limp_thr::planifica_sub_1(int ithr,  Matrix2d<float> &cost_amb)
 		s->cost_despl_aux=0;
 		sig=FALSE;
 
-		//busca el ámbito inicial de la planificiación
+		//si venía secuencia en el archivo, se utiliza esa
-		secu_ambi=planifica_sect(s,olv_limp->ang_conj, OLV_LIMP_FACT_PERM);		
+		if (olv_limp->usa_secuen)
-		if(!secu_ambi)
 		{
-			olvlog(LOG_TODO,"olv_limp_t","Subthr %ld, Imposible planificar sector %02d",ithr,is);
+			secu_ambi = planifica_sect_dada_secuen(s);
-			sal=TRUE;
+			if (!secu_ambi)
-			continue;
+			{
+				olvlog(LOG_TODO, "olv_limp_t", "Subthr %ld, Imposible planificar sector %02d", ithr, is);
+				sal = TRUE;
+				continue;
+			}
 		}
-		if(esta_repe(secu_ambi, s->namb))			
+		else
 		{
-			olvlog(LOG_TODO,"olv_limp_t","Esta repe despues de planifica sec");
+			//si no venía, se planifica el sector
-			sal=TRUE;
+			//busca el ámbito inicial de la planificiación
-			continue;
+			secu_ambi = planifica_sect(s, olv_limp->ang_conj, OLV_LIMP_FACT_PERM);
+			if (!secu_ambi)
+			{
+				olvlog(LOG_TODO, "olv_limp_t", "Subthr %ld, Imposible planificar sector %02d", ithr, is);
+				sal = TRUE;
+				continue;
+			}
+			if (esta_repe(secu_ambi, s->namb))
+			{
+				olvlog(LOG_TODO, "olv_limp_t", "Esta repe despues de planifica sec");
+				sal = TRUE;
+				continue;
+			}
 		}
-		
 		///////////////////////////////////////////
 		//Añade la ruta de la instalación al primer punto
 		if(olv_limp->nod_instal>=0 && olv_limp->ord_sec_plan)
@@ -7553,8 +7571,7 @@ BOOL Colv_limp_thr::genera_planif_aux(int is, Info_sec *ss, Info_planif *pp, int
 
 				dt=OLV_TTO;
 				ambs_sec[k]=1;
-			}
+			}			
-
 		}
 		else if(olv_limp->iaso[ref_j].flgs & OLV_LIMP_FLG_SEG_LIN) //es segmento de ámbito
 		{
@@ -7619,7 +7636,7 @@ BOOL Colv_limp_thr::genera_planif_aux(int is, Info_sec *ss, Info_planif *pp, int
 		pp->elem[nelesec].ref_nw = ref_nw;	
 		pp->elem[nelesec].coste = cost_parc_aux + cost;
 		pp->elem[nelesec].ltot = ltot;
-		pp->elem[nelesec].aux=0;
+		pp->elem[nelesec].aux=0;		
 
 		//////////////
 		if(dt<OLV_DT_N)
@@ -9411,6 +9428,21 @@ BOOL Colv_limp_thr::genera_list_rut_ctrl()
 			else if((pp->elem[i].ref_nw>0) && (!(olv_limp->iaso[pp->elem[i].ref_nw].flgs & OLV_LIMP_FLG_NW)) && 
 				(pp->elem[i].tp == OLV_PLAN_TIP_AMB_PEAT))
 				strcpy_s(calle,1024,"Parque---");
+			else if ((pp->elem[i].ref_nw > 0) && (olv_limp->iaso[pp->elem[i].ref_nw].flgs & OLV_LIMP_FLG_AMB))
+			{
+				//apunta a otro ámbito de la red, busca carretera
+				int ref_nw = pp->elem[i].ref_nw;
+				BOOL sdire=false;
+				while ((ref_nw>0) && (olv_limp->iaso[ref_nw].flgs & OLV_LIMP_FLG_AMB))
+				{
+					ref_nw= olv_limp->inww_amb[ref_nw + !sdire * olv_limp->n_amb].refnw;
+					sdire = !sdire && (olv_limp->tipo_ambit== OLV_AMB_LIN);
+				}
+				if((olv_limp->iaso[ref_nw].flgs & OLV_LIMP_FLG_NW) && olv_limp->iaso[ref_nw].inf_n.nomb)
+					strcpy_s(calle, 1024, olv_limp->iaso[ref_nw].inf_n.nomb);
+				else
+					calle[0] = 0;				
+			}
 			else
 				calle[0]=0;
 
@@ -9646,6 +9678,76 @@ BOOL Colv_limp_thr::guarda_dbf_sector(int modo)
 	return TRUE;
 }
 //*************************************************************************************
+/**
+ * Planifica o calcula el orden en el que hay que recorrer los ambitos del sector s
+ * y los nodos de entrada y salida de cada ámbito en caso de ámbito lineal
+ * dada la secuencia que ha leído en la capa
+ */
+Secu_amb* Colv_limp_thr::planifica_sect_dada_secuen(Info_sec* s)
+{
+	Secu_amb* sec;
+	sec = (Secu_amb*)malloc(s->namb * sizeof(Secu_amb));
+	if (!sec)
+		goto sal;
+	memset(sec, 0, s->namb * sizeof(Secu_amb));
+
+	double d = MAYUSCULO, d1 = MAYUSCULO;
+	int nsal, nent;
+	int k, j;
+	int isec;
+
+	//busca por dónde entra a la secuencia
+	//coge el primer ámbito y busca el nodo más cercano al ámbito siguiente
+	//solo si es de tipo lineal
+	nent = nsal = 0;
+	if (s->namb > 1)
+	{
+		for (k = 0; k < olv_limp->tipo_ambit; k++)
+		{
+			for (j = 0; j < olv_limp->tipo_ambit; j++)
+			{
+				d1 = olv_limp->arch_dj.dame_dis(s->iamb[0], k, s->iamb[1], j);
+				if (d1 < d)
+				{
+					d = d1;
+					nent = j;
+					nsal = k;
+				}
+			}
+			if (d >= MAYUSCULO)
+				return NULL;
+		}
+		sec[1].entrada = nent;
+		sec[1].iamb = 1;
+		sec[1].flags = 1;
+	}
+	sec[0].entrada = (nsal + 1) % 2;
+	sec[0].iamb = 0;
+	sec[0].flags = 1;
+
+	for (isec = 2; isec < s->namb; isec++)
+	{
+		d = MAYUSCULO;
+		for (j = 0; j < olv_limp->tipo_ambit; j++)
+		{
+			d1 = olv_limp->arch_dj.dame_dis(s->iamb[isec-1], (sec[isec - 1].entrada + 1) % 2, s->iamb[isec], j);
+			if (d1 < d)
+			{
+				d = d1;
+				nent = j;
+			}
+		}
+		if (d >= MAYUSCULO)
+			return NULL;
+		sec[isec].entrada = nent;
+		sec[isec].iamb = isec;
+		sec[isec].flags = 1;
+	}
+	pon_t_desp(s, sec);
+sal:
+	return sec;
+}
+//*************************************************************************************
 /**
  * Planifica o calcula el orden en el que hay que recorrer los ambitos del sector s
  * la idea es partir de una solucion factible (la cual se consigue por distancias minimas)

Olivia/olv_limp_thr.h

@@ -247,7 +247,9 @@ public:
 	BOOL genera_list_rut_ctrl();
 	virtual void quita_t_ult_desc(int s, double *t);
 	virtual BOOL genera_list_fila_vaci(Colv_csv *cc, char *fila0,int ielem, int s, int ii, double tt, double *t0,BOOL is_fin);
-	BOOL guarda_dbf_sector(int modo);	
+	BOOL guarda_dbf_sector(int modo);
+	Secu_amb* planifica_sect_dada_secuen(Info_sec* s);
+
 	virtual BOOL gen_guard_subtramos();
 	BOOL genera_rut_aux(Info_planif *pp, int is, BOOL is_insta, int ie_ini, int ie_fin);
 	BOOL genera_rut_ctrl(int ns, Info_planif *planif, BOOL tramos);