Cambios para leer secuencia que entra. Falta terminar para que desde fuera, si ha recibido secuencia, haga el paso de planificar diferente, solo entre ámbitos.

Olivia/olv_limp_thr.cpp

@@ -6562,6 +6562,152 @@ double Colv_limp_thr::dame_coste_ex( Secu_amb * sec, int ini, int fin,  Info_sec
  * Lee la sectorización que viene como info asociada en el shp de entrada
  */
 BOOL Colv_limp_thr::lee_secto()
+{
+	BOOL ret;
+	int i, s, idd, ics, icsq;
+	char nfile[MAX_PATH];
+	int* info;
+	Cb_file f;
+	Fdbf dbf;
+	int sector, secuen;
+
+	ret = TRUE;
+	std::map<int, std::vector<int>> l_sec;
+	std::map<int, std::map<int, int>> l_secuen;
+
+	olvlog(LOG_TODO, "olv_limp_t", "Comienza lectura de sectorización");
+	pon_mi_progre(OLV_TAREA_LEE_SECTO, 0);
+	pon_mi_msg("");
+	err_str[0] = 0;
+
+	/////////////////////////////////////	
+	info = (int*)malloc(olv_limp->n_amb * sizeof(int));
+	if (!info)
+	{
+		sprintf_s(err_str, OLV_MAX_ERR, "Error, sin memoria para info asociada");
+		return FALSE;
+	}
+	memset(info, 0, olv_limp->n_amb * sizeof(int));
+
+	//lee dbf del shp la columna SECTOR
+	strcpy_s(nfile, MAX_PATH, olv->paths.path_data);
+	//cambiaext(nfile,".shp",".dbf");
+	strcpy((Cdir_manager::extension_archivo(nfile)), "dbf");
+	if (!f.abre(nfile, 1) || !dbf.lee(&f))
+	{
+		ret = FALSE;
+		goto fin;
+	}
+	ics = dbf.findCol(olv_limp->camps.campo_secto);
+	icsq = dbf.findCol(olv_limp->camps.campo_secuen);
+	if (ics < 0 || icsq < 0)
+	{
+		ret = FALSE;
+		goto fin;
+	}
+
+	idd = dbf.leeNexRow();
+	//rellena para cada sector info[i] qué ámbitos tiene
+	for (i = 0; i < olv_limp->n_amb && idd == 1; i++)
+	{
+		if (olv_limp->iaso[olv_limp->carto.get(i).entity()->ref].flgs & OLV_LIMP_FLG_AMB_NO)
+		{
+			idd = dbf.leeNexRow();
+			continue;
+		}
+
+		sector = dbf.getI(ics);
+		l_sec[sector].push_back(i);//va añadiendo al sector los elementos
+		secuen = dbf.getI(icsq);
+		if (secuen > 0)//se indica en qué secuencia va ese elemento
+		{
+			l_secuen[sector][secuen] = i;
+		}
+		idd = dbf.leeNexRow();
+	}
+	if (i < olv_limp->n_amb)
+	{
+		ret = FALSE;
+		goto fin;
+	}
+	olv_limp->nsec = (int)l_sec.size();
+	////////////////////////////////////////
+	//revisa si todos los ámbitos de todos los sectores tienen secuencia
+	bool secuen_incompleta = false;
+	for (std::map<int, std::map<int, int>>::iterator it = l_secuen.begin(); it != l_secuen.end(); ++it)
+	{
+		if (it->second.size()>0 && (l_sec[it->first].size() != it->second.size()))//no ha almacenado el mismo número de ámbitos en los dos arrays
+		{
+			secuen_incompleta = true;
+			break;
+		}
+		for (i = 1; i < it->second.size()+1; i++)
+		{
+			if (it->second.find(i)==it->second.end()) //si alguna secuencia no existe
+			{
+				secuen_incompleta = true;
+				break;
+			}
+		}
+	}
+	if (secuen_incompleta)
+	{
+		//loguea error 
+		pon_mi_msg("Se descarta información de secuencia por encontrarse elementos incompletos o repetidos");
+	}
+	////////////////////////////////////////
+	//inicia los arrays para la sectorización
+	if (!pide_memo_secto())
+	{
+		sprintf_s(err_str, OLV_MAX_ERR, "Error, Sin memoria para lectura de sectorización");
+		ret = FALSE;
+		goto fin;
+	}
+	////////////////////////////////////////
+	//recoge los datos, revisando que estén las secuencias completas
+	i = -1;//sector
+	int ia = 0;
+	for (std::map<int, std::vector<int>>::iterator it = l_sec.begin(); it != l_sec.end(); ++it)
+	{
+		i++;
+		olv_limp->sec[i].sec_def = it->first;
+		olv_limp->sec[i].namb = (int)it->second.size() - 1;
+		if (secuen_incompleta) //añade los elementos según los ha leído
+		{
+			olv_limp->sec[i].iamb_ini_def = -1;
+			for (ia = 1; ia < olv_limp->sec[i].namb + 1; ia++)
+			{
+				olv_limp->sec[i].iamb[ia - 1] = it->second[ia];
+				olv_limp->amb_sec[it->second[ia]].sec = i;
+			}
+		}
+		else//se ha indicado toda la secuencia en l_secuen
+		{
+			olv_limp->sec[i].iamb_ini_def = 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];
+				olv_limp->amb_sec[l_secuen[it->first][ia]].sec = i;
+			}
+		}
+	}
+
+fin:
+
+	free(info);
+
+	if (!ret)
+	{
+		pon_mi_msg("Error en lectura de info de sectorización: %s", err_str);
+	}
+
+	return ret;
+}
+//*************************************************************************************
+/**
+ * Lee la sectorización que viene como info asociada en el shp de entrada
+ */
+BOOL Colv_limp_thr::lee_secto_old()
 {
 	BOOL ret;
 	int i,s,idd, ics, icsq;
@@ -6573,6 +6719,7 @@ BOOL Colv_limp_thr::lee_secto()
 
 	ret = TRUE;
 	std::map<int,std::vector<int>> l_sec;
+	std::map<int, std::map<int,int>> l_sec_;
 
 	olvlog(LOG_TODO,"olv_limp_t","Comienza lectura de sectorización");
 	pon_mi_progre(OLV_TAREA_LEE_SECTO, 0);
@@ -6619,9 +6766,10 @@ BOOL Colv_limp_thr::lee_secto()
 		sector=dbf.getI(ics);
 		if (l_sec[sector].size() == 0)
 		{
-			//inicializa el array
+			//inicializa el array con -1
-			//A MEDIAS
+			//lo inicializa al número de ámbitos, no sabe a priori cuántos tendrá este sector
-			
+			for (j = 0; j < olv_limp->n_amb; j++)
+				l_sec[sector].push_back(-1);			
 		}
 		secuen = dbf.getI(icsq);
 		if (secuen > 0)//se indica en qué secuencia va ese elemento

Olivia/olv_limp_thr.h

@@ -227,6 +227,7 @@ public:
 
 	//Lee secto
 	BOOL lee_secto();
+	BOOL lee_secto_old();
 
 	//Calcula el número de sectores
 	BOOL calcula_n_sec();